repro: dir-copy x nested-entry footprint collision (case 5), flip fixed cases to regression guards

2026.8.10 landed jdx/mise#12190: cases 1 and 3 now compose, so they guard
the fix instead of asserting the bug. Case 5 adds the new one: composition
never checks a directory entry's source footprint, so a root that declares
a file inside another root's copied directory applies silently in glob
order, the loser drifts forever, and unapply --force removes both entries'
files. Case 6 pins the documented exact-path conflict as the contrast.

Author: Guria

README.md

@@ -1,41 +1,51 @@
-# mise `config_roots`: same-target `symlink-each` conflicts on disjoint leaves
+# mise `config_roots`: dotfiles composition cases
 
-Minimal repro for the `[bootstrap].config_roots` composition shipped in
-mise 2026.8.9 (jdx/mise#12105, jdx/mise#12132). Verified against 2026.8.9.
-
-Run:
+Fixture trees for the `[bootstrap].config_roots` dotfiles composition,
+verified against mise **2026.8.10**. Run:
 
     ./run.sh                          # uses `mise` from PATH
     MISE_BIN=/path/to/mise ./run.sh
 
 Every case is a materialized tree under `case*/`. `run.sh` copies each into
 a throwaway sandbox (`mktemp -d`) and runs mise with an isolated HOME —
-nothing touches the real home. Exit code 0 means every case reproduced the
-behavior in the table below — including the two conflicts. When mise gains
-merge semantics for same-target `symlink-each`, cases 1 and 3 turn into
-successes and `run.sh` starts failing: it doubles as the fix detector.
+nothing touches the real home. Exit 0 means every case reproduced the
+behavior in the table below. Case 5 asserts the open bug: when mise starts
+rejecting that collision, case 5 fails — the script doubles as the fix
+detector.
 
-| case | layout | result on 2026.8.9 |
+| case | layout | result on 2026.8.10 |
 |---|---|---|
-| 1 | two roots declare `"~/.config/mise/"` `symlink-each`, sources hold disjoint leaves (`a.toml` / `b.toml`) | error `conflicting dotfile declarations`, both origins named |
-| 2 | same bundles, distinct targets | composes; both leaves linked |
-| 3 | case 1 tree, `mise bootstrap` invoked from `bundles/a` | same conflict — the parent's `config_roots` is active in child invocations |
-| 4 | two roots write managed blocks with distinct ids into one file | merges — same-file composition exists for blocks, keyed by `(path, id)` |
-
-## The ask
-
-Compose same-target `symlink-each` by unioning the source trees and
-conflicting only when two roots claim the same leaf path — the leaf-keyed
-merge `symlink-each` already performs against a pre-existing real
-directory. Merging into a directory it does not own is that mode's
-documented purpose, so a shared directory across roots is its primary
-composition case, not an error.
-
-## Real-world shape
-
-A dotfiles repo structured exactly like the release-notes example
-(`config_roots = ["bundles/*"]`) has 31 `symlink-each` declarations for
-`"~/.config/mise/"` across the bundle tree — each bundle links its own
-`config-mise/conf.d/<bundle>.toml` fragment into the shared directory,
-disjoint by construction. Case 3 additionally means adoption cannot be
-staged root by root: the glob is live for every child `mise bootstrap`.
+| 1 | two roots declare `"~/.config/mise/"` `symlink-each`, sources hold disjoint leaves | composes — fixed by jdx/mise#12190 (conflicted on 2026.8.9) |
+| 2 | same bundles, distinct targets | composes |
+| 3 | case 1 tree, `mise bootstrap` invoked from `bundles/a` | composes — the parent's `config_roots` is live in child invocations |
+| 4 | two roots write managed blocks with distinct ids into one file | merges, keyed by `(path, id)` |
+| 5 | root a: directory `copy` whose source **contains** `collide.txt`; root b: whole-file `copy` at `<dir>/collide.txt` | **open bug** — no conflict; entries apply in glob order and b silently wins; a's `status` reports `differs` forever; `unapply --force` from a removes both entries' files |
+| 6 | two roots claim the same target with `copy` | error `conflicting dotfile declarations`, both origins named — documented on https://mise.jdx.dev/bootstrap.html |
+
+## The ask (case 5)
+
+The composed-apply conflict check is exact-path: it rejects two whole-path
+entries with identical targets (case 6) and composes same-target
+`symlink-each` by disjoint leaf (case 1), but it never considers a directory
+entry's *source footprint*. When one root's directory copy contains a file
+that another root declares exactly, composition applies both and resolves
+the collision silently by config order — against the documented
+"Independent roots never acquire precedence from their order in
+`config_roots`".
+
+Reject this footprint collision before any mutation, the way jdx/mise#12190
+already does for same-target `symlink-each` leaves ("reject duplicate leaves
+and file/directory footprint collisions before any mutation") — or, if
+silent last-writer-wins is intended, document the nesting exception
+explicitly, including on https://mise.jdx.dev/dotfiles.html, whose modes
+table ("Directory copies are additive") currently reads as if such overlap
+is safe.
+
+## History
+
+This repo originally reproduced the 2026.8.9 behavior where cases 1 and 3
+(same-target `symlink-each`, disjoint leaves) hard-errored; jdx/mise#12190
+fixed that in 2026.8.10 and those cases now serve as regression guards. The
+discovering dotfiles repo migrated to per-bundle scoped `copy` targets
+(disjoint by construction); rendering one template next to a copied
+directory exposed case 5's shape.

case5-nested-copy-collision/bundles/a/mise.toml

@@ -0,0 +1,2 @@
+[dotfiles]
+"~/.config/demo" = { source = "srcA", mode = "copy" }

case5-nested-copy-collision/bundles/a/srcA/collide.txt

@@ -0,0 +1 @@
+A version

case5-nested-copy-collision/bundles/a/srcA/own-a.txt

@@ -0,0 +1 @@
+A own

case5-nested-copy-collision/bundles/b/f.txt

@@ -0,0 +1 @@
+B version

case5-nested-copy-collision/bundles/b/mise.toml

@@ -0,0 +1,2 @@
+[dotfiles]
+"~/.config/demo/collide.txt" = { source = "f.txt", mode = "copy" }

case5-nested-copy-collision/mise.toml

@@ -0,0 +1,2 @@
+[bootstrap]
+config_roots = ["bundles/*"]

case6-copy-same-target/bundles/a/mise.toml

@@ -0,0 +1,2 @@
+[dotfiles]
+"~/.config/demo" = { source = "srcA", mode = "copy" }

case6-copy-same-target/bundles/a/srcA/own-a.txt

@@ -0,0 +1 @@
+A own

case6-copy-same-target/bundles/b/mise.toml

@@ -0,0 +1,2 @@
+[dotfiles]
+"~/.config/demo" = { source = "srcB", mode = "copy" }