         assert symbol = @constructor.ACCESS_ENTITY_SYMBOL
         assert session = container?.session, noSession
         assert _.isObject(entity), "malformed entity"
-        @hibernateEntity ?= (xe, xn) -> xn null, xe
+        surrogate = _.unique @constructor.hibernation()
+        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)
+        @hibernateEntity ?= (c, fn) -> fasn _.clone(c), fn
         @hibernateEntity entity, (error, content) =>
             return callback error, undefined if error
             assert not _.isEmpty(content), "no content"

    # 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 = ressurections: 1, hibernations: 1

    # Add the supplied implementation function to the internal stack
    # of function that will be invoked each the time the access system
    # is ressurecting 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.
    @ressurection: (xoptions, ximplement) ->
        noOptions = "the options must be an object"
        noImplement = "must have implementation body"
        noSignature = "function has invalid signature"
        message = "Install session ressurector in %s"
        assert identify = this.identify().underline
        implement = _.find arguments, _.isFunction
        options = _.find arguments, _.isPlainObject
        assert previous = @ressurections 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 @ressurections = 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, ressurects 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.

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

    # Authenticate supplied entity as the authorized entity against
