         $item.append children
         $item
 
-    run_context = _.extend {}, extra_contexts...,
+    run_context_prototype = _.extend {}, extra_contexts...,
       current_options: {}
       renderable_list_builder: delayed_renderable_list_builder $ '<div/>'
-      _lead_render: -> run_context.current_context.renderable_list_builder._lead_render()
-      active_context: ->
-        console.warn 'no active running context. did you call an async function without keeping the context?' unless running_context_binding?
-        run_context.current_context
+      _lead_render: -> @renderable_list_builder._lead_render()
 
       running_context: -> running_context_binding
 
-      options: -> run_context.current_context.current_options
-
-      in_context: (context, fn, args) ->
-        previous_context = run_context.current_context
-        run_context.current_context = context
+      options: -> @current_options
+
+      apply_to: (fn, args) ->
+        previous_context = scope_context.current_context
+        scope_context.current_context = @
         try
-          fn.apply context, args
+          fn.apply @, args
         finally
-          run_context.current_context = previous_context
+          scope_context.current_context = previous_context
 
       in_running_context: (fn, args) ->
         throw new Error 'no active running context. did you call an async function without keeping the context?' unless running_context_binding?
-        run_context.in_context running_context_binding, fn, args
+        running_context_binding.apply_to fn, args
 
       # returns a function that calls its argument in the current context
       capture_context: ->
-        context = run_context.current_context
+        context = @
         running_context = running_context_binding
         (fn, args) ->
           previous_running_context_binding = running_context_binding
           running_context_binding = running_context
           try
-            run_context.in_context context, fn, args
+            context.apply_to fn, args
           finally
             running_context_binding = previous_running_context_binding
 
       # wraps a function so that it is called in the current context
       keeping_context: (fn) ->
-        restoring_context = run_context.capture_context()
+        restoring_context = @capture_context()
         ->
           restoring_context fn, arguments
 
       add_renderable: (renderable) ->
-        run_context.current_context.renderable_list_builder.add_renderable renderable
+        @renderable_list_builder.add_renderable renderable
         ignore
 
       add_rendered: (rendered) ->
-        run_context.add_rendering -> rendered
-
-      add_rendering: (rendering) -> run_context.add_renderable _lead_render: run_context.keeping_context(rendering)
+        @add_rendering -> rendered
+
+      add_rendering: (rendering) -> @add_renderable _lead_render: @keeping_context(rendering)
 
       render: (o) -> o._lead_render()
 

            "#{ms} ms"

        renderable = immediate_renderable_list_builder $item
        run_context.add_renderable renderable
        nested_context = run_context.create_nested_context
          renderable_list_builder: renderable

        promise = run_context.in_context nested_context, fn
        promise.then ->
          $item.attr 'data-async-status', "loaded in #{duration()}"
        promise.fail ->
          $item.attr 'data-async-status', "failed in #{duration()}"
        promise

    run_context.fns = bind_context_fns run_context, run_context.imported_context_fns
    fns_and_vars = bind_context_fns run_context, run_context.context_fns
    _.each run_context.vars, (vars, name) -> _.extend (fns_and_vars[name] ?= {}), vars
    _.extend fns_and_vars, fns_and_vars.builtins
    _.each fns_and_vars, (mod, name) ->
      if run_context[name]?
        console.warn mod._lead_context_name, 'would overwrite core'
      else
        run_context[name] = mod
    run_context.current_context = run_context

    run_context

  scope = (run_context) ->
    _.extend {}, run_context.fns, run_context.imported_vars

  bind_context_fns = (run_context, fns, name_prefix='') ->
    bind_fn = (name, op) ->
      bound = (args...) ->
        if @imported_context_fns? and @ != run_context.current_context
          # it looks like this is a context, but not the current one
          console.warn 'mismatched run context'
          console.trace()
        # if the function returned a value, unwrap it. otherwise, ignore it
        op.fn.apply(run_context.current_context, args)?._lead_context_fn_value ? ignore
      bound._lead_context_fn = op
      bound._lead_context_name = name
      bound
