     # 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 identify = try routable.constructor.identify()
         assert inspected = try identify.toString().underline
         [matches, process] = [routable.matches, routable.process]
         goneMatches = "The #{identify} has no valid matches method"

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

    # the request off to the service for processing it. Normally it
    # should not be used outside of the router (middleware) coding.
    streamline: (recognized, request, response, next) ->
        ignite = "Launch the ignition sequence in %s"
        rescue = "Setup the rescue handler in the %s"
        assert signature = _.rest arguments or Array()
        identify = try @constructor.identify().underline
        ignition = recognized.downstream ignition: ->
            assert domain = require("domain").create()
            processor = recognized.process.bind recognized
            polished = => processor.apply this, signature
            logger.debug ignite.cyan, identify.toString()
            logger.debug rescue.cyan, identify.toString()
            domain.add eem for eem in [request, response]
            domain.add recognized; domain.on "error", (error) =>
                rescuing = recognized.downstream rescuing: ->
