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:            (fd-wrapper-release ,fd))))))
  
  (defmacro receive-ref-counted-fd ((variable (function-name &rest args)) &body body)
    (let ((fd (gensym "FD"))
          (name (symbol-name function-name)))
      (labels
  
negative.code:   (dir-ptr-wrapper-raw value))
  
  (defun dup-fd-into-dir-ptr (fd)
    "create a `dir-ptr-wrapper' which interacts with a dup'd version of
  the given fd.
  
  This `dir-ptr-wrapper' must be closed with `close-dir-ptr'.  You must
  not leak the `dir-ptr-wrapper' without closing it first."
    (with-safe-fd-manipulation
      (let ((close-new-fd t)
            new-fd
  