anchor.diff:    "Applies FUNCTION to children, containing (X,Y), in the reversed
   order they were added."
     (declare (ignore x-offset y-offset))
  -  (loop with children = (output-record-children record)
  -        for i from (1- (length children)) downto 0
  -        for child = (aref children i)
  -        when (and (multiple-value-bind (min-x min-y max-x max-y)
  -                      (output-record-hit-detection-rectangle* child)
  -                    (and (<= min-x x max-x) (<= min-y y max-y)))
  -                  (output-record-refined-position-test child x y))
  -          do (apply function child function-args)))
  +  (let ((function (alexandria:ensure-function function)))
  +    (loop with children = (output-record-children record)
  +          for i from (1- (length children)) downto 0
  +          for child = (aref children i)
  +          when (and (multiple-value-bind (min-x min-y max-x max-y)
  +                        (output-record-hit-detection-rectangle* child)
  +                      (and (<= min-x x max-x) (<= min-y y max-y)))
  +                    (output-record-refined-position-test child x y))
  +          do (apply function child function-args))))
   
   (defmethod map-over-output-records-overlapping-region
       (function (record standard-sequence-output-record) region
  
positive.code: ;;; not affect bounding rectangles.  -- Hefner
  (defun null-bounding-rectangle-p (bbox)
    (with-bounding-rectangle* (x1 y1 x2 y2) bbox
       (and (= x1 x2)
            (= y1 y2))))
  
  ;;; 16.2.3. Output Record Change Notification Protocol
  (defmethod recompute-extent-for-new-child
  
negative.code:   (bounding-rectangle* record))
  
  (defmethod tree-recompute-extent-aux ((record compound-output-record))
    (if (zerop (output-record-count record)) ; no children
        (bounding-rectangle* record)
        (let ((new-x1 0)
              (new-y1 0)
              (new-x2 0)
              (new-y2 0)
              (first-time t))
          (flet ((do-child (child)
                   (if first-time
                       (progn
                         (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
                           (tree-recompute-extent-aux child))
                         (setq first-time nil))
                       (multiple-value-bind (cx1 cy1 cx2 cy2)
                           (tree-recompute-extent-aux child)
                         (minf new-x1 cx1)
                         (minf new-y1 cy1)
                         (maxf new-x2 cx2)
                         (maxf new-y2 cy2)))))
            (declare (dynamic-extent #'do-child))
            (map-over-output-records #'do-child record))
          (with-slots (x y) record
            (setf x new-x1 y new-y1)
            (setf (rectangle-edges* record)
                  (values new-x1 new-y1 new-x2 new-y2))))))
  
  (defmethod recompute-extent-for-changed-child
      ((record compound-output-record) changed-child
  