anchor.diff:  
   (defun load-history-url (url-or-node
                            &key (buffer (current-buffer))
  -                           (message "History entry is already the current URL."))
  +                              (message "History entry is already the current URL."))
     "Go to HISTORY-NODE's URL."
     (unless (quri:uri-p url-or-node)
       (setf url-or-node (url (htree:data url-or-node))))
  
positive.code:   (unzoom-page :buffer (buffer mode)
                 :ratio (current-zoom-ratio (buffer mode)))
    url)
  
  (defmethod nyxt:object-string ((node htree:node))
    (object-string (when node (htree:data node))))
  (defmethod nyxt:object-display ((node htree:node))
    (object-display (when node (htree:data node))))
  
negative.code:         (history-forwards-direct-children)
          (history-forwards))))
  
  (define-class history-forwards-source (prompter:source)
    ((prompter:name "Child URLs")
     (buffer :initarg :buffer :accessor buffer :initform nil)
     (prompter:must-match-p t)
     (prompter:constructor
      (lambda (source)
        (htree:all-forward-children (get-data (history-path (buffer source)))))))
    (:export-class-name-p t))
  
  (define-command history-forwards-query (&optional (buffer (current-buffer)))
    "Query forward-URL to navigate to."
    (let ((input (first (prompt
                         :prompt "Navigate forwards to"
                         :sources (list (make-instance 'history-forwards-source
                                                       :buffer buffer))))))
      (when input
        (with-data-access (history (history-path buffer))
          ;; REVIEW: Alternatively, we could use the COUNT argument with
          ;; (1+ (position input (htree:all-forward-children history)))
          ;; Same with `history-backwards-query'.
          (loop until (eq input (htree:current-owner-node history))
                do (htree:forward history)))
        (load-history-url input))))
  
  (define-class all-history-forwards-source (prompter:source)
    ((prompter:name "Child URLs")
     (buffer :initarg :buffer :accessor buffer :initform nil)
     (prompter:must-match-p t)
     (prompter:constructor
      (lambda (source)
        (funcall (if (conservative-history-movement-p (find-mode (buffer source) 'web-mode))
                     (alex:compose #'htree:all-contiguous-owned-children #'htree:current-owner)
                     #'htree:all-children)
                 (get-data (history-path (buffer source)))))))
    (:export-class-name-p t))
  
  (define-command history-forwards-all-query (&optional (buffer (current-buffer)))
    "Query URL to forward to, from all child branches."
    (let ((input (first (prompt
                         :prompt "Navigate forwards to (all branches)"
                         :sources (list (make-instance 'all-history-forwards-source
                                                       :buffer buffer))))))
      (when input
        (with-data-access (history (history-path buffer))
          (htree:forward history))
        (load-history-url input))))
  
  (define-class history-all-source (prompter:source)
    ((prompter:name "History URLs")
     (buffer :initarg :buffer :accessor buffer :initform nil)
     (prompter:must-match-p t)
     (prompter:constructor
      (lambda (source)
        (funcall (if (conservative-history-movement-p (find-mode (buffer source) 'web-mode))
                     #'htree:all-current-owner-nodes
                     #'htree:all-current-branch-nodes)
                 (get-data (history-path (buffer source)))))))
    (:export-class-name-p t))
  
  (define-command history-all-query (&optional (buffer (current-buffer)))
    "Query URL to go to, from the whole history."
    (let ((input (prompt
                  :prompt "Navigate to"
                  :sources (list (make-instance 'history-all-source
                                                :buffer buffer)))))
      (when input
        (with-data-access (history (history-path buffer))
          (htree:visit-all history input))
  