anchor.diff:  (defun %expand-wild-path (directories index file-name)
     "The brains of `expand-wild-path'."
     (let (next as-directory-p)
  +    ;; Figure out what we're looking for and whether it needs to be a
  +    ;; directory or not.
       (cond
         ((>= index (length directories))
  +       (unless file-name
  +         (return-from %expand-wild-path (fset:seq (fset:empty-seq))))
          (setf next file-name)
          (setf as-directory-p nil))
         (t
          (setf next (aref directories index))
          (setf as-directory-p t)))
   
  -    (unless next
  -      (return-from %expand-wild-path (fset:seq (fset:empty-seq))))
  -
       (labels
           ((recurse ()
              (%expand-wild-path directories (1+ index) file-name))
            (recurse-and-prefix (string slash-p)
  +           ;; Recurse and add `string' (optionally followed by a #\/
  +           ;; character) to the start of all results produced by the
  +           ;; recursion.
              (let ((rest (recurse)))
                (unless rest
                  (return-from recurse-and-prefix))
  
positive.code:                    (slash (if slash-p (fset:seq #\/) (fset:empty-seq))))
                 (fset:image (lambda (seq) (fset:concat s slash seq)) rest)))))
        (declare (dynamic-extent #'recurse #'recurse-and-prefix))
        (cond
          ((and (zerop index)
                (stringp next)
                (not (find-if-not (lambda (c) (equal #\/ c)) next)))
  
negative.code:          (with-directory-or-nil (next)
             (recurse-and-prefix next nil)))
  
          ;; Handle empty directory components (i.e. adjacent,
          ;; non-leading slash characters).
          ((equal next "")
           (assert as-directory-p)
           (recurse-and-prefix "/" nil))
  
          ;; Handle specifically named directories
          ((and (stringp next) as-directory-p)
           (with-directory-or-nil (next)
             (recurse-and-prefix next t)))
  
          ;; Handle specifically named files
          ((stringp next)
           (assert (not as-directory-p))
           (handler-case
               (shcl/core/fd-table:receive-ref-counted-fd
                   (fd (retained-fd-openat (get-fd-current-working-directory) next 0))
                 (declare (ignore fd))
                 (fset:seq (fset:convert 'fset:seq next)))
             (syscall-error ())))
  
          ;; Oooh.  Exciting.  A scanner.  Iterate the contents of the
          ;; current directory and look for things that match the given
          ;; name.
          ((not (stringp next))
           (let ((matches (fset:empty-seq)))
             (with-dir-ptr-for-fd (dir-ptr (get-fd-current-working-directory))
  