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:   (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:     ((record compound-output-record) child)
    (unless (null-bounding-rectangle-p child)
      (with-bounding-rectangle* (old-x1 old-y1 old-x2 old-y2) record
        (cond
          ((null-bounding-rectangle-p record)
           (setf (rectangle-edges* record) (bounding-rectangle* child)))
          ((not (null-bounding-rectangle-p child))
           (assert (not (null-bounding-rectangle-p record))) ; important.
           (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))
  