anchor.diff:  	     :reader output-record-children)))
   
   (defmethod add-output-record (child (record standard-sequence-output-record))
  -  (with-slots (children) record
  -    (vector-push-extend child children))
  -  (with-slots (parent) child ; FIXME!!!
  -    (setf parent record)))
  -
  -#+nil
  -(defmethod add-output-record :before (child (record compound-output-record))
  -  (when (zerop (output-record-count record))
  -    (with-slots (x1 y1 x2 y2) record
  -      (setf (values x1 y1 x2 y2) (bounding-rectangle* child)))))
  +  (vector-push-extend child (output-record-children record))
  +  (setf (output-record-parent child) record))
   
   (defmethod delete-output-record (child (record standard-sequence-output-record)
   				 &optional (errorp t))
  
positive.code: 
  ;;;; Implementation
  
  ;;; Should we blow off standard-bounding-rectangle and implement the
  ;;; bounding rectangle protocol ourselves?  Or use x1,y1 from
  ;;; standard-bounding-rectangle as our position?
  
  (defclass basic-output-record (standard-bounding-rectangle output-record)
    ((parent :initarg :parent
  	   :initform nil
             :reader output-record-parent))
    (:documentation "Implementation class for the Basic Output Record Protocol."))
  
  (defmethod initialize-instance :after ((record basic-output-record)
  
negative.code: 
  (defgeneric invoke-with-new-output-record (stream continuation record-type
                                             &rest initargs
                                             &allow-other-keys))
  
  (defgeneric invoke-with-output-to-output-record
      (stream continuation record-type
       &rest initargs
       &allow-other-keys))
  
  (defgeneric make-design-from-output-record (record))
  