anchor.diff:    (catch 'toplevel
       (do-commandloop (:toplevel t)
         (with-error-handler ()
  -        (cockpit
  -          (when (= 0 (event-queue-length)) (redraw-display))
  -          (handler-case
  -              (handler-bind ((editor-condition
  -                              (lambda (c)
  -                                (declare (ignore c))
  -                                (stop-record-key))))
  -                (let ((cmd (read-key-command-with-idle-timers)))
  -                  (cond ((changed-disk-p (current-buffer))
  -                         (ask-revert-buffer))
  -                        (t
  -                         (message nil)
  -                         (cmd-call cmd nil)))))
  -            (editor-abort ()
  -                          (buffer-mark-cancel (current-buffer))
  -                          (message "Quit"))
  -            (editor-condition (c)
  -                              (message "~A" c))))))
  +        (when (= 0 (event-queue-length)) (redraw-display))
  +        (handler-case
  +            (handler-bind ((editor-condition
  +                            (lambda (c)
  +                              (declare (ignore c))
  +                              (stop-record-key))))
  +              (let ((cmd (read-key-command-with-idle-timers)))
  +                (message nil)
  +                (cmd-call cmd nil)))
  +          (editor-abort ()
  +                        (buffer-mark-cancel (current-buffer))
  +                        (message "Quit"))
  +          (editor-condition (c)
  +                            (message "~A" c)))))
       nil))
   
   (defun lem-internal ()
     (let* ((main-thread (bt:current-thread))
            (editor-thread (bt:make-thread
                            (lambda ()
  -                           (let ((result (toplevel-editor-loop)))
  +                           (let* ((*in-the-editor* t)
  +                                  (result (toplevel-editor-loop)))
                                (bt:interrupt-thread main-thread
                                                     (lambda ()
                                                       (error 'exit-editor
  
positive.code:        :stream stream
         :count 100))))
  
  (defun bailout (condition)
    (throw 'toplevel
      (with-output-to-string (stream)
        (princ condition stream)
        (uiop/image:print-backtrace
         :stream stream
         :condition condition))))
  
  (defmacro with-error-handler (() &body body)
    `(handler-case-bind ((lambda (condition)
                           (handler-bind ((error #'bailout))
                             (pop-up-backtrace condition)))
                         ,@body)
                        ((condition) (declare (ignore condition)))))
  
  
negative.code:     (t
       (setf (get-bvar 'already-visited :buffer (window-buffer window)) t)
       (syntax-scan-buffer (window-buffer window)))))
  
  (defun syntax-scan-point (start end old-len)
    (line-start start)
  