anchor.diff:  |#
   
   (defun linearize-fd-bindings (&optional (fd-bindings *fd-bindings*))
  +  "Produce a linear sequence of bindings suitable for passing to
  +`shcl/core/fork-exec:run'.
  +
  +SHCL makes a distinction between virtual file descriptor bindings and
  +physical file descriptors.  When its time to fork off a process, we
  +need to merge the physical file descriptors and the virtual file
  +descriptors.  This can be problematic.
  +
  +Consider what happens if the following virtual => physical bindings
  +are in effect.
  +
  +    virtual fd => physical fd (file that the physical fd might represent)
  +    1 => 2 (foo.txt)
  +    2 => 1 (bar.txt)
  +    3 => 1 (bar.txt)
  +
  +So, in a subprocess, we would expect fd 1 to be bound to foo.txt and
  +fds 2 and 3 bound to bar.txt.  When its time to dup the physical file
  +descriptors into the places dictated by virtual fd bindings, you need
  +to be careful.  If you naievely walk through the bindings and apply
  +them in order you'll get the following result.
  +
  +    1 => 1 (foo.txt)
  +    2 => 2 (foo.txt)
  +    3 => 3 (foo.txt)
  +
  +Whoops!  We lost bar.txt.  The correct end result would actually be
  +the following.
  +
  +    1 => 1 (foo.txt)
  +    2 => 2 (bar.txt)
  +    3 => 3 (bar.txt)
  +
  +This function produces a sequence of fd dup2 assignments that will
  +produce the correct result.  See `shcl/core/fork-exec' for information
  +about the format of the list this function produces."
     (let* ((fd-graph (fd-bindings-dependency-graph fd-bindings))
            (components (nreverse (graph-tarjan-strongly-connected-components fd-graph)))
            (bindings (make-extensible-vector)))
  
positive.code:     (values)))
  
  (defun get-fd-binding (virtual-fd &key (if-unbound :error))
    (check-type if-unbound (member nil :error :unmanaged))
    (let ((result (nth-value 0 (fset:lookup *fd-bindings* virtual-fd))))
      (unless result
  
negative.code:   (unless *private-fds-locked*
      (error "Unsafe fd manipulation")))
  
  (defgeneric fd-wrapper-close (fd-wrapper)
    (:documentation
     "This function is called when a file descriptor wrapper should
  close the associated file descriptor.
  
  It is an error to call this function twice on a single object.
  
  You probably shouldn't get in the habit of calling this function
  directly.  Some file descriptor wrappers (e.g. `ref-counted-fd') are
  picky about when this function is called."))
  
  (defmethod fd-wrapper-close :around ((fd-wrapper fd-wrapper))
    (with-safe-fd-manipulation
  