@vzn/vx-migrate 0.0.591 → 0.0.594

package/README.md

@@ -58,7 +58,7 @@ Rules:
 - `dependsOn`: `^x` passes through when some package runs `x`, and is dropped when none does (Turbo gives it no edges; core refuses a `^x` no project declares as a typo); `pkg#task` is kept only when `pkg` emits `task` (else a todo: edge dropped); a same-package task Turbo defines but the package has no script for is Turbo's no-op node, so its own edges pass through in its place (`test → codegen → ^build` with no `codegen` script is `test → ^build`); another package's `^x` or `pkg#x` reaches such a node through a group task when its edges name a task of its own package or another (with-tailwind's `ui` has no `build` script; its `build` builds `build:styles` and `build:components`, and `web#build` waits on them), and so does one whose `^` edge names another task (rallly's script-less `build` holds `^db:generate`), while one whose only edge is `^` to its own name needs none, since core's `^x` walks past a package without `x`; a no-op node nothing else reaches runs nothing, its own edges included, where Turbo still runs them (kitchen-sink's `turbo run test` builds `@repo/ui` for `admin`, which has no `test` script; `vx run test --all` does not, and `vx run build test --all` does both); a name Turbo does not define has no edge; `$TURBO_ROOT$` deps are a todo. Root `//#task`s run in the workspace root, as under Turbo: `turbo()` names the root a project through core's `discover` stage when turbo.json declares one (no `vx.config` needed; a root no member glob lists), and `//#x` in `dependsOn` is an edge to it, named by the root `package.json` `name`; a root task's globs are the workspace's (`workspaceFiles`), since Turbo hashes a root task over the whole repo; with no root project (a root `package.json` with no `name`, or one a package holds) they are a note and such an edge a todo. Turbo runs no plain task in the root package of a monorepo, and neither does `turbo()`; in a single-package repo (no workspaces, Turbo's `non-monorepo` example) turbo.json's plain tasks run on the root package, as under Turbo.
 - A transit node (Turbo's documented pattern, its with-vitest example: `transit: { dependsOn: ["^transit"] }` with no script anywhere, and `test: { dependsOn: ["transit"] }`) is a key-only task in each package that defines it: it runs `true`, cached and keyed on its inputs, with its `^transit` edge, so a dependant's `test` re-keys on its dependencies' sources as Turbo re-hashes it. A `^` task that some package has a script for, or that nothing depends on, is no transit node. A package without the script of a `^` task others run gets the same key-only task, as Turbo hashes a no-op node there: an edit to it re-keys its dependants. A `build` whose only edge is `^build` is not written: core gives every project with no `build` that node (solid's three script-less packages each got a `build` running `true`).
 - `with` (tasks Turbo runs alongside, `web#dev` with `api#dev`): an edge to each sidecar that is persistent, so vx starts the task once the sidecar has spawned and runs the sidecar only when the task runs; a sidecar that ends would be waited for, so it is a todo instead, and a pair that names each other keeps one edge (two would be a cycle). A task with no script whose `with` names persistent sidecars (Turbo's with-tailwind example: `ui` has no `dev` script, its `dev` starts `dev:styles` and `dev:components`) is a group task that depends on them.
-- `inputs`: a structured entry (Turbo 2.11) is its `globs`, plus `**/*` with `withDefaults`, for `startup` and `jit` alike; `dependencyOutputs` adds none (vx folds each dependency's key). Then: absent or `[]` → `**/*` (Turbo's default); `$TURBO_DEFAULT$` → `**/*`; exclusions alone narrow `**/*`; `$TURBO_ROOT$/<path>` → `cache.inputs.workspaceFiles` (negation kept); any other `$TURBO_ROOT$` use is a todo. `globalDependencies` and Turbo 1's `globalDotEnv` land in `workspaceFiles` too, and a task's Turbo 1 `dotEnv` in its `files`. Turbo 1's `$NAME` entries, in `globalDependencies` or a task's `dependsOn`, are env vars: they join `cache.inputs.env` and `exec.env.passThrough`. A package nested in the task's package (cal.com's apps inside `@calcom/app-store`) is hashed by Turbo with its parent, and core's globs stop at a project: each glob that reaches one is also listed in `cache.inputs.workspaceFiles`. Turbo's glob grammar is translated as Nx's is (`*.[jt]s` is `*.{[jt],j,t}s`); an input with no safe form widens to `**/*` with a todo. A `.env`-shaped input (`.env*`, `.env.local`, a task's Turbo 1 `dotEnv`, create-turbo's `globalDependencies: ["**/.env.*local"]`) is gitignored as a rule, so it is keyed by a probe that hashes the `.env` files it can name (`cache.inputs.runtime`) or, for a root entry, the files its root-relative globs name, hidden ones too, as Turbo's `*` matches them (`workspaceRuntime`; `**/<name>` is a `find -name` that skips `node_modules`, and another `**` walks the workspace), rather than as a file glob git never reports. A package whose `.env` globs all sit at its root gets a one-shell probe of that directory; one below the root walks the package.
+- `inputs`: a structured entry (Turbo 2.11) is its `globs`, plus `**/*` with `withDefaults`, for `startup` and `jit` alike; `dependencyOutputs` adds none where the producer is cached (vx folds each dependency's key); from a `cache: false` producer (vercel/vercel's `//#generate:cache-keys`, which records the host) the named files, or its outputs, are a `cache.inputs.workspaceRuntime` probe, and `cache.inputs.tasks` leaves the producer out, so core answers the probe after it ran. Then: absent or `[]` → `**/*` (Turbo's default); `$TURBO_DEFAULT$` → `**/*`; exclusions alone narrow `**/*`; `$TURBO_ROOT$/<path>` → `cache.inputs.workspaceFiles` (negation kept); any other `$TURBO_ROOT$` use is a todo. `globalDependencies` and Turbo 1's `globalDotEnv` land in `workspaceFiles` too, and a task's Turbo 1 `dotEnv` in its `files`. Turbo 1's `$NAME` entries, in `globalDependencies` or a task's `dependsOn`, are env vars: they join `cache.inputs.env` and `exec.env.passThrough`. A package nested in the task's package (cal.com's apps inside `@calcom/app-store`) is hashed by Turbo with its parent, and core's globs stop at a project: each glob that reaches one is also listed in `cache.inputs.workspaceFiles`. Turbo's glob grammar is translated as Nx's is (`*.[jt]s` is `*.{[jt],j,t}s`); an input with no safe form widens to `**/*` with a todo. A `.env`-shaped input (`.env*`, `.env.local`, a task's Turbo 1 `dotEnv`, create-turbo's `globalDependencies: ["**/.env.*local"]`) is gitignored as a rule, so it is keyed by a probe that hashes the `.env` files it can name (`cache.inputs.runtime`) or, for a root entry, the files its root-relative globs name, hidden ones too, as Turbo's `*` matches them (`workspaceRuntime`; `**/<name>` is a `find -name` that skips `node_modules`, and another `**` walks the workspace), rather than as a file glob git never reports. A package whose `.env` globs all sit at its root gets a one-shell probe of that directory; one below the root walks the package.
 - `outputs`: `$TURBO_ROOT$/<path>` → `cache.outputs.workspaceFiles`; a negated output rides beside its positives and takes its paths back from the clean, the save and the restore (Next's `.next/**` minus `!.next/cache/**` keeps the cache), and one with no positive beside it takes back nothing and is dropped. Past its first segment an output takes Turbo's grammar (`dist/**/*.[cm]js`); the first stays a literal (a route directory). An output whose first segment is a wildcard (`**/*.d.ts`, `*/**`) runs the task uncached with a todo: Turbo never cleans an output, vx cleans it before every run, and such a glob reaches the sources. One segment with a literal extension the package tracks no file of (`*.xml`, `*.tsbuildinfo`) reaches only top-level artifacts and stays cached, and so does `**/<dir>/**` when the package tracks nothing under a directory of that name (vercel/ai's `**/dist/**`; `node_modules` is never an output), and so does a first segment no tracked top-level entry matches (tldraw's `dist-*/**`). A wildcard first segment with a literal rest (clerk's `*/package.json`, the subpath stubs it commits) reaches only files of that name: each committed one, up to 16, is taken back with `!` and the task stays cached; more, and it runs uncached. An output that covers the package's own `package.json` (trpc's client build lists it: the build rewrites `exports`) runs the task uncached with a todo: vx would delete the manifest before every run, and core refuses that config. `nx()` takes the manifest back with `!package.json` instead and keeps the cache (owner, 2026-10-03). So does one that covers the package's vx.config; `turbo()` and `nx()` check the config the package has, and `vx-migrate` the one it writes, so sanity's `*.js` shims stay cached beside none. `nx()` keeps a wildcard-first output cached instead: each committed file it reaches is taken back with `!` (past sixteen, uncached with a todo), and the clean removes the rest, what the task writes (owner, 2026-10-03). A committed file under an output (typescript-eslint's `data/sponsors.json` in a cached `data`) is taken back with `!` — Turbo and Nx never clean an output, vx does — so it survives the clean and the task keeps its cache; past sixteen such files the task runs uncached with a todo. `turbo()` and `nx()` both do this, and so do the configs `vx-migrate` writes from turbo.json or an Nx graph (each take-back is a todo there, as it names files a later commit may move).
 - `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.
@@ -105,6 +105,7 @@ Nx's own option handling, rendered as one POSIX `sh` line (`vx show` prints it):
 - **An argument replaces its option:** an option the arguments after `vx run … --` name (`--region=us`, `--region us`, `--no-region`, `-r` for a one-letter option; no camel-case expansion) is not appended, as Nx drops it; the line decides once it has them. `tests/nx-run-commands-override-live.test.ts` holds it to `nx run`.
 - **Environment:** `env` is `exec.env.define` (so it is in the key), and `color: true` sets `FORCE_COLOR=true`, as Nx does (nx#20465). `envFile` is loaded after the task's `.env` files (below), a name they already set winning, as in Nx (nx#23581).
 - **`readyWhen`** makes the task persistent with that string as its `readyWhen`, so dependents start once it is printed; several strings, all of which Nx waits for, run the line under `nx-env --ready-when` (one flag per string), which passes the output through and prints `nx-env: ready` once every string has appeared on stdout or stderr; that line is the task's `readyWhen`.
+- **A leading Nx call** (`nx <target> <project>`, `nx run <project>:<target>`, through `npx` / `pnpm` / `yarn` / `bunx` or not) in a serial line, or as its one command, is a `dependsOn` edge to that target (its default configuration, as Nx runs it) and leaves the line: ngrx's `build` opens with `nx build-package <project>`. One Nx would hand options or arguments to, one after another command, and one in a parallel line stay commands.
 - **Reported, not reproduced:** per-command `prefix` / `color` decoration, `streamOutput: false`. Decoration in a serial run (`parallel: false`), which Nx refuses, is the failing placeholder with Nx's reason, as `readyWhen` there is. Display-only options (`usePty`, `tty`, `verbose`) change nothing here: vx runs every task without a pseudo-terminal.
 
 `tests/nx-exec-live.test.ts` holds each of these shapes to Nx's own run-commands executor on the same options and arguments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.591",
+  "version": "0.0.594",
   "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.591"
+    "@vzn/vx": "^0.0.594"
   },
   "repository": {
     "type": "git",

package/src/adoption-plugin.ts

@@ -111,7 +111,8 @@ export function adoptionPlugin(
         // only reads a stage-given task after validating it. The copy was
         // the per-process memo's guard and cost 10 ms per run at 1,000
         // projects, 3,000 clones (item 609).
-        config.tasks[t.name] ??= t.task as unknown as TaskConfig
+        if (!Object.hasOwn(config.tasks, t.name))
+          config.tasks[t.name] = t.task as unknown as TaskConfig
       }
     },
     // The root files the mapping reads (`turbo.json`, `nx.json`) shape every

package/src/nx/nx-deps.ts

@@ -19,7 +19,7 @@ export type TaskNameFor = (project: string, target: string, configuration: strin
  * "depends on …#codegen but no such task is declared". Dropped here as
  * Nx drops it, for this project and a named one alike.
  */
-export type HasTarget = (project: string, target: string) => boolean
+type HasTarget = (project: string, target: string) => boolean
 
 /**
  * The graph nodes a `projects` list names, ported from Nx's

package/src/nx/nx-map.ts

@@ -800,6 +800,10 @@ function buildTask(
     meta.packageJson,
     opts.manifestField,
     opts.executors,
+    (p, t) =>
+      !(p === nodeName && t === targetName) &&
+      metaByNode.has(p) &&
+      Object.hasOwn(nodeMap[p]?.data?.targets ?? {}, t),
   )
 
   const inputs = emptyNxInputs()
@@ -845,6 +849,12 @@ function buildTask(
       : { node: nodeName, configuration: variant.configuration! },
     options,
   )
+  // A nested `nx <target>` runs the target's default configuration, whatever this one runs.
+  for (const c of mapped?.nxCalls ?? []) {
+    const edge =
+      c.project === nodeName ? c.target : `${metaByNode.get(c.project)!.name}#${c.target}`
+    if (!deps.includes(edge)) deps.push(edge)
+  }
 
   // Nx's rule, not a guess: a target is cached when it says `cache: true`
   // (Nx ≥ 17 writes it into the graph from `cacheableOperations` too —
@@ -1003,6 +1013,8 @@ interface MappedCommand {
   readonly envInputs: readonly string[]
   /** A translated executor's `exec.timeout`. */
   readonly timeout?: number
+  /** The Nx targets a leading `nx <target> <project>` ran: dependency edges (nx-command.ts). */
+  readonly nxCalls?: readonly { readonly project: string; readonly target: string }[]
 }
 
 /**
@@ -1025,6 +1037,7 @@ function mapCommand(
   manifest: { readonly name?: unknown; readonly version?: unknown },
   manifestField: MapNxOptions['manifestField'],
   executors: NxExecutors | undefined,
+  isTarget: (project: string, target: string) => boolean,
 ): MappedCommand | null {
   const executor = target.executor
   if (executor === 'nx:noop') {
@@ -1063,7 +1076,7 @@ function mapCommand(
   if (executor === 'nx:run-commands' || plain) {
     const rc = mapRunCommands(
       plain ? { ...options, command: target.command } : options,
-      { projectRel, projectName },
+      { projectRel, projectName, isTarget },
       todos,
     )
     if (rc === null) return line(PLACEHOLDER)
@@ -1075,7 +1088,10 @@ function mapCommand(
         : path.posix.isAbsolute(rc.envFile)
           ? rc.envFile
           : relPosix(projectRel, path.posix.normalize(rc.envFile))
-    return shell(rc.command, envFile, { env: rc.env, readyWhen: rc.readyWhen }, rc.readyAll)
+    return {
+      ...shell(rc.command, envFile, { env: rc.env, readyWhen: rc.readyWhen }, rc.readyAll),
+      ...(rc.nxCalls === undefined ? {} : { nxCalls: rc.nxCalls }),
+    }
   }
   if (executor === 'nx:run-script') {
     const script = typeof options.script === 'string' ? options.script : targetName

package/src/nx-command.ts

@@ -40,13 +40,15 @@ interface NxCommandContext {
   readonly projectRel: string
   /** The Nx project name, what `{projectName}` expands to. */
   readonly projectName: string
+  /** Whether a vx task runs Nx project `project`'s `target`: what a leading `nx <target> <project>` may become. */
+  readonly isTarget?: (project: string, target: string) => boolean
 }
 
 /** The line `nx-env --ready-when` prints once every string is seen (`READY` in nx-env.cjs). */
 const NX_ENV_READY = '^nx-env: ready$'
 
 /** A run-commands target as vx runs it. */
-export interface RunCommandsLine {
+interface RunCommandsLine {
   readonly command: string
   /** `exec.env.define`: the target's `env`, and `FORCE_COLOR` under `color`. */
   readonly env: Readonly<Record<string, string>>
@@ -60,8 +62,18 @@ export interface RunCommandsLine {
   readonly readyAll?: readonly string[]
   /** `envFile` as declared: workspace-root-relative, or absolute. */
   readonly envFile: string | undefined
+  /**
+   * The Nx targets the line's leading `nx <target> <project>` /
+   * `nx run <project>:<target>` commands ran, taken out of the line: each
+   * is a dependency edge instead.
+   */
+  readonly nxCalls?: readonly { readonly project: string; readonly target: string }[]
 }
 
+/** `nx <target> <project>` or `nx run <project>:<target>`, through a package runner or not, with nothing else. */
+const NX_CALL =
+  /^(?:(?:npx|bunx|pnpm(?: exec)?|yarn)\s+)?nx\s+(?:run\s+([\w@./-]+):([\w:.-]+)|([\w:.-]+)\s+([\w@./-]+))$/
+
 /** The options run-commands consumes itself; every other one is forwarded to each command. */
 const PROP_KEYS: ReadonlySet<string> = new Set([
   'command',
@@ -306,8 +318,6 @@ export function mapRunCommands(
       'nx:run-commands: per-command `prefix` / `color` output decoration is not reproduced',
     )
   }
-  if (entries.length === 0) return { command: NOOP, env, readyWhen: undefined, envFile }
-
   const argsOption = Array.isArray(options['args'])
     ? options['args'].join(' ')
     : typeof options['args'] === 'string'
@@ -328,6 +338,27 @@ export function mapRunCommands(
         ? options['forwardAllArgs']
         : true
 
+  // A command that runs another target under Nx, ahead of the rest of a
+  // serial line (ngrx's `build` opens with `nx build-package <project>`),
+  // ran Nx inside the task and kept two cached tasks on one output with no
+  // edge between them; as an edge, the target runs first as Nx ran it. One
+  // Nx would hand options or arguments to stays a command.
+  const nxCalls: { project: string; target: string }[] = []
+  if ((!parallel || entries.length === 1) && readyWhen.length === 0 && ctx.isTarget) {
+    while (entries.length > 0) {
+      const e = entries[0]!
+      const m = NX_CALL.exec(e.command.trim())
+      if (m === null || (forwardAll(e) && (unknown.length > 0 || argsOption))) break
+      const project = m[1] ?? m[4]!
+      const target = m[2] ?? m[3]!
+      if (!ctx.isTarget(project, target)) break
+      nxCalls.push({ project, target })
+      entries.shift()
+    }
+  }
+  const calls = nxCalls.length > 0 ? { nxCalls } : {}
+  if (entries.length === 0) return { command: NOOP, env, readyWhen: undefined, envFile, ...calls }
+
   const commands: Interpolated[] = []
   let named = false
   for (const e of entries) {
@@ -384,7 +415,7 @@ export function mapRunCommands(
   const only = commands.length === 1 ? commands[0]! : undefined
   if (only !== undefined && only.runtime === 'append' && only.baked.length === 0) {
     const line = only.tail === undefined ? only.text : `${only.text} ${only.tail}`
-    return { command: `${cd}${line}`, env, readyWhen: pattern, envFile, ...ready }
+    return { command: `${cd}${line}`, env, readyWhen: pattern, envFile, ...ready, ...calls }
   }
   // A subshell per command, as Nx gives each a shell of its own; a comment
   // in one must not swallow the `)` that closes it.
@@ -437,6 +468,7 @@ export function mapRunCommands(
     readyWhen: pattern,
     envFile,
     ...ready,
+    ...calls,
   }
 }
 

package/src/paths.ts

@@ -27,10 +27,12 @@ export function relPosix(from: string, to: string): string {
  * holds: a string or an array would enumerate its INDICES as script names,
  * and indexing one by a task named `0` yields a single character that reads
  * as a usable command. Core's `migrate-scripts.ts` guards this read; these
- * mappers did not.
+ * mappers did not. Null-prototype, so a turbo.json task or Nx target named
+ * `constructor` or `toString` finds no script rather than Object's method.
  */
 export function packageScripts(meta: ProjectMeta): Record<string, unknown> {
   const raw = (meta.packageJson as unknown as { scripts?: unknown }).scripts
-  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) return {}
-  return raw as Record<string, unknown>
+  const scripts: Record<string, unknown> = Object.create(null)
+  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) return scripts
+  return Object.assign(scripts, raw)
 }

package/src/turbo/turbo-map.ts

@@ -500,6 +500,11 @@ function tasksOf(cfg: TurboJson): Record<string, TurboTask> {
   return cfg.tasks ?? cfg.pipeline ?? {}
 }
 
+/** A turbo.json's own task `key`: a plain index reads `constructor` off Object. */
+function taskAt(tasks: Record<string, TurboTask>, key: string): TurboTask | undefined {
+  return Object.hasOwn(tasks, key) ? tasks[key] : undefined
+}
+
 function declares(meta: ProjectMeta, dependency: string): boolean {
   const pj = meta.packageJson as unknown as Record<string, unknown>
   // Turbo counts every kind but a peer in a monorepo.
@@ -627,7 +632,7 @@ function taskDefined(
   const cfg = files.get(at)
   if (cfg === undefined) return at === ROOT ? 'none' : taskDefined(pkgName, name, files, ROOT, seen)
   const tasks = tasksOf(cfg)
-  const def = tasks[`${pkgName}#${name}`] ?? tasks[name]
+  const def = taskAt(tasks, `${pkgName}#${name}`) ?? taskAt(tasks, name)
   if (def !== undefined) return optedOut(def) ? 'excluded' : 'found'
   if (at === ROOT) return 'none'
   for (const parent of parentsOf(cfg)) {
@@ -666,7 +671,9 @@ function taskNamesFor(
 function definitionOf(pkgName: string, name: string, chain: readonly TurboJson[]): TurboTask {
   const defs = chain.map((cfg, i) => {
     const tasks = tasksOf(cfg)
-    return i === 0 ? (tasks[`${pkgName}#${name}`] ?? tasks[name]) : tasks[name]
+    return i === 0
+      ? (taskAt(tasks, `${pkgName}#${name}`) ?? taskAt(tasks, name))
+      : taskAt(tasks, name)
   })
   let from = 0
   for (let i = defs.length - 1; i > 0; i--) {
@@ -676,16 +683,43 @@ function definitionOf(pkgName: string, name: string, chain: readonly TurboJson[]
     }
   }
   let def: TurboTask = {}
+  let fromDeps: DependencyOutputs | null = null
   for (const d of defs.slice(from)) {
     if (d === undefined) continue
     const own: TurboTask = { ...d }
     delete own.extends
-    if (Array.isArray(own.inputs)) own.inputs = flatInputs(own.inputs)
+    if (Array.isArray(own.inputs)) {
+      const found = dependencyOutputsOf(own.inputs)
+      if (found !== null || !own.inputs.includes(TURBO_EXTENDS)) fromDeps = found
+      own.inputs = flatInputs(own.inputs)
+    }
     def = withOverlay(def, own)
   }
+  if (fromDeps !== null) dependencyOutputs.set(def, fromDeps)
   return def
 }
 
+/** A task's `{ mode: "dependencyOutputs" }` input: the producers it names, and which of their files. */
+interface DependencyOutputs {
+  from: readonly string[] | null
+  globs: readonly string[]
+}
+
+/** Held beside a resolved definition, out of the keys the unknown-key check reads. */
+const dependencyOutputs = new WeakMap<TurboTask, DependencyOutputs>()
+
+function dependencyOutputsOf(inputs: readonly unknown[]): DependencyOutputs | null {
+  for (const i of inputs) {
+    if (i === null || typeof i !== 'object') continue
+    const { mode, from, globs } = i as { mode?: unknown; from?: unknown; globs?: unknown }
+    if (mode !== 'dependencyOutputs') continue
+    const strings = (v: unknown): string[] =>
+      Array.isArray(v) ? v.filter((g): g is string => typeof g === 'string') : []
+    return { from: Array.isArray(from) ? strings(from) : null, globs: strings(globs) }
+  }
+  return null
+}
+
 /**
  * Turbo 2.11's structured inputs as the strings they stand for: a
  * `startup` or `jit` entry is its globs (and every file with
@@ -1381,6 +1415,67 @@ export async function mapTurboWorkspace(
     projects.push({ name: meta.name, dir: meta.dir, tasks })
   }
 
+  // Turbo 2.11's `dependencyOutputs` input hashes the named files after
+  // their producer ran. A cached producer's key already reaches the reader
+  // through `dependsOn`, its outputs following from it; an uncached one's
+  // (vercel/vercel's `//#generate:cache-keys`, which records the host) do
+  // not, and a test cached on one platform hit on another. The reader
+  // keys those files by a probe at the workspace root.
+  const metaNamed = new Map(metas.map((m) => [m.name, m]))
+  for (const meta of metas) {
+    const { defFor } = definitions(meta)
+    for (const t of projects.find((p) => p.name === meta.name)?.tasks ?? []) {
+      const def = defFor(t.name)
+      const dep = def === undefined ? undefined : dependencyOutputs.get(def)
+      const inputs = (t.task?.['cache'] as { inputs?: Record<string, unknown> } | undefined)?.inputs
+      if (dep === undefined || inputs === undefined) continue
+      const rels: string[] = []
+      const unfold = new Set<string>()
+      for (const sel of dep.from ?? def!.dependsOn ?? []) {
+        if (envDependency(sel) !== null) continue
+        const hash = sel.indexOf('#')
+        const producers: [ProjectMeta | undefined, string][] = sel.startsWith('^')
+          ? metas.filter((m) => declares(meta, m.name)).map((m) => [m, sel.slice(1)])
+          : hash === -1
+            ? [[meta, sel]]
+            : [
+                [
+                  sel.startsWith(`${ROOT}#`) ? rootMeta : metaNamed.get(sel.slice(0, hash)),
+                  sel.slice(hash + 1),
+                ],
+              ]
+        for (const [pm, task] of producers) {
+          if (pm === undefined) continue
+          const pdef = definitions(pm).defFor(task)
+          if (pdef?.cache !== false) continue
+          if (!sel.startsWith('^')) unfold.add(`${pm.name}#${task}`)
+          const at = relPosix(root, pm.dir)
+          for (const g of dep.globs.length > 0 ? dep.globs : (pdef.outputs ?? []))
+            if (!g.startsWith('!')) rels.push(at === '' ? g : `${at}/${g}`)
+        }
+      }
+      if (rels.length === 0) continue
+      const probe = rels.every(isLiteral) ? ignoredFilesProbe(rels) : dotenvGlobsProbe(rels)
+      if (probe === null) {
+        delete t.task!['cache']
+        t.todos.push(
+          `inputs read ${rels.map((r) => JSON.stringify(r)).join(', ')} from an uncached ` +
+            'dependency, a glob vx cannot key by a probe — task runs uncached; key it in a vx.config to cache it',
+        )
+        continue
+      }
+      const probes = (inputs['workspaceRuntime'] as unknown[] | undefined) ?? []
+      inputs['workspaceRuntime'] = [...probes, probe]
+      // Folded, the producer's key "covers" what it writes, and core answers
+      // the probe before it runs: the previous run's bytes. Left out of the
+      // fold, the probe waits for it (core's late probes, X-34).
+      const deps = (t.task!['dependsOn'] as string[] | undefined) ?? []
+      const id = (d: string) => (d.startsWith('^') || d.includes('#') ? d : `${meta.name}#${d}`)
+      if (deps.some((d) => unfold.has(id(d))))
+        inputs['tasks'] = deps.filter((d) => !unfold.has(id(d)))
+    }
+  }
+
   if (opts.ignored !== undefined) {
     const ignored = await opts.ignored([
       ...new Set(literals.tasks.flatMap((l) => [...l.rels.keys()])),

package/src/workspace-notes.ts

@@ -24,7 +24,7 @@ export function lockfilePlugin(root: string): { file: string; factory: string }
   return lock === undefined ? undefined : { file: lock[0], factory: lock[1] }
 }
 
-export interface AdoptedTool {
+interface AdoptedTool {
   /** The adoption plugin `vx init` declares: `turbo`, `nx`. */
   readonly plugin: string
   /** The file it reads every run: `turbo.json`, `nx.json`. */