         assert not (routable in (@registry or [])), duplicate
         assert register = routable.downstream register: =>
             attaching = "Attaching %s service instance"
+            this.emit "register", routable, @kernel
+            (this.registry ?= []).unshift routable
             logger.info attaching.blue, inspected
-            @emit "register", routable, @kernel
-            (@registry ?= []).unshift routable
             return unless _.isFunction callback
             return callback routable, this
         register @kernel, this; return @

    # If something is wrong, this method will throw an exception.
    # The method is idempotent, ergo no duplication of routables.
    register: (routable, callback) ->
        assert identify = routable.constructor.identify()
        assert inspected = try identify.toString().underline
        [matches, process] = [routable.matches, routable.process]
        goneMatches = "The #{identify} has no valid matches method"

    # transfers the control to the pre-installed, default routable.
    # A set of tests are performed to ensure the logical integrity.
    middleware: (request, response, next) ->
        assert incoming = try request.url.underline
        p = (i, c) -> i.matches request, response, c
        final = (service) -> service.abstract?() is no
        assert registry = @registry, "missing registry"
        signature = arguments if _.isArguments arguments
        implemented = _.toArray _.filter registry, final
        matching = "Incoming request %s matches %s service"
        missing = "Request %s does not match to any service"
        async.detectSeries implemented, p, (recognized) =>
            success = ok = _.isObject recognized or null
            logger.debug missing.grey, incoming unless ok
            return next undefined unless ok # shortcircuit
            assert constructor = recognized.constructor
            identify = constructor?.identify()?.underline
            @emit "recognized", recognized, signature...
