         method = external method unless isRemote
         assert _.isFunction(method), notFunction
         parameters = {} unless _.isObject parameters
-        method.remote.autocall = parameters
-        assert parameters; return method
+        method.remote.autocall = parameters; method
+
+    # The awaiting directive is a lot like `autocall`, except the
+    # implementation will not be immediatelly , but rather when the
+    # specified signal is emited on the current context (service)
+    # object. Effectively, it is the same as creating the autocall
+    # that explicitly binds the event using `on` with the context/
+    @awaiting: (event, method) ->
+        isRemote = _.isObject method?.remote
+        notFunction = "no function is passed"
+        invalidEvent = "invalid event supplied"
+        method = external method unless isRemote
+        assert _.isFunction(method), notFunction
+        assert not _.isEmpty(event), invalidEvent
+        assert method.remote.autocall = Object()
+        method.remote.auto = (symbol, key) -> ->
+            t = "#{symbol}.on(%s, #{symbol}.#{key})"
+            return format t, JSON.stringify event
+        method.remote.meta = event: event; method
 
     # This server side method is called on the context prior to the
     # context being compiled and flushed down to the client site. The

            return receive context, compiled or null
        return prelude symbol, context, request

    # Get the contents of the resources at the established path. It
    # is a good idea for this HTTP method to be idempotent. As the
    # rule, this method does not have to alter any contents or data
    # of the resource. Use for unobtrusive retrieval of resources.
    GET: (request, response) ->
        symbol = "service".toString().toLowerCase()
        assert args = [symbol, request, yes, undefined]
        @assembleContext args..., (context, compiled) ->

        _.each prototypes, (p) -> _.forOwn p, (value, key) ->
            return yes unless value?.remote?.autocall?
            params = JSON.stringify value.remote.autocall
            auto = a if _.isFunction a = value.remote.auto
            template = "#{symbol}.#{key}.call(#{symbol}, %s)"
            formatted = Object.create String.prototype
            formatted.valueOf = -> format template, params
            formatted.valueOf = auto symbol, key if auto
            formatted.priority = value.remote.autocall.z
            uns = -> context.invokes.unshift formatted
            return uns() if value.remote.autocall.unshift
