                 @_props[propName].get()
 
         # Set up @reactives
-        @_reactiveComps = {} # nonDictReactiveName: computation
-        @reactives = {} # reactiveName: reactiveVar|J.AutoDict
+        @reactives = {} # reactiveName: autoVar
         for reactiveName, reactiveSpec of componentSpec.reactives ? {}
-            if reactiveSpec.val?
-                # AutoDicts get initialized later because they
-                # immediately want to run their keyFunc.
-                @reactives[reactiveName] = new ReactiveVar undefined,
-                    reactiveSpec.same ? J.util.equals
+            @reactives[reactiveName] = J.AutoVar(
+                reactiveSpec.val.bind @
+                reactiveSpec.onChange ? null
+                reactiveSpec.same ? J.util.equals
+            )
 
         # Set up @state
         initialState = {}

            @_renderComp.stop()
            @_renderComp = null

        for reactiveName of @reactives
            if reactiveName of @_reactiveComps
                # It's a ReactiveVar
                val = Tracker.nonreactive => @reactives[reactiveName].get()
                if val instanceof J.AutoDict or val instanceof J.AutoList or val instanceof J.AutoVar
                    val.stop()
                @_reactiveComps[reactiveName].stop()
            else
                # It's an AutoDict
                @reactives[reactiveName].stop()
        @_reactiveComps = null
        @reactives = null

        componentSpec.componentWillUnmount?.apply @


    reactSpec.render = ->
        # Make sure we've run all the reactives' val-functions at least once.
        # Even if the render function never uses a reactive, that reactive
        # might need to monitor a value and do some side effect in its onChange.
        for reactiveName, reactiveSpec of componentSpec.reactives
            # We should be able to optimize this by only running
            # reactives with onChange functions, since val functions
            # aren't supposed to have side effects, but whatever.
            @[reactiveName]()

        ###
            There are three times at which a component may be re-rendered:


            renderedComponent = componentSpec.render.apply @

        @_renderComp.onInvalidate (c) =>
            return if c.stopped

            @_renderComp.stop()

            Tracker.afterFlush =>
                # The component may have unmounted
                return unless @isMounted()

                # Between c's invalidation time and now, the component may
                # have been re-rendered at time (1) - see comment above - in
                # which case there would be a new @_renderComp
                return unless c is @_renderComp

                @_renderComp = null
                @forceUpdate()

        renderedComponent

