anchor.diff:                 (sort common-parent-buffers #'string< :key #'id)))
           (sera:split-sequence-if (sera:equals (id buffer))
            common-parent-buffers
  -         :key #'id
  -         :remove-empty-subseqs t)))))
  +         :key #'id)))))
   
   (defun buffer-sibling-previous (&optional (buffer (current-buffer)))
     (alex:when-let ((previous-siblings (first (buffer-siblings buffer))))
  
positive.code:   (first (second (buffer-siblings buffer))))
  
  (define-command switch-buffer-previous (&optional (buffer (current-buffer)))
    "Switch to the previous sibling buffer.
  A sibling buffer is a buffer with the same parent.
  The 'previous' one here means the one with the closest ID below it.
  If there is no sibling, go to the parent."
    (alex:when-let ((previous (or (buffer-sibling-previous buffer)
                                  (buffer-parent buffer))))
      (set-current-buffer previous)))
  
  (define-command switch-buffer-next (&optional (buffer (current-buffer)))
    "Switch to the next sibling buffer.
  A sibling buffer is a buffer with the same parent.
  The 'next' one here means the one with the closest ID above it.
  If there is no sibling, go to the parent."
    (alex:when-let ((next (or (buffer-sibling-next buffer)
                              (buffer-parent buffer))))
      (set-current-buffer next)))
  
  (define-command switch-buffer-last ()
  
negative.code:        :key (lambda (b) (alex:when-let ((owner (htree:owner history (id b))))
                            (htree:creator-id owner)))))))
  
  (defun buffer-first-root (&optional (buffer (current-buffer)))
    (alex:if-let ((parent (buffer-parent buffer)))
      (buffer-first-root parent)
      (first (first (buffer-siblings buffer)))))
  
  (defun buffer-last-child (&optional (buffer (current-buffer)))
    (alex:if-let ((next-siblings (second (buffer-siblings buffer))))
      (buffer-last-child (alex:last-elt next-siblings))
      (alex:if-let ((children (buffer-children buffer)))
        (buffer-last-child (alex:last-elt children))
        buffer)))
  
  (defun buffer-next-parent-sibling (&optional (buffer (current-buffer)))
    (alex:when-let ((parent (buffer-parent buffer)))
      (alex:if-let ((next-siblings (second (buffer-siblings buffer))))
        (first next-siblings)
        (buffer-next-parent-sibling parent))))
  
  (defun buffer-siblings (&optional (buffer (current-buffer)))
    (let* ((current-history (get-data (history-path buffer)))
           (buffers (remove-if (complement (sera:eqs current-history))
  