         assert @middleware = @router.middleware
         @middleware = @middleware.bind @router
         assert _.isFunction @middleware; this
+
+    # Setup a set of appropriate Connect middlewares that will take
+    # care of serving static directory content for all configured
+    # assets directory, using the options drawed from configuration.
+    # You should override the method to tweak the creation process.
+    # Please see the `serveStaticDirectory` method implementation.
+    connectStaticAssets: ->
+        envs = nconf.get "env:dirs" or Array()
+        dirs = nconf.get "assets:dirs" or Array()
+        opts = nconf.get "assets:opts" or Object()
+        pub = -> _.find envs, (dir) -> dir is "pub"
+        established = try "#{__dirname}/../../public"
+        assert _.isString(pub()), "no pub environment"
+        assert _.isObject(opts), "wrong assets options"
+        assert _.isArray(dirs), "no assets directories"
+        @serveStaticDirectory d, opts for d in dirs
+        @serveStaticDirectory established, Object()
+        @serveStaticDirectory pub(); return this
+
+    # Either get or set an identica token. This token is application
+    # identification string of a free form, but usually formed by a
+    # app name plus a verion after the at sign. If no arguments are
+    # supplied, the method will get identica, otherwise - attempt to
+    # set one. If there is no identica - it asks the configuration.
+    @identica: (identica) ->
+        assert cns = "identica:compiled".toString()
+        automatic = => f(@$identica or nconf.get cns)
+        functional = _.isFunction identica or null
+        i = (fn) => return fn.apply this, arguments
+        f = (x) => if _.isFunction x then i(x) else x
+        return automatic() if arguments.length is 0
+        return @$identica = identica if functional
+        noIdentica = "the identica is not a string"
+        assert _.isString(identica), noIdentica
+        assert @$identica = identica.toString()
+        return @emit? "identica", arguments...
+
+    # The utilitary method that is being called by either the kernel
+    # or scope implementation to establish the desirable facade for
+    # logging. The options from the config may be used to configure
+    # various options of the logger, such as output format, etc.
+    setupLoggingFacade: ->
+        assert _.isObject @logging = logger
+        assert format = "DD/MM/YYYY @ HH:mm:ss"
+        stamp = -> return moment().format format
+        options = timestamp: stamp, colorize: yes
+        options.level = nconf.get "log:level" or 0
+        noLevel = "No logging level is specified"
+        throw new Error noLevel unless options.level
+        assert console = logger.transports.Console
+        try do -> logger.remove console catch error
+        logger.add console, options; return this
+
+    # Create and wire in an appropriate Connext middleware that will
+    # serve the specified directory as the directory with a static
+    # content. That is, it will expose it to the world (not list it).
+    # The serving aspects can be configured via a passed in options.
+    serveStaticDirectory: (directory, options={}) ->
+        assert cwd = try process.cwd().toString()
+        solved = try paths.relative cwd, directory
+        serving = "Serving %s as static assets dir"
+        notExist = "The assets dir %s does not exist"
+        fail = -> logger.warn notExist, solved.underline
+        return fail() unless fs.existsSync directory
+        middleware = connect.static directory, options
+        logger.info serving.cyan, solved.underline
+        try @connect.use middleware; return this

    # an actual application. This method gets passes continuation
    # that does that. The method can either invoke it or omit it.
    kernelPreemption: (continuation) -> continuation.apply this

    # Either get or set an identica token. This token is application
    # identification string of a free form, but usually formed by a
    # app name plus a verion after the at sign. If no arguments are
    # supplied, the method will get identica, otherwise - attempt to
    # set one. If there is no identica - it asks the configuration.
    @identica: (identica) ->
        assert cns = "identica:compiled".toString()
        automatic = => f(@$identica or nconf.get cns)
        functional = _.isFunction identica or null
        i = (fn) => return fn.apply this, arguments
        f = (x) => if _.isFunction x then i(x) else x
        return automatic() if arguments.length is 0
        return @$identica = identica if functional
        noIdentica = "the identica is not a string"
        assert _.isString(identica), noIdentica
        assert @$identica = identica.toString()
        return @emit? "identica", arguments...

    # An embedded system for adding ad-hoc configuration routines.
    # Supply the reasoning and the routine and this method will add

        @connect.use @send = plumbs.send this
        @connect.use @middleware; return this

    # This method sets up the necessary internal toolkits, such as
    # the determined scope and the router, which is then are wired
    # in with the located and instantiated services. Please refer
