populate flake-input: fail on failures, reuse the store, leave out replaced inputs

Delivering flakes and flake inputs gets more robust:

- With fetchOnTarget, the inputs get collected before the pipeline that
  links them, so populate fails if the target can't fetch one, instead of
  linking the flake without its inputs and succeeding.
- What the lock file pins gets taken from the store if it's there: the
  store path is the one of a directory named source with the locked hash,
  which nix-store --print-fixed-path computes.  builtins.fetchTree
  contacts where the input comes from even then, so redeploying unchanged
  sources fails without that if a server is unreachable.
- With fetchOnTarget, a delivered input that is itself locked to a local
  path the target lacks fails with populate's error naming the input, like
  its inputs do.
- Inputs that get drawn from other sources are left out, with all they
  pin: Nix archives an empty flake in their place.  So nothing gets
  fetched, copied, and rooted that no evaluation uses, and a pin that is
  unreachable doesn't matter if it gets replaced anyway.
- flake-input sources get the option requireInputs.  By default,
  populating fails if the inputs that the input's own lock file pins
  can't be delivered, e.g. because the lock file lacks an input its
  flake.nix has.  With false, populate warns and delivers the input with
  what Nix locks now, or else without its inputs.

A remote flake that the target fetches entirely on its own collects its
inputs like everything else does.  The Nix function finding its
subdirectory moves next to the jq programs.

New edge cases cover each of these.

1 files changed, 13 insertions, 2 deletions

diff --git a/README.md b/README.md
index ae7eca2..9f1b760 100644
--- a/README.md
+++ b/README.md
@@ -476,6 +476,15 @@ Supported attributes:
   e.g. `stockholm/nixpkgs`, and resolved as the flake's lock file resolves
   them, so an input that follows another one names the other one.
 
+* `requireInputs` (optional) -
+  boolean that controls whether populating fails if the inputs that the
+  input's own lock file pins can't be delivered, e.g. because the lock file
+  pins something unreachable, or lacks an input its `flake.nix` has.  With
+  `false`, populate prints a warning and delivers the input with the inputs
+  Nix locks when it adds what the lock file lacks, or else without its
+  inputs.  Evaluating the input as a flake then needs network access.
+  Defaults to `true`.
+
 * `fetchOnTarget` (optional) -
   boolean that controls whether the target fetches the input itself instead
   of receiving it from the deploying machine.  The target then uses the
@@ -669,8 +678,10 @@ there are any), all other sources as `path:`, with symlinks resolved.  Lock
 files get rewritten or generated on every run, so they match the sources.
 Copies of `flake` and `flake-input` sources get made again only if the
 delivered store path, the patches, or the sources they draw inputs from
-change.  Generated flakes and copies get removed once their sources no longer
-need them.  This requires Nix with flake support (Nix 2.4 or later) on the
+change.  Inputs that get drawn from other sources don't get delivered with
+a `flake` or `flake-input` source, and neither does what they pin.
+Generated flakes and copies get removed once their sources no longer need
+them.  This requires Nix with flake support (Nix 2.4 or later) on the
 target.  Populating fails if a source that draws inputs from other sources
 contains no `flake.nix`.  Sources that inputs get drawn from don't need to be
 flakes, as long as the inputs drawing from them are declared with