anchor.diff:  (defmethod output-record-children ((record standard-tree-output-record))
     (map 'list
          #'tree-output-record-entry-record
  -       (spatial-trees:search (%record-to-spatial-tree-rectangle record)
  -                             (%tree-record-children record))))
  +       (spatial-trees:search 
  +        (%record-to-spatial-tree-rectangle record)
  +        ;; The form below intends to fix output-record-children not
  +        ;; reporting empty children, which may lie outside the reported
  +        ;; bounding rectangle of their parent.
  +        ;; Assumption: null bounding records are always at the origin.
  +        ;; I've never noticed this violated, but it's out of line with
  +        ;; what null-bounding-rectangle-p checks, and setf of
  +        ;; output-record-position may invalidate it. Seems to work, but
  +        ;; fix that and try again later.
  +        #+NIL
  +        (rectangles:make-rectangle
  +         :lows (list 0 0) #| `(,(bounding-rectangle-min-x r) ,(bounding-rectangle-min-y r)) |#
  +         :highs `(,(bounding-rectangle-max-x record) ,(bounding-rectangle-max-y record)))
  +       (%tree-record-children record))))
   
   (defmethod add-output-record (child (record standard-tree-output-record))
     (let ((entry (make-tree-output-record-entry child (incf (last-insertion-nr record)))))
  
positive.code:     ((record compound-output-record) child)
    (unless (null-bounding-rectangle-p child)
      (with-bounding-rectangle* (old-x1 old-y1 old-x2 old-y2) record
        ;; I expect there's a bug here. If you create a record A, add an empty child B
        ;; then add a displayed-output-record C, the code below will use min/max to
        ;; grow the all-zero bounds of A, typically giving a bogus x1,y1 of 0,0. --Hefner
        (if (eql 1 (output-record-count record))
  	  (setf (rectangle-edges* record) (bounding-rectangle* child))
  	  (with-bounding-rectangle* (x1-child y1-child x2-child y2-child)
  		child
  	      (setf (rectangle-edges* record)
  		    (values (min old-x1 x1-child) (min old-y1 y1-child)
  			    (max old-x2 x2-child) (max old-y2 y2-child)))))
        (let ((parent (output-record-parent record)))
  	    (when parent
  	      (recompute-extent-for-changed-child
  	       parent record old-x1 old-y1 old-x2 old-y2)))))
    record)
  
  (defmethod %tree-recompute-extent* ((record compound-output-record))
  
negative.code:   (values nx ny))
  
  (defmethod* (setf output-record-position) :around
              (nx ny (record basic-output-record))
    (with-bounding-rectangle* (min-x min-y max-x max-y) record
      (call-next-method)    
      (let ((parent (output-record-parent record)))
        (when (and parent (not (and (typep parent 'compound-output-record)
                                    (slot-value parent 'in-moving-p)))) ; XXX
          (recompute-extent-for-changed-child parent record
                                              min-x min-y max-x max-y)))   
      (values nx ny)))
  
  (defmethod* (setf output-record-position)
    :before (nx ny (record compound-output-record))
  