     # one and the foreign (the one that is beign merged in). Exists
     # for backing up the consistent behavior when using composition.
     @composition: (destination) ->
-        assert _.isObject arche = Archetype
         assert currents = @interceptors or []
         assert from = try @identify().underline
-        return unless destination.derives arche
-        into = destination.identify().underline
+        return unless destination.derives Archetype
+        into = try destination.identify().underline
         message = "Merge intercept from %s into %s"
-        spawn = (x, src) -> _.extend _.clone(x), src
-        previous = destination.interceptors or {}
+        previous = destination.interceptors or []
         assert previous? and _.isObject previous
-        assert merged = spawn previous, currents
+        assert merged = previous.concat currents
+        assert merged = _.toArray _.unique merged
         logger.debug message.blue, from, into
         assert destination.interceptors = merged
         try super catch error; return this

        assert _.isFunction(trap or null), invalid
        assert _.isString(event), "malformed event"
        assert _.isFunction(implement), "#{misused}"
        previous = this.interceptors or new Object()
        spawn = (x, src) -> _.extend _.clone(x), src
        assert a = try _.object [[event, implement]]
        @interceptors = spawn previous, a; implement

    # This is the composition hook that gets invoked when compound
    # is being composed into other services and components. Merges

    constructor: ->
        super if @constructor.__super__ or null
        currents = try @constructor.interceptors
        currents = [] unless _.isArray currents
        ids = @constructor.identify().underline
        msg = "Intercepting an %s event at the %s"
        currents = try _.toArray _.unique currents
        _.each currents, (record, index, linear) =>
            {event, implement} = record or Object()
            assert _.isString event or undefined
            assert _.isFunction implement or null
            assert _.isFunction try this.on or null
