anchor.diff:      (without-local-recording stream
         (call-next-method))))
   
  -#+nil
  -(defmethod stream-write-char :around ((stream standard-output-recording-stream) char)
  -  (when (and (stream-recording-p stream)
  -             (slot-value stream 'local-record-p))
  -    (if (or (eql char #\return)
  -
  -        (stream-close-text-output-record stream)
  -      (let* ((medium (sheet-medium stream))
  -             (text-style (medium-text-style medium)))
  -        (stream-add-character-output stream char text-style
  -                                     (stream-character-width stream char :text-style text-style)
  -                                     (text-style-height text-style medium)
  -                                     (text-style-ascent text-style medium)))))
  -  (without-local-recording stream
  -                           (call-next-method))))
  -
  -#+nil
  -(defmethod stream-write-string :around ((stream standard-output-recording-stream) string
  -                                        &optional (start 0) end)
  -  (when (and (stream-recording-p stream)
  -             (slot-value stream 'local-record-p))
  -    (let* ((medium (sheet-medium stream))
  -           (text-style (medium-text-style medium)))
  -      (stream-add-string-output stream string start end text-style
  -                                (stream-string-width stream string
  -                                                     :start start :end end
  -                                                     :text-style text-style)
  -                                (text-style-height text-style medium)
  -                                (text-style-ascent text-style medium))))
  -  (without-local-recording stream
  -                           (call-next-method)))
  -
  -
   (defmethod stream-finish-output :after ((stream standard-output-recording-stream))
     (stream-close-text-output-record stream))
   
  
positive.code:   (declare (ignore record sheet))
    (values))
  
  (defmethod note-output-record-lost-sheet :after ((record compound-output-record) sheet)
    (map-over-output-records #'note-output-record-lost-sheet record 0 0 sheet))
  
  (defmethod note-output-record-got-sheet  ((record output-record) sheet)
    (declare (ignore record sheet))
    (values))
  
  (defmethod note-output-record-got-sheet :after ((record compound-output-record) sheet)
    (map-over-output-records #'note-output-record-got-sheet record 0 0 sheet))
  
  (defun find-output-record-sheet (record)
    "Walks up the parents of RECORD, searching for an output history from which
  the associated sheet can be determined."
    (typecase record
      (stream-output-history-mixin (output-history-stream record))
      (basic-output-record (find-output-record-sheet (output-record-parent record)))))  
  
  (defmethod output-record-children ((record basic-output-record))
    nil)
  
negative.code: were added."
    (declare (ignore x-offset y-offset))
    (loop with children = (output-record-children record)
  	for child across children
  	when (region-intersects-region-p region child)
  	  do (apply function child function-args)))
  
  ;;; tree output recording
  
  (defclass tree-output-record-entry ()
       ((record :initarg :record :reader tree-output-record-entry-record)
        (cached-rectangle :initform nil
  			:accessor tree-output-record-entry-cached-rectangle)
        (inserted-nr :initarg :inserted-nr
  		   :accessor tree-output-record-entry-inserted-nr)))
  
  (defun make-tree-output-record-entry (record inserted-nr)
    (make-instance 'tree-output-record-entry
      :record record
      :inserted-nr inserted-nr))
  
  (defun %record-to-spatial-tree-rectangle (r)
    (rectangles:make-rectangle
  