dedup: auto-pin transitive-only [all_follow] targets

Author: amaanq

.tack/default.nix

@@ -4,7 +4,30 @@
 let
   pins = builtins.fromTOML (builtins.readFile ./pins.toml);
   lock = builtins.fromJSON (builtins.readFile ./pins.lock.json);
-  all_follow = pins.all_follow or { };
+  all_follow_raw = pins.all_follow or { };
+
+  # flatten `target = [aliases]` rows alongside `alias = "target"` rows
+  all_follow = builtins.foldl' (
+    acc: key:
+    let
+      val = all_follow_raw.${key};
+    in
+    if builtins.isList val then
+      acc
+      // {
+        ${key} = key;
+      }
+      // builtins.listToAttrs (
+        map (a: {
+          name = a;
+          value = key;
+        }) val
+      )
+    else if builtins.isString val then
+      acc // { ${key} = val; }
+    else
+      acc
+  ) { } (builtins.attrNames all_follow_raw);
 
   fetchPin = name: builtins.fetchTree lock.${name};
 
@@ -134,6 +157,30 @@ let
       in
       if pinType == "flake" then evalTopFlake sourceInfo pin else sourceInfo.outPath + subdir;
 
-  self = builtins.mapAttrs loadPin pins.inputs;
+  declared = pins.inputs or { };
+
+  # any lock entry without a declared [inputs] mate is an auto-dedup synthetic
+  # written by `tack update` for [all_follow] targets that aren't pinned
+  # top-level. fall back to the bare source tree if the fetched tree has no
+  # flake.nix (so `flake = false` consumers get a usable sourceInfo)
+  autoNames = builtins.filter (n: !(declared ? ${n})) (builtins.attrNames lock);
+  autoPin =
+    name:
+    let
+      sourceInfo = fetchPin name;
+    in
+    if builtins.pathExists (sourceInfo.outPath + "/flake.nix") then
+      evalTopFlake sourceInfo { }
+    else
+      sourceInfo;
+
+  self =
+    (builtins.mapAttrs loadPin declared)
+    // builtins.listToAttrs (
+      map (name: {
+        inherit name;
+        value = autoPin name;
+      }) autoNames
+    );
 in
 self

README.md

@@ -52,7 +52,10 @@ tack dedup                           report inputs reachable from multiple pins
 
 `tack dedup` reports inputs reachable from more than one of your pins, whether
 direct or transitive, and recurses through the pins of your pins indefinitely.
-when a top-level pin matches, it suggests an `[all_follow]` rule to share it.
+its output is two sub-blocks of ready-to-paste `[all_follow]` rules. the first
+block refers to existing top-level pins, the subsequent one refers to inputs tack
+will synthesise on the next `tack update`. targets with multiple aliases collapse
+into a single array entry.
 
 ## pin types
 
@@ -98,17 +101,31 @@ url = "gh:owner/foo"
 follows = { nixpkgs = "nixpkgs" }   # foo's nixpkgs -> your nixpkgs pin
 ```
 
-`all_follow` applies a rule to every pin that has a matching input
+`all_follow` applies a rule to every pin that has a matching input. two value
+shapes are accepted:
 
 ```toml
 [all_follow]
-nixpkgs = "nixpkgs"   # every input named nixpkgs follows your nixpkgs pin
+# alias -> target. every input named fenix follows your top-level fenix pin
+fenix = "fenix"
+
+# target -> [aliases]. the key is the canonical target, and the key plus every
+# array member alias to it. one row covers many aliases of the same target
+nixpkgs = ["nixpkgs-stable", "nixpkgs-unstable"]
 
 [inputs.bar]
 url = "gh:owner/bar"
 exclude_follow = ["nixpkgs"]   # ...except bar's
 ```
 
+when a target named in `[all_follow]` isn't itself a top-level `[inputs]` pin,
+`tack update` synthesises a lock entry for it by walking every top-level
+flake.lock, collecting the observed revs of the aliased name, and writing the
+freshest by `lastModified` into pins.lock.json. the resolver then treats the
+synthetic entry as a default flake, or as a bare source tree when its repo has
+no `flake.nix`. this lets you dedup transitive inputs (e.g. `crane`) without declaring
+them as top-level pins you don't actually consume.
+
 ## build
 
 ```

assets/pins.toml

@@ -9,6 +9,7 @@
 # opt out per-input with exclude_follow
 [all_follow]
 # nixpkgs = "nixpkgs"
+# nixpkgs = ["nixpkgs-stable", "nixpkgs-unstable"]
 
 # [inputs.<name>] fields
 #   url             required, shorturl ok; ?rev=<sha> pins an exact commit