anchor.diff:  
   ;;; * Metaclasses
   
  -(defgeneric class-transform-type (class))
  +(defgeneric class-model-metaclass (class))
   
   
   ;;; * Element transformation proto.
   
   
  -(defclass transformation-model ()
  -  ;; FIXME: differentiate this class w.r.t `MODEL' (see "here documentation", previous)
  -
  -  ;; effectively a container for XMI -> Common Lisp transformation descriptors
  -  ((namespaces
  -    :initarg :namespaces
  -    :accessor transformation-model-namespaces
  -    )
  -   (ns-registry
  +(defclass bootstrap-model ()
  +  ;; effectively a container for XMI -> Common Lisp transformation
  +  ;; descriptors, so far as to unmarshal the full UML metamodel
  +  ;; serialized in UML.xmi
  +  ((ns-registry
  +    ;; NB: This slot consumes the :namespaces instance initarg
       :type namespace-registry
  -    :accessor tranformation-model-ns-registry)
  +    :accessor bootstrap-model-ns-registry)
      ))
   
  -(defmethod shared-initialize :after ((instance transformation-model)
  +
  +(defmethod shared-initialize :after ((instance bootstrap-model)
   				     slots &rest initargs
  -				     &key &allow-other-keys)
  -  (when (or (not (slot-boundp instance 'ns-registry))
  -	    (and (listp slots)
  -		 (member 'ns-registry (the list slots) :test #'eq)))
  -    (cond
  -      ((slot-boundp instance 'namespaces)
  -       (let ((namespaces (slot-value instance  'namespaces)))
  -	 (when namespaces
  -	   (let ((nsreg (make-namespace-registry)))
  -	     (dolist (ns namespaces)
  -	       (destructuring-bind (prefix . uri) ns
  -		 ;; FIXME: integrate further with qname utils, when
  -		 ;; adding elements to the transformation model, etc -
  -		 ;; avoid duplcation of qname strings, esp.
  -		 (ensure-prefix prefix uri nsreg)))
  -	     (setf (tranformation-model-ns-registry instance)
  -		   nsreg)))))
  -      (t
  -       (simple-style-warning
  -	"Instance 'namespaces' slot not bound, unable to initialize ~
  -ns-registry slot, in ~s"
  -	instance)))))
  -
  -
  +				     &key namespaces &allow-other-keys)
  +  (declare (ignore slots initargs))
  +  (when namespaces
  +    (flet ((ensure-nsreg ()
  +	     (cond
  +	       ((slot-boundp instance 'ns-registry)
  +		(bootstrap-model-ns-registry instance))
  +	       (t
  +		(let ((nsreg (make-namespace-registry)))
  +		  (setf (bootstrap-model-ns-registry instance)
  +			nsreg))))))
  +      (let ((nsreg (ensure-nsreg)))
  +	(dolist (ns namespaces)
  +	  (destructuring-bind (prefix . uri) ns
  +	    (ensure-prefix prefix uri nsreg)))))))
  +
  +
  +;; FIXME: Use or discard these three generic functions.
  +;; see also: transform-klacks.lisp
   (defgeneric add-transformation (transformation model))
  -
   (defgeneric find-transformation (namespace element type model))
   ;; ^ ? too broad ?
  -
   (defgeneric apply-transform (transformation source))
   
  -(defclass transformation-model-component ()
  +
  +(declaim (type bootstrap-model *boostrap-model*))
  +(defvar *boostrap-model* ;; name ??
  +  (make-instance 'bootstrap-model
  +		 :namespaces
  +		 '(("uml" . "http://www.omg.org/spec/UML/20110701" ))))
  +
  +
  +(defclass bootstrap-model-component ()
     ;; used in METAMODEL-TRANSFORM and in TRANSFORM-CLASS
     ((model
       :initarg :model
  -    :type transformation-model
  -    :accessor component-transformation-model)
  +    :type bootstrap-model
  +    :initform *bootstrap-model*
  +    :accessor component-bootstrap-model)
      ))
   
   ;;; * ...
   
  -(declaim (type transformation-model *uml-stub-model*))
  -
  -(defvar *uml-stub-model* ;; name ??
  -  (make-instance 'transformation-model
  -		 :namespaces
  -		 '(("uml" . "http://www.omg.org/spec/UML/20110701" ))))
  -
  -
  -(defclass metamodel-transform (transformation-model-component)
  -  ((local-name ;; how differs from TYPE ?
  -    ;; ^ local name for type of metamodel serialiation?
  +
  +
  +(defclass metamodel-transform (bootstrap-model-component)
  +
  +  ;; this may be subject to some revision - note the irrelevance of
  +  ;; the 'type' slot and the corredponding @xmi:type attribute, with
  +  ;; regards to "simple" metamodel unmarshaling
  +
  +  ((local-name
  +    ;; ^ local name for type of metamodel serialiation. (Note that that
  +    ;; name will identify a single metamodel element type)
       :initarg :local-name
  -    ;; FIXME: validate local-name as an XML name
  -    :type string ;; FIXME: namespace qualified strings? - see ensure-qname (?)
  +    :type string ;; FIXME: namespace qualified strings - see ensure-qname
       :accessor transform-local-name)
      (namespace
  +    ;; XML namespace URI for the element in the metamodel
  +    ;; serialization, likewise may the URI of a UML package containing
  +    ;; the element
       :initarg namespace
       :type namespace
       :accessor transform-namespace)
      (element-p
  +    ;; whether the metamodel element is known to be serialized as an
  +    ;; XML element
       :initarg :element-p
       :type boolean
       :accessor transform-element-p)
      (attribute-p
  +    ;; whether the metamodel element is known to be serialized as an
  +    ;; XML attribute
       :initarg :attribute-p
       :type boolean
       :accessor transform-attribute-p)
  -   (type
  +
  +   #+NIL ;; not needed in the metamodel
  +   (type ;; type of the model element object to be unmarshaled
       ;; cf. xmi:type attribute value in UML
       ;; (FIXME: Decouple that from the metamodel?)
       :initarg :type
  
positive.code: (def-uml-package "UML") ;; ?
  
  
  (defclass uml-class (classifier uml-transform-class)
    ;; NOTE: This class represents the main initial use-case for the
    ;; transformation algorithm proposed in Lupine XMI
    ((owned-attributes
      :source-element-p t
      :source-local-name "ownedAttribute" ;; qname (?)
      :initarg :owned-attributes
      ;; NB: access to values of slot containing property-table types
      ;; may be faciliated with a special slot definition extension
  
negative.code: 
  ;; * Trasform-Class
  
  (defclass transform-class (bootstrap-model-component standard-class)
    ((model-metaclass
      :initarg :model-metaclass
      :types simple-string
      :accessor class-model-metaclass
      )
     (composite-name
      ;; ??? specific to UML, but needs to be handled during class
      ;; init. However, in order for it to be appropriately handleed,
      ;; the system must have NAMESPACE and NAMED-ELEMENT defined.
      ;;
      ;; so, FIXME: during CHANGE-CLASS or somesuch, be sure to resolve
      ;; COMPOSITE-NAME to its NAME and CONTAINING-PACKAGE(s) components
      :initarg :comopsite-name
      :type simple-string
      :accessor class-composite-name
      )))
  
  
  (defmethod shared-initialize ((instance transform-class)
  			      slots &rest initargs
  			      &key &allow-other-keys)
    (macrolet ((uncadr (name)
  	       (with-gensyms (it)
  		 (let ((,it (getf initargs ,name)))
  		   (when ,it
  		     (setf (getf initargs ,name)
  			   (cadr ,it)))))))
      ;; FIXME: resolve MODEL-METACLASS (as a QName) onto model
      ;; namespace registry (prefix/ns bindings) in MODEL
      (uncadr :model-metaclass)
      (uncadr :model)
      (uncadr :composite-name)
      ;; FIXME: resolve COMPOSITE-NAME ...
      (apply #'call-next-method instance slots initargs)
      ))
  
  
  (defmethod direct-slot-definition-class ((class transform-class)
  					 &rest initargs)
    (destructuring-bind (&key source-local-name &allow-other-keys)
        initargs
      (cond
        (source-local-name
         (find-class 'direct-property-transform-slot-definition))
        (t (call-next-method)))))
  
  (defmethod effective-slot-definition-class ((class transform-class)
  					    &rest initargs)
    (destructuring-bind (&key name &allow-other-keys)
        initargs
      (let ((dslots (compute-direct-slot-definitions name class)))
        (delare (type cons dslots))
        (cond
  	((some #'(lambda (sl)
  		   (typep sl 'direct-property-transform-slot-definition))
  	       dslots)
  	 (find-class 'effective-property-transform-slot-definition))
  	(t (call-next-method))))))
  
  
  #+nil
  (defclass uml-transform-class (transform-class)
    ;; moreso representstive of a named element and a relation to its
    ;; containing package
    ((uml-source-package
      )
     (uml-element-name
  