anchor.diff:      (when sheet
         (map-over-output-records #'note-output-record-lost-sheet record 0 0 sheet))))
   
  +(defmethod clear-output-record :around ((record compound-output-record))
  +  (multiple-value-bind (x1 y1 x2 y2) (bounding-rectangle* record)
  +    (call-next-method)
  +    (assert (null-bounding-rectangle-p record))
  +    (when (output-record-parent record)
  +      (recompute-extent-for-changed-child
  +       (output-record-parent record) record x1 y1 x2 y2))))
  +
   (defmethod clear-output-record :after ((record compound-output-record))
     ;; XXX banish x and y
  -  (with-slots (x y)
  -      record
  +  (with-slots (x y) record
       (setf (rectangle-edges* record) (values x y x y))))
   
   (defmethod output-record-count ((record displayed-output-record))
  
positive.code:           (cond
              ;; The child has been deleted; who knows what the
              ;; new bounding box might be.
              ((not (output-record-parent changed-child))
               (%tree-recompute-extent* record))
              ;; Only one child of record, and we already have the bounds.
              ((eql (output-record-count record) 1)
               (values cx1 cy1 cx2 cy2))
              ;; If our record occupied no space (had no children, or had only
              ;; children similarly occupying no space, hackishly determined by
  
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))
  