anchor.diff:  	(first-time t))
       (map-over-output-records
        (lambda (child)
  -       (if first-time
  -           (progn
  -             (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
  -               (bounding-rectangle* child))
  -             (setq first-time nil))
  -           (with-bounding-rectangle* (cx1 cy1 cx2 cy2) child
  -             (minf new-x1 cx1)
  -             (minf new-y1 cy1)
  -             (maxf new-x2 cx2)
  -             (maxf new-y2 cy2))))
  +       (unless (null-bounding-rectangle-p child)
  +         (if first-time
  +             (progn
  +               (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
  +                 (bounding-rectangle* child))
  +               (setq first-time nil))
  +             (with-bounding-rectangle* (cx1 cy1 cx2 cy2) child
  +               (minf new-x1 cx1)
  +               (minf new-y1 cy1)
  +               (maxf new-x2 cx2)
  +               (maxf new-y2 cy2)))))
        record)
       (if first-time
   	;; XXX banish x y
  
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:     (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
      (setf (rectangle-edges* record) (values x y x y))))
  
  (defmethod output-record-count ((record displayed-output-record))
  