         return callback() unless session = container.session
         return callback() unless content = session[sid]
         delete container[key] if _.has container, key
-        surrogate = _.unique @constructor.ressurection()
+        surrogate = _.unique @constructor.resurrection()
         functions = (o.implement.bind @ for o in surrogate)
         boxd = (obj) -> (apply fn, obj for fn in functions)
         fasn = (o, c) -> series boxd(o), (e, r) -> c(e, o)
-        @ressurectEntity ?= (c, fn) -> fasn _.clone(c), fn
-        @ressurectEntity content, (error, entity) =>
-            format = (m) -> "ressurection error: #{m}"
+        @resurrectEntity ?= (c, fn) -> fasn _.clone(c), fn
+        @resurrectEntity content, (error, entity) =>
+            format = (m) -> "resurrection error: #{m}"
             masked = format error.message if error
             return callback Error masked if error
             s = enumerable: no, configurable: yes

            p.get = s.get = -> entity or undefined
            Object.defineProperty container, key, p
            Object.defineProperty session, key, p
            @emit "ressurect", container, entity
            assert container[key]?; callback()

    # Authenticate supplied entity as the authorized entity against

    # counterparts in the destination, once the composition process
    # takes place. See the `Archetype::composition` hook definition
    # for more information. Keys are names, values can be anything.
    @COMPOSITION_EXPORTS = resurrections: 1, hibernations: 1

    # Add the supplied implementation function to the internal stack
    # of functions that will be invoked every time the access system
    # is resurrecting the entity out of the session. These functions
    # will be called asynchronously, with an ability to abruptly end
    # the execution. Please consult with the `async` package and the
    # source code of this method for more details on the mechanics.
    @resurrection: (xoptions, ximplement) ->
        noOptions = "the options must be an object"
        noImplement = "must have implementation body"
        noSignature = "function has invalid signature"
        message = "Install session resurrector in %s"
        assert identify = this.identify().underline
        implement = _.find arguments, _.isFunction
        options = _.find arguments, _.isPlainObject
        assert previous = @resurrections or Array()
        return previous unless arguments.length > 0
        assert _.isObject(options or {}), noOptions
        assert _.isFunction(implement), noImplement
        assert (implement.length) > 1, noSignature
        logger.debug message.yellow, identify.bold
        fn = (arbitraryVector) -> return implement
        return fn @resurrections = previous.concat
            implement: implement or _.noop
            options: options or Object()

    # Add the supplied implementation function to the internal stack
    # of functions that will be invoked every time the access system
    # is hibernating the entity inside the session. These functions
    # will be called asynchronously, with an ability to abruptly end
    # the execution. Please consult with the `async` package and the
    # source code of this method for more details on the mechanics.
    @hibernation: (xoptions, ximplement) ->
        noOptions = "the options must be an object"
        noImplement = "must have implementation body"
        noSignature = "function has invalid signature"
        message = "Install session hibernator in %s"
        assert identify = this.identify().underline
        implement = _.find arguments, _.isFunction
        options = _.find arguments, _.isPlainObject
        assert previous = @hibernations or Array()
        return previous unless arguments.length > 0
        assert _.isObject(options or {}), noOptions
        assert _.isFunction(implement), noImplement
        assert (implement.length) > 1, noSignature
        logger.debug message.yellow, identify.bold
        fn = (arbitraryVector) -> return implement
        return fn @hibernations = previous.concat
            implement: implement or _.noop
            options: options or Object()

    # Dereference the potentially existent entity from the session
    # into the supplied container, where the session is residing. It
    # basically retrieves the hibernated entity, resurrects it and
    # defined the appropriate getter property on supplied container.
    # If the entity or session does not exist, nothing gets defined.
    # Please refer to source code, as it contains important details.
