anchor.diff:              ;; In the following cases, we can grow the new bounding rectangle
               ;; from its previous state:
               ((or
  -              ;; If the child was originally empty, it should not have affected
  +              ;; If the child was originally empty, it could not have affected
                 ;; previous computation of our bounding rectangle.
                 ;; This is hackish for reasons similar to the above.
  -              (and (zerop old-min-x) (zerop old-min-y)
  -                   (zerop old-max-x) (zerop old-max-y))
  -	      ;; For each old child coordinate, either it was not
  -	      ;; involved in determining the bounding rectangle of the
  -	      ;; parent, or else it is the same as the corresponding
  -	      ;; new child coordinate.
  +              (and (= old-min-x old-max-x) (= old-min-y old-max-y))
  +	      ;; For each edge of the original child bounds, if it was within
  +	      ;; its respective edge of the old parent bounding rectangle,
  +	      ;; or if it has not changed:
   	      (and (or (> old-min-x ox1) (= old-min-x cx1))
   		   (or (> old-min-y oy1) (= old-min-y cy1))
   		   (or (< old-max-x ox2) (= old-max-x cx2))
  
positive.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))
  
negative.code: (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)
          ;; 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)))))
  