@vzn/vx-migrate 0.0.578 → 0.0.579

package/README.md

@@ -63,7 +63,7 @@ Rules:
 - `env` / `passThroughEnv`: explicit names go to `cache.inputs.env` (env only) and `exec.env.passThrough` (both, plus both globals); a wildcard expands over the run's environment under `turbo()`, which maps where the tasks run (a new variable name such a wildcard matches maps afresh); the CLI, which writes for another environment, lists the names the task's package and its workspace dependencies spell (a root task: the whole repo; clerk's `E2E_*`), noted once per entry, and one nothing spells is a todo; `*` is the only wildcard, as in Turbo, so `\*`, a leading `\!`, `?` and `[` are literal: unkey's `NEXT_PUBLIC_\*` names one variable, which vx cannot key, so it is dropped and reported once for the workspace with the count of tasks naming it (openstatus's root `build` env `\*` had written one todo into each of 45 configs; `turbo()`: only when the run's environment sets it, as Turbo hashes nothing otherwise); and a `!` entry (openstatus' `!NEXT_PUBLIC_VERCEL_URL`) removes the names it matches from its list, with no todo, since vx matches no name it is not given. A name both a global list and the task's own list carry is listed once.
 - Framework inference (Turbo hashes and passes Next's `NEXT_PUBLIC_*`, Vite's `VITE_*`, … for a package that depends on the framework): `turbo()` expands the prefix over the run's environment; the CLI writes the names the tracked source and `.env.example` of the package and its workspace dependencies spell (the bare prefix, as a `startsWith` test spells it, is none) (Next bundles theirs: cal.com's web, 23 alone, 58 with them), and a note asks for any only an installed dependency reads.
 
-- **Two tasks of one package on one output path** (strapi's `build`, `build:code` and `build:types`, all on `dist/**`): vx cleans a task's outputs before it runs and before a restore, so the loader refuses two cached tasks whose outputs provably overlap. The mapping resolves it before the file is written — the task with a `^` edge keeps its cache (the first declared when none has one); a task a same-project edge orders after it stays cached too (vx caches what an ordered dependant ADDS to the tree — twenty's `build:individual` into `build`'s `dist`); the rest run uncached with a todo naming the keeper and the fix, their own output path or that edge. Same rule for Nx targets.
+- **Two tasks of one package on one output path** (strapi's `build`, `build:code` and `build:types`, all on `dist/**`): vx cleans a task's outputs before it runs and before a restore, so the loader refuses two cached tasks whose outputs provably overlap. Under vx's default `rules.exclusiveOutputs` an edge between the two changes nothing (twenty's `build:individual` writing into `build`'s `dist`). The mapping resolves it before the file is written — the task with a `^` edge keeps its cache (the first declared when none has one); the rest run uncached with a todo naming the keeper and the fix, their own output path. Same rule for Nx targets.
 - **Two packages' tasks on one workspace output** (cal.com's shared `post-install` writes `../../node_modules/@prisma/client/**` from every package with the script): core refuses two cached tasks on one path with no edge between them, so `turbo()` (and `nx()`) keeps the first (in package and task order) cached and runs the rest uncached, each with a todo naming the keeper. A package's own outputs count at their workspace path: typescript-eslint's root project caches `dist` and each package's typecheck `dist/packages/<name>`, one path twice. Edges across packages are not read, so an ordered pair loses its cache too.
 - `cache: false` or `persistent: true` → no `cache` block; a persistent task gets `exec.persistent: {}` and, when some task depends on it, the consumer's `persistentTodo`.
 - A task's `description` (Turbo 2.11.5's schema) is the vx task's `description`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.578",
+  "version": "0.0.579",
   "license": "MIT",
   "description": "Adopt @vzn/vx from Turborepo or Nx: run the repo unchanged, migrate it to vx.config.ts, and keep your Turbo or Nx remote cache",
   "keywords": [
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.578"
+    "@vzn/vx": "^0.0.579"
   },
   "repository": {
     "type": "git",

package/src/shared-outputs.ts

@@ -1,16 +1,18 @@
 // Two targets of one project on one output path. vx cleans a task's
 // declared outputs before it runs and before a cache-hit restore, so the
-// loader refuses two cached tasks whose outputs provably overlap — UNLESS
-// a same-project edge orders them (core item 588): then the dependant is
-// ADDITIVE, keeps its cache, and owns only what its run added. strapi
-// (2026-09-11) declares `build`, `build:code` and `build:types` all on
-// `dist/**`, and the refusal came at load time, after the migration had
-// reported clean. The mapping resolves it: the task with a `^` edge keeps
-// its cache (it is the one a dependant waits for), or the first declared
-// when none has one; every other task on that path stays cached when an
-// edge orders it against every kept task it overlaps, and otherwise runs
+// loader refuses two cached tasks whose outputs provably overlap, an edge
+// between them or not under core's default `rules.exclusiveOutputs` (X-53).
+// A workspace may turn the rule off (item 588's additive shape), but the
+// mapping never sees the workspace's rules, so it maps for the default and
+// loads under either.
+// strapi (2026-09-11) declares `build`, `build:code` and `build:types` all
+// on `dist/**`, and twenty's `build:individual` writes into `build`'s
+// `dist`; the refusal came at load time, after the migration had reported
+// clean. The mapping resolves it: the task with a `^` edge keeps its cache
+// (it is the one a dependant waits for), or the first declared when none
+// has one; every other task whose outputs overlap a kept task's runs
 // uncached, with a todo that names the keeper and the fix (its own output
-// path, or the edge).
+// path).
 //
 // The overlap question is core's own `outputsOverlap`, asked through the
 // façade. It used to be a COPY of it here, and the copy stopped being the
@@ -162,8 +164,6 @@ interface Cached {
   name: string
   files: string[]
   hasUpstreamEdge: boolean
-  /** Same-project `dependsOn` names (no `^`), for the ordering test. */
-  localDeps: string[]
 }
 
 function cachedOutputs(t: GeneratedTask, index: number): Cached | null {
@@ -179,10 +179,7 @@ function cachedOutputs(t: GeneratedTask, index: number): Cached | null {
   const deps = task['dependsOn']
   const hasUpstreamEdge =
     Array.isArray(deps) && deps.some((d) => typeof d === 'string' && d.startsWith('^'))
-  const localDeps = Array.isArray(deps)
-    ? deps.filter((d): d is string => typeof d === 'string' && !d.startsWith('^'))
-    : []
-  return { index, name: t.name, files: strings, hasUpstreamEdge, localDeps }
+  return { index, name: t.name, files: strings, hasUpstreamEdge }
 }
 
 /**
@@ -196,33 +193,6 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
     const c = cachedOutputs(t, i)
     if (c !== null) cached.push(c)
   })
-  // Does `from` reach `to` through same-project edges? The generated
-  // tasks of one project are the whole graph here.
-  // Every task, cached or not: a hop through an uncached group task is an
-  // edge too.
-  const depsByName = new Map<string, string[]>()
-  for (const t of tasks) {
-    const deps = t.task?.['dependsOn']
-    depsByName.set(
-      t.name,
-      Array.isArray(deps)
-        ? deps.filter((d): d is string => typeof d === 'string' && !d.startsWith('^'))
-        : [],
-    )
-  }
-  const reaches = (from: Cached, to: Cached): boolean => {
-    const seen = new Set<string>()
-    const stack = [...from.localDeps]
-    while (stack.length > 0) {
-      const n = stack.pop()!
-      if (n === to.name) return true
-      if (seen.has(n)) continue
-      seen.add(n)
-      for (const d of depsByName.get(n) ?? []) stack.push(d)
-    }
-    return false
-  }
-  const ordered = (x: Cached, y: Cached): boolean => reaches(x, y) || reaches(y, x)
   const dropped = new Set<number>()
   for (const a of cached) {
     if (dropped.has(a.index)) continue
@@ -238,25 +208,22 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
     const kept: Cached[] = [keeper]
     for (const c of all) {
       if (c === keeper) continue
-      // Additive under core's rule when an edge orders it against every
-      // kept task whose outputs it overlaps: it stays cached, no todo.
-      const unordered = kept.find(
-        (k) => c.files.some((gb) => k.files.some((ga) => outputsOverlap(ga, gb))) && !ordered(c, k),
+      const clash = kept.find((k) =>
+        c.files.some((gb) => k.files.some((ga) => outputsOverlap(ga, gb))),
       )
-      if (unordered === undefined) {
+      if (clash === undefined) {
         kept.push(c)
         continue
       }
       dropped.add(c.index)
       const t = tasks[c.index]!
-      const shared = c.files.find((gb) => unordered.files.some((ga) => outputsOverlap(ga, gb)))!
+      const shared = c.files.find((gb) => clash.files.some((ga) => outputsOverlap(ga, gb)))!
       delete t.task!['cache']
       t.todos.push(
-        `declares the output ${JSON.stringify(shared)} that ${JSON.stringify(unordered.name)} also ` +
+        `declares the output ${JSON.stringify(shared)} that ${JSON.stringify(clash.name)} also ` +
           "declares — vx cleans a task's outputs before it runs and before a restore, so two " +
           "cached tasks on one path would delete each other's work; this one runs uncached. " +
-          `Give it its own output path to cache it, or a dependsOn edge on ${JSON.stringify(unordered.name)} ` +
-          'so vx orders them and caches what this one adds.',
+          'Give it its own output path to cache it.',
       )
     }
   }
@@ -272,9 +239,8 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
  * workspace path: typescript-eslint's root project caches `dist` and every
  * package's typecheck `dist/packages/<name>`, and core refused the run
  * over the nesting. Keepers are the first in project and task order;
- * every later task on a kept path runs uncached, with a todo. Edges are
- * not read: across projects they are the package graph's, which the
- * mapping does not hold, so an ordered pair loses its cache too.
+ * every later task on a kept path runs uncached, with a todo, edge or not,
+ * as core refuses the pair either way.
  */
 export function resolveSharedWorkspaceOutputs(
   root: string,
@@ -335,8 +301,7 @@ export function resolveSharedWorkspaceOutputs(
         rel === '' ? g.replace(/^(\.\/)+/, '') : `${rel}/${g.replace(/^(\.\/)+/, '')}`,
       )
       if (ws.length === 0 && own.length === 0) continue
-      // Two own outputs of one project are resolveSharedOutputs', which
-      // reads the edges that order them.
+      // Two own outputs of one project are resolveSharedOutputs'.
       const overlap = (a: string[], b: string[]): string | undefined =>
         a.find((g) => b.some((h) => outputsOverlap(h, g)))
       let clash: (typeof kept)[number] | undefined