anchor.diff:    (check-type node node)
     (check-type property-name property-name)
     (or (find-transition node property-name)
  -      (aconsf (%node-transitions node) property-name
  -              (make-node :mold (%node-mold node)
  +      (aconsf (node-transitions node) property-name
  +              (make-node :mold (node-mold node)
                            :properties (cons property-name
  -                                           (%node-properties node))))))
  +                                           (node-properties node))))))
   
   (defun ensure-mold (parents properties)
     "Returns the node with properties PROPERTIES of the mold for PARENTS,
  
positive.code: ;;;   all sub-molds must be alerted (and they must alert -their- sub-molds), and each sub-mold must
  ;;;   recalculate its hierarchy list.
  
  (defstruct (mold (:predicate moldp) (:conc-name %mold-)
                   (:constructor
                    %make-mold (parents &aux (hierarchy (compute-hierarchy parents)))))
    "Also known as 'backend classes', molds are hidden caches which enable
  Sheeple to use class-based optimizations yet keep its dynamic power."
    (parents   nil :read-only t)
  
negative.code:   (check-list-type goal-properties property-name)
    ;; This algorithm is very concise, but it's not optimal AND it's unclear.
    ;; Probably the first target for cleaning up. - Adlai
    (let ((path (set-difference goal-properties (node-properties start-node))))
      (if (null path) start-node
          (awhen (some (fun (find-transition start-node _)) path)
            (find-node-by-transitions it path)))))
  