     # a valid __super__ descriptor, among some other prototypal things.
     Object.defineProperty Object::, "rebased",
         enumerable: no, value: (baseclass, force) ->
-            isClass = _.isObject baseclass?.__super__
-            noClass = "The #{baseclass} is not a class"
-            throw new Error noClass unless isClass
-            baseclass.rebasement? this, force
-            p = (k) => force is yes or not this[k]?
-            this[k] = v for k, v of baseclass when p k
-            original = this.prototype or {}; r = this
-            `function ctor() {this.constructor = r}`
-            ctor.prototype = baseclass.prototype
-            this.__super__ = baseclass.prototype
-            this.prototype = new ctor() or original
-            _.extend this.prototype, original; @
+            classed = _.isObject baseclass?.__super__
+            malformed = "the baseclass is not a class"
+            throw new Error malformed unless classed
+            baseclass.rebasement? this, force or false
+            p = (key) => force is yes or not this[key]?
+            this[k] = v for k, v of baseclass when p(k)
+            original = this.prototype or {}; halo = this
+            `function ctor() {this.constructor = halo}`
+            assert ctor.prototype = baseclass.prototype
+            assert this.__super__ = baseclass.prototype
+            try this.prototype = new ctor() or original
+            _.extend this.prototype, original; this

    # invokes the composition functionality to obtain a shadow of the
    # original class that can be later modified to modify hierarchy.
    cloner = module?.exports?.cloner = (subject) ->
        noClass = "the #{subject} is not a class"
        assert _.isObject(subject?.__super__), noClass
        subject = subject.watermark if subject.watermark
        snapshot = _.cloneDeep subject, d = (value) ->
            return unless _.isFunction value
            func = -> value.apply this, arguments
            func.name = value.name or "<anonymous>"
            _.extend func.prototype, value.prototype

    # composition to work - system needs dynamic super method resolution.
    # Call this method with current class and the method name arguments
    Object.defineProperty Object::, "upstack",
        enumerable: no, value: (definition) ->
            wrong = "invalid POJO style definition"
            assert _.isPlainObject definition, wrong
            assert nameing = _.head _.keys definition
            assert exclude = _.head _.values definition
            assert current = this[nameing] or undefined
            assert hierarchy = @constructor.hierarchy()
            predicate = (co) -> co.similarWith exclude
            pivotal = _.findIndex hierarchy, predicate
            hierarchy = _.drop hierarchy, pivotal + 1
            exists = (val) -> val.prototype?[nameing]?
            heading = _.find(hierarchy, exists) or 0
            value = try heading?.prototype?[nameing]
            return value unless  value is current
            (formed = {})[nameing] = _.head(hierarchy)
            return this.upstack.call this, formed

    # A complicated piece of functionality for merging arbitrary classes
    # into the linear hierarchical inheritance chain of existing class.
