anchor.diff:      (lambda (minibuffer)
         (fuzzy-match (input-buffer minibuffer) ring-items))))
   
  +(define-class ring-source (prompter:source)
  +  ((prompter:name "Ring")
  +   (ring :initarg :ring :accessor ring :initform nil)
  +   (prompter:must-match-p t)
  +   (prompter:constructor
  +    (lambda (source)
  +      (containers:container->list (ring source))))
  +   (prompter:actions
  +    (list (make-command paste* (ring-items)
  +            (%paste :input-text (first ring-items))))))
  +  (:export-class-name-p t))
  +
   (define-command paste-from-ring ()
     "Show `*browser*' clipboard ring and paste selected entry."
  -  (let ((ring-item (prompt-minibuffer
  -                    :suggestion-function (ring-suggestion-filter
  -                                          (nyxt::clipboard-ring *browser*)))))
  -    (%paste :input-text ring-item)))
  +  (prompt
  +   :prompt "Paste from ring"
  +   :sources (list (make-instance 'ring-source
  +                                 :ring (nyxt::clipboard-ring *browser*)))))
   
   (define-command copy ()
     "Copy selected text to clipboard."
  
positive.code: (define-class history-backwards-source (prompter:source)
    ((prompter:name "Parent URLs")
     (buffer :initarg :buffer :accessor buffer :initform nil)
     (prompter:constructor
      (lambda (source)
        (with-data-unsafe (parents (history-path (buffer source))
                                   :key (if (conservative-history-movement-p (find-mode (buffer source) 'web-mode))
                                            #'htree:all-contiguous-owned-parents
                                            #'htree:all-parents))
          parents))))
    (:export-class-name-p t))
  
  (defmethod prompter:object-properties ((node history-tree:node))
    (list :entry (history-tree:data (history-tree:entry node))))
  
  (define-command history-backwards-query (&optional (buffer (current-buffer)))
    "Query parent URL to navigate back to."
    (let ((input (prompt
                  :prompt "Navigate backwards to"
                  :sources (make-instance 'history-backwards-source
                                          :buffer (current-buffer)))))
      (when input
        (with-data-access (history (history-path buffer))
          ;; See `history-forwards-query' comment.
          (loop until (eq input (htree:current-owner-node history))
                do (htree:backward history)))
        (load-history-url input))))
  
  (defun history-forwards-direct-children-suggestion-filter (&optional (buffer (current-buffer)))
    "Suggestion function over forward-children URL."
    (with-data-unsafe (children (history-path buffer)
                       :key (if (conservative-history-movement-p (find-mode buffer 'web-mode))
                                (alex:compose #'htree:owned-children #'htree:current-owner)
                                (alex:compose #'htree:children #'htree:current-owner-node)))
      (lambda (minibuffer)
        (if children
            (fuzzy-match (input-buffer minibuffer) children)
            (echo "Cannot navigate forwards.")))))
  
  (define-command history-forwards-direct-children (&optional (buffer (current-buffer)))
    "Query child URL to navigate to."
    (let ((input (prompt-minibuffer
                  :input-prompt "Navigate forwards to"
                  :suggestion-function (history-forwards-direct-children-suggestion-filter))))
      (when input
        (with-data-access (history (history-path buffer))
          (htree:go-to-child (htree:data input) history))
  
negative.code: 
  (defun load-history-url (url-or-node
                           &key (buffer (current-buffer))
                                (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))))
  