anchor.diff:                          :initform nil)
      (%rescanning-p :reader stream-rescanning-p
                     :writer (setf stream-rescanning)
  -                  :initform nil))
  +                  :initform nil)
  +   (%input-buffer-array :accessor input-buffer-array
  +                        :initform nil
  +                        :documentation "After a command has been
  +executed, the contents of the Drei area instance shall be
  +replaced by the contents of this array, if non-NIL."))
     (:documentation "An mixin that helps in implementing Drei-based
   input-editing streams. This class should not be directly
   instantiated."))
  
positive.code:   ;; want to permit the user to undo input for this context.
    (clear-undo-history (buffer (drei-instance stream))))
  
  (defmethod stream-input-buffer ((stream drei-input-editing-mixin))
    ;; NOTE: This is very slow, please do not use it unless you want to
    ;; be compatible with other editor substrates. Use the Drei buffer
    ;; directly instead.
    (with-accessors ((buffer buffer)) (drei-instance stream)
      (let* ((array (buffer-sequence buffer 0 (size buffer))))
        (make-array (length array)
                    :fill-pointer (length array)
                    :initial-contents array))))
  
  (defmethod replace-input ((stream drei-input-editing-mixin) (new-input array)
  			  &key
  
negative.code:                                                         *pointer-documentation-output*
                                                          minibuffer)
                                          :prompt "M-x ")
        ;; Commands are permitted to signal immediate rescans, but
        ;; we may need to do some stuff first.
        (unwind-protect
             (accepting-from-user (drei)
               ;; We narrow the buffer to the input position, so the user won't
               ;; be able to erase the original command (when entering command
               ;; arguments) or stuff like argument prompts.
               (drei-core:with-narrowed-buffer (drei (input-position stream) t t)
                 (handler-case (process-gestures-or-command drei)
                   (unbound-gesture-sequence (c)
                     (display-message "~A is unbound" (gesture-name (gestures c))))
                   (abort-gesture (c)
                     (if (member (abort-gesture-event c)
                                 *abort-gestures*
                                 :test #'event-matches-gesture-name-p)
                         (signal 'abort-gesture :event (abort-gesture-event c))
                         (when was-directly-processing
                           (display-message "Aborted")))))))
          (update-drei-buffer stream))
        ;; Will also take care of redisplaying minibuffer.
        (display-drei drei)
        (let ((first-mismatch (offset (high-mark buffer))))
  