anchor.diff:        (setf *server* (jsonrpc:make-server))
         (jsonrpc:expose *server* "ready" (ready (lambda () (setf ready t))))
         (jsonrpc:expose *server* "input" 'input-callback)
  -      (dbg "server-listen")
  +      (log:info "server-listen")
         (apply #'jsonrpc:server-listen *server*
                :mode *mode*
                (if (eq *mode* :tcp) (list :port *port*))))))
  
positive.code:       (yason:encode-object-element "use_modeline" (view-use-modeline view))
        (yason:encode-object-element "kind" (view-kind view)))))
  
  (let ((lock (bt:make-lock)))
    (defun dbg (x)
      (when *debug*
        (bt:with-lock-held (lock)
          (with-open-file (out "~/log"
                               :direction :output
                               :if-exists :append
                               :if-does-not-exist :create)
            (write-string x out)
            (terpri out))))
      x))
  
  (defmacro with-error-handler (() &body body)
    `(handler-case
         (handler-bind ((error (lambda (c)
                                 (dbg (with-output-to-string (stream)
                                        (format stream "~%******ERROR******:~%~A~%" c)
                                        (uiop:print-backtrace :stream stream
                                                              :condition c))))))
           (progn ,@body))
       (error ())))
  
  
negative.code:               (t
                 (error "unexpected kind: ~D" kind))))
      (error (e)
        (log:error e)
        (log:error (with-output-to-string (stream)
                     (let ((stream (yason:make-json-output-stream stream)))
                       (yason:encode args stream)))))))
  
  (add-hook *exit-editor-hook*
            (lambda ()
  