         assert mw = @constructor.middleware().bind this
         signature = [request, response, variables...]
         message = "Executing Crossroads routing in %s"
-        intake = (func) => downstream processing: func
+        intake = (func) => @downstream processing: func
         go = (fn) => usp = intake fn; usp signature...
         go => mw(signature) (error, results, misc) =>
             assert expanded = _.clone variables or []

    # This implementation sets up the internals of the API service
    # that will allow to properly expose and execute the methods.
    register: (kernel, router, next) ->
        msgs = "Setting up Crossroads service in %s"
        invalidDefs = "invalid type of the definitions"
        emptyDoc = "the document sequence is not emptied"
        noCrossr = "unable to load a Crossroads library"
        noInh = "cannot be inherited from both toolkits"
        try identify = @constructor.identify().underline
        assert not (try this.objectOf Screenplay), noInh
        assert crs = @crossroads = crossroads.create()

        assert _.isArray(defines or null), invalidDefs
        assert _.isEmpty(@constructor.doc()), emptyDoc
        assert _.isObject(@crossroads or 0), noCrossr
        assert amount = defines.length.toString().bold
        try logger.debug noted.yellow, amount, identify
        async.each defines, createRouteWrapper, next

    # Part of the internal implementation of the API engine. It
    # is used to create the wrapping around the Crossroads route
    # handler. This wrapping is very tightly inegrated with this
    # abstract base class internals, as well as with the internal
    # design of some of the parent classes, namely `RestfulService`.
    # The wrapping provides important boilerplate to set up scope.
    createRouteWrapper: (definition, next) ->
        register = "Adding Crossroads route %s to %s"
        noCross = "no Crossroads router in the service"
        assert _.isObject(crs = @crossroads), noCross
        identify = @constructor.identify().underline
        assert method = try definition.method or null
        assert implement = definition.implement or 0
        assert rules = rls = definition.rules or {}
        assert not _.isEmpty mask = definition.mask
        assert p = (mask.source or mask).underline
        logger.debug register.magenta, p, identify
        fr = (q) => q.method.toUpperCase() is method
        rx = (r) => r.rules = rls; rls.request_ = fr
        fx = (f) => rx crs.addRoute mask, f; next()
        fx (shadow, parameters...) -> # the wrapper
            assert (shadow.__isolated or 0) is yes
            assert _.isObject shadow.__origin or 0
            implement.apply shadow, parameters

    # Class directive that sets the specified documentations in
    # the documentation sequence that will be used & emptied when
