@vzn/vx-migrate 0.0.596 → 0.0.598

package/README.md

@@ -47,7 +47,7 @@ Until `bunx @vzn/vx-migrate` writes native config, `vx run build --all` maps eve
 
 ### The mapper (`mapTurboWorkspace`)
 
-The plugin and the CLI read a repo the same way: the mapper the plugin runs live is what `bunx @vzn/vx-migrate` writes `vx.config.ts` per package from, splicing Turbo's global fields in as imports of a generated `vx-preset.ts`, where the plugin inlines the values; a global input another task writes to is taken back after the spread (`[...globalInputs, '!packages/plugin/dist/**']`), as the plugin takes it back from the inlined values. `splice` is the seam between the two consumers; `uses` names which globals a task drew on. Before 2026-09-10 the mapper lived in `@vzn/vx` itself; until 2026-09-11 the plugin was its own package, `@vzn/vx-turbo`.
+The plugin and the CLI read a repo the same way: the mapper the plugin runs live is what `bunx @vzn/vx-migrate` writes `vx.config.ts` per package from, splicing Turbo's global fields in as imports of a generated `vx-preset.ts` (its exports alone, no comments), where the plugin inlines the values; a global input another task writes to is taken back after the spread (`[...globalInputs, '!packages/plugin/dist/**']`), as the plugin takes it back from the inlined values. `splice` is the seam between the two consumers; `uses` names which globals a task drew on. Before 2026-09-10 the mapper lived in `@vzn/vx` itself; until 2026-09-11 the plugin was its own package, `@vzn/vx-turbo`.
 
 Rules:
 
@@ -56,7 +56,7 @@ Rules:
 - **The command is the script body** with its `pre<name>` / `post<name>` hooks folded in, in that order, through core's `foldScriptHooks`: each part in its own subshell, the chain stopping at the first that fails, forwarded `--` args reaching the body alone (npm and pnpm run them around `<name>` without being asked; novu's `prebuild` copies the CSS its `build` inlines), one process less per task than `pnpm run <name>` — except a body that calls yarn's `run` builtin (`run -T rollup -c`, `run clean && run build`; yarn ≥ 2 runs scripts in its own shell), which is `run: command not found` in sh: it runs as `yarn run <name>`, as Turbo and Nx run it, and yarn ≥ 2 runs no hooks, so none are folded there. A Yarn Plug'n'Play workspace (`.yarnrc.yml` with no `nodeLinker`, or `pnp`) has no `node_modules`: a dependency resolves only through `.pnp.cjs` and a bin only through yarn's shims, so there every script runs as `yarn run <name>`, and a `nodeLinker` change maps afresh. Same rules for `nx:run-script` below (strapi and novu, 2026-09-11).
 - **Turbo 2.11's task `command`** (`futureFlags.experimentalTaskCommand`) wins over the script, as Turbo holds it: an argv is the command — each word quoted, run from the package dir, no `pre`/`post` hooks — and gives the package the task even with no script (turborepo's `@turbo/types#build`, `docs#schema`); `null` or `[]` is Turbo's no-op node, no task even where the script exists, its edges passed through; a per-toolchain map applies its `javascript` entry (or `typescript`, Turbo's alias), and without one the script runs. A shape Turbo would refuse keeps the script, with a todo.
 - `dependsOn`: `^x` passes through when some package runs `x` or turbo.json defines it, and is dropped otherwise (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. A task turbo.json defines and no package has a script for (documenso's `lint`, shadcn-ui's `check`) is a group task in each package that defines it, its edges kept (a `pkg#task` edge only in `pkg`), so `vx run lint` runs Turbo's no-op nodes and exits 0 as `turbo run lint` does. 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`).
+- 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`). A dependency without the script whose own edges lack `^x` gets it too, so a `^x` stops there as Turbo's does (opencode's `build: { dependsOn: [] }`: core walked past to the builds below, which Turbo's `^build` never reaches).
 - `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 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).
@@ -88,7 +88,7 @@ import { nx } from '@vzn/vx-migrate'
 export default defineWorkspace({ plugins: [nx()] })
 ```
 
-Until `bunx @vzn/vx-migrate` writes native config, `vx run build --all` maps every project's `build` target the way `nx run-many -t build` would. The plugin reads Nx's **resolved** project graph — where Nx has already applied `targetDefaults`, expanded `namedInputs`, inferred targets through its plugins and interpolated `{projectRoot}` and friends — so nothing is re-derived here. Per target: `nx:run-commands` and a plain `command` run as one shell line that does what Nx's run-commands does (below); `nx:run-script` is the package script, with the `$npm_package_name`, `$npm_package_version` and `$npm_lifecycle_event` it reads defined as `<pm> run` sets them (a migration reads the name and version from the manifest it imports, so a bump reaches them; any other `$npm_*` is a todo); `nx:noop` is a group task, and so is a target with neither an executor nor a command that has dependencies, as Nx normalizes it (one with none is dropped, as Nx drops it); **every other executor runs through `nx-exec`** with the executor and its options on the command line. A target Nx caches (`cache: true`, or the legacy `cacheableOperations` list in `nx.json`) gets its `inputs` / `outputs` as the cache block, with no `inputs` meaning Nx's `default` and `^default`, named inputs resolved per project (nx.json's under the project's own; one neither defines, such as an `extends` preset not installed, keys the whole project with a todo, never an empty list that keys the task on its config alone), `{workspaceRoot}` / `{projectRoot}` / `{projectName}` interpolated anywhere in a path as Nx does (`{workspaceRoot}/coverage/{projectRoot}`), Nx's glob grammar translated (`*.[jt]s` is `*.{j,t}s`; the default `production` negation `?(*.)+(spec|test).[jt]s?(x)` becomes brace sets, a narrowing only a negation may take; what has no safe form is a todo), a project fileset of negations alone (nx-recipes' `noMarkdown`) starting from every project file, as Nx reads it, and an output outside the project dir (`dist/<project>` at the workspace root, Nx's default layout) a `workspaceFiles` output, an output outside the workspace (an old generator's `reportsDirectory: "../../coverage/<lib>"`) a todo and dropped, as vx caches only inside it, an output whose first segment is a wildcard (`{projectRoot}/**/*.d.ts`) cached, with each committed file it reaches taken back by `!` and the rest cleaned before the run (typescript-eslint's `**/*.shot`, 3,656 committed snapshots, is past sixteen and runs uncached with a todo), and an output that covers the project's own `package.json` or vx.config cached with the file taken back by `!`; `dependsOn` becomes the edges (`^build` — dropped when no project has the target, as Nx gives it no edges and core refuses a `^name` nothing declares — `build`, `project:target` → `project#target`, everything past `project:` one target name, as Nx joins it (`ui:build:esm` is ui's `build:esm`; `ui:build:ci` names target `build:ci`, never `build`'s `ci` configuration, and is no edge where ui lacks it), this project's own target winning over a project name, `{ target, projects }` → each matched project's task, `projects` read as Nx's `findMatchingProjects` reads it: a name or a list of names, globs over names and over project directories (`libs/*`), `name:` / `tag:` / `directory:` labels, a bare word as a word in a name, and `!` exclusions; an edge to a target its project lacks is dropped without a word, as Nx drops it — `targetDefaults` that give every `typecheck` a `codegen` one project has; `^name` is every dependency's `name` whatever it holds, `^rsbuild:typecheck` included; a target glob — `test:e2e--*`, `^build-*`, `ui:build-{esm,cjs}`, a `{ target }` object's — expands over every target name in the workspace, as Nx 19.5+ does, before those rules; a same-project glob keeps its own project's matches), `{ env }` inputs pass through (one that is no shell variable name is keyed only), `{ runtime }` inputs run at the workspace root as Nx runs them (`cache.inputs.workspaceRuntime`), a `{ fileset, includeIgnored: true }` literal (Nx 23 hashes it from disk, gitignored or missing) is read by such a probe, since vx's globs see only what git lists, and a glob of one is a todo, a target that says `continuous` — or, in a graph from an Nx older than that field, runs a server executor (`@nx/vite:dev-server`, `@nx/next:server`, …) — is a persistent task and never cached, ready on spawn as Nx has it (Nx starts the dependents once it has started; a run-commands `readyWhen` gates them, below). The target's name never decides: a cached `dev` caches like any other target (nx#32610). `parallelism: false` (Nx runs the target alone) has no vx form and is a todo naming `--concurrency 1`; `syncGenerators` (Nx runs them first) is one workspace note per generator list, counting its tasks and naming `nx sync`; nx.json's `sync.globalGenerators` is one note per run naming `nx sync`. A target with `configurations` is one task per configuration (one whose name another target holds, `vite`'s `build` beside an inferred `vite:build`, is not written, with a todo, as Nx resolves `a:vite:build` to the target): `build` carries the default configuration's options, `build:ci` the `ci` one, and an edge of `build:ci` (own, named or `^`) reaches each target's `ci` task where it declares one, else its default, as Nx's `resolveConfiguration` does; a `^build` there becomes one edge per dependency Nx links. A `^name` input (`^production`, `{ input, dependencies: true }`, the pre-17 `{ input, projects: "dependencies" }`; `projects: "self"` is the own input, as Nx 23 still reads both) is what Nx hashes: each dependency's `name`, over the project graph, whether or not a task edge exists. A `{ input, projects }` list is read as `dependsOn`'s `projects` is. Each project some reader reaches gets an `nx-input:<name>` task — `true`, cached, keyed on its own `name` input, depending on its Nx dependencies' twins (a project nothing reaches gets none) — and a task that reads `^name` depends on its direct dependencies' twins, so the whole closure folds into its key with each project hashed once. A dependency FILESET (`^{projectRoot}/tsconfig.lib.json`, `{ fileset, dependencies: true }`, which Nx's own inferred `typecheck` writes) folds the same way: its twin, `nx-input:fileset-<hash>` (a glob's `*` is no task name; the task's description names the fileset), keys on that fileset in each project. The twins show in a run's output; each costs about 0.16 ms of a warm run. A path input inside an output one of the project's own targets declares (TanStack/table's `public` input lists `{projectRoot}/dist`) is generated, and gitignored where Nx caches it: Nx's file map skips gitignored files, so Nx hashes nothing there (a changed `dist` file is a cache hit under Nx 23.3), and it is dropped without a todo, and the task that writes it keys its dependants through `dependsOn`.
+Until `bunx @vzn/vx-migrate` writes native config, `vx run build --all` maps every project's `build` target the way `nx run-many -t build` would. The plugin reads Nx's **resolved** project graph — where Nx has already applied `targetDefaults`, expanded `namedInputs`, inferred targets through its plugins and interpolated `{projectRoot}` and friends — so nothing is re-derived here. Per target: `nx:run-commands` and a plain `command` run as one shell line that does what Nx's run-commands does (below); `nx:run-script` is the package script, with the `$npm_package_name`, `$npm_package_version` and `$npm_lifecycle_event` it reads defined as `<pm> run` sets them (a migration reads the name and version from the manifest it imports, so a bump reaches them; any other `$npm_*` is a todo); `nx:noop` is a group task, and so is a target with neither an executor nor a command that has dependencies, as Nx normalizes it (one with none is dropped, as Nx drops it); **every other executor runs through `nx-exec`** with the executor and its options on the command line. A target Nx caches (`cache: true`, or the legacy `cacheableOperations` list in `nx.json`) gets its `inputs` / `outputs` as the cache block, with no `inputs` meaning Nx's `default` and `^default`, named inputs resolved per project (nx.json's under the project's own; one neither defines, such as an `extends` preset not installed, keys the whole project with a todo, never an empty list that keys the task on its config alone), `{workspaceRoot}` / `{projectRoot}` / `{projectName}` interpolated anywhere in a path as Nx does (`{workspaceRoot}/coverage/{projectRoot}`), Nx's glob grammar translated (`*.[jt]s` is `*.{j,t}s`; the default `production` negation `?(*.)+(spec|test).[jt]s?(x)` becomes brace sets, a narrowing only a negation may take; what has no safe form is a todo), a project fileset of negations alone (nx-recipes' `noMarkdown`) starting from every project file, as Nx reads it, and an output outside the project dir (`dist/<project>` at the workspace root, Nx's default layout) a `workspaceFiles` output, an output outside the workspace (an old generator's `reportsDirectory: "../../coverage/<lib>"`) a todo and dropped, as vx caches only inside it, an output whose first segment is a wildcard (`{projectRoot}/**/*.d.ts`) cached, with each committed file it reaches taken back by `!` and the rest cleaned before the run (typescript-eslint's `**/*.shot`, 3,656 committed snapshots, is past sixteen and runs uncached with a todo), and an output that covers the project's own `package.json` or vx.config cached with the file taken back by `!`; `dependsOn` becomes the edges (`^build` — dropped when no project has the target, as Nx gives it no edges and core refuses a `^name` nothing declares — `build`, `project:target` → `project#target`, everything past `project:` one target name, as Nx joins it (`ui:build:esm` is ui's `build:esm`; `ui:build:ci` names target `build:ci`, never `build`'s `ci` configuration, and is no edge where ui lacks it), this project's own target winning over a project name, `{ target, projects }` → each matched project's task, `projects` read as Nx's `findMatchingProjects` reads it: a name or a list of names, globs over names and over project directories (`libs/*`), `name:` / `tag:` / `directory:` labels, a bare word as a word in a name, and `!` exclusions; an edge to a target its project lacks is dropped without a word, as Nx drops it — `targetDefaults` that give every `typecheck` a `codegen` one project has; `^name` is every dependency's `name` whatever it holds, `^rsbuild:typecheck` included; a target glob — `test:e2e--*`, `^build-*`, `ui:build-{esm,cjs}`, a `{ target }` object's — expands over every target name in the workspace, as Nx 19.5+ does, before those rules; a same-project glob keeps its own project's matches), `{ env }` inputs pass through (one that is no shell variable name is keyed only), `{ runtime }` inputs run at the workspace root as Nx runs them (`cache.inputs.workspaceRuntime`), a `{ fileset, includeIgnored: true }` literal (Nx 23 hashes it from disk, gitignored or missing) is read by such a probe, since vx's globs see only what git lists, and a glob of one is a todo, a target that says `continuous` — or, in a graph from an Nx older than that field, runs a server executor (`@nx/vite:dev-server`, `@nx/next:server`, …) — is a persistent task and never cached, ready on spawn as Nx has it (Nx starts the dependents once it has started; a run-commands `readyWhen` gates them, below). The target's name never decides: a cached `dev` caches like any other target (nx#32610). `parallelism: false` (Nx runs the target alone) has no vx form and is a todo naming `--concurrency 1`; `syncGenerators` (Nx runs them first) is one workspace note per generator list, counting its tasks and naming `nx sync`; nx.json's `sync.globalGenerators` is one note per run naming `nx sync`. A target with `configurations` is one task per configuration (one whose name another target holds, `vite`'s `build` beside an inferred `vite:build`, is not written, with a todo, as Nx resolves `a:vite:build` to the target): `build` carries the default configuration's options, `build:ci` the `ci` one, and an edge of `build:ci` (own, named or `^`) reaches each target's `ci` task where it declares one, else its default, as Nx's `resolveConfiguration` does; a `^build` there becomes one edge per dependency Nx links. A `^name` input (`^production`, `{ input, dependencies: true }`, the pre-17 `{ input, projects: "dependencies" }`; `projects: "self"` is the own input, as Nx 23 still reads both) is what Nx hashes: each dependency's `name`, over the project graph, whether or not a task edge exists. A `{ input, projects }` list is read as `dependsOn`'s `projects` is. Each project some reader reaches gets an `nx-input:<name>` task — `true`, cached, keyed on its own `name` input, depending on its Nx dependencies' twins (a project nothing reaches gets none) — and a task that reads `^name` depends on its direct dependencies' twins, so the whole closure folds into its key with each project hashed once. A dependency FILESET (`^{projectRoot}/tsconfig.lib.json`, `{ fileset, dependencies: true }`, which Nx's own inferred `typecheck` writes) folds the same way: its twin, `nx-input:fileset-<hash>` (a glob's `*` is no task name; the task's description names the fileset), keys on that fileset in each project. A twin lists its project's `package.json` and `project.json` first (whichever exists; Nx keys every task on its project's manifest and configuration): a fileset that matches nothing (an absent `tsconfig.spec.json`, a dependency's unbuilt `*.d.ts`) is nothing to Nx and no "matched no files" warning, and the file appearing re-keys its readers. The twins show in a run's output; each costs about 0.16 ms of a warm run. A path input inside an output one of the project's own targets declares (TanStack/table's `public` input lists `{projectRoot}/dist`) is generated, and gitignored where Nx caches it: Nx's file map skips gitignored files, so Nx hashes nothing there (a changed `dist` file is a cache hit under Nx 23.3), and it is dropped without a todo, and the task that writes it keys its dependants through `dependsOn`.
 
 | Option  | Meaning                                                                                                                                                      |
 | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
@@ -176,7 +176,7 @@ An Nx project's `tags` are its vx `tags`, so `vx run build --filter tag:scope:we
 
 ### The graph snapshot
 
-Once per run the plugin keys its snapshot (`<cache dir>/nx-project-graph.json`) on what Nx computes the graph from: `nx.json` and the files its `extends` chain names by content, and the worktree as git sees it — `HEAD`, `git status -uall` (core's own for the run, `DiscoverContext.worktreeChanges`: the tree is walked once, which took ~96 ms per run on refine; a `root` elsewhere asks git itself), and the content of every listed path under a project root (the last graph's too, so a project `discover` names counts before it is one), any `project.json`, or at the root (manifests, lockfiles, `tsconfig*.json`). A different key, or no snapshot, runs `node_modules/.bin/nx graph --file=<snapshot>` — the one time Nx itself runs, served from the daemon when one is up. So a source edit that adds a cross-package `import` (an edge Nx derives) or a config an Nx plugin infers targets from (`vite.config.ts`) re-exports before the run, tracked or untracked, and a touch without an edit, or a stray file a task writes at the root, does not. Outside a git worktree the plugin falls back to the manifests' mtimes. The snapshot and its key live in the cache dir, which ignores itself (a `*` `.gitignore` inside it), so writing them moves nothing. Nx's own caches (`.nx/cache/`, `.nx/workspace-data/`, which the export writes) never enter the key: under a root project (a standalone repo) that does not ignore them, each export re-exported on the next run. An export that fails with a snapshot in hand warns and runs on the previous graph. The snapshot is machine-local, like the cache: nothing about it enters a key. Measured at 1,000 projects: the export runs once (1.5 s with the daemon off after an edit, 0.9 s with it on; Nx's own computation), and a warm run with nothing changed pays the key, 43 ms at min where the manifest stats it replaced took 9 (item 1075), plus the mapping. Under `vx watch` the same rule runs per cycle: a `project.json` edit is the next cycle's tasks, the export included — 1.3 s from the edit to the new command's effect on that workspace. The mapping itself is kept beside it (`<cache dir>/vx-migrate-nx-mapping.json`), keyed on everything it reads — the graph, `nx.json` and its `extends` chain, every package manifest, each project dir's `.env` names, `NX_LOAD_DOT_ENV_FILES`, which bins are installed and the mapper's own code — so a warm run with nothing changed maps nothing.
+Once per run the plugin keys its snapshot (`<cache dir>/nx-project-graph.json`) on what Nx computes the graph from: `nx.json` and the files its `extends` chain names by content, and the worktree as git sees it — `HEAD`, `git status -uall` (core's own for the run, `DiscoverContext.worktreeChanges`: the tree is walked once, which took ~96 ms per run on refine; a `root` elsewhere asks git itself), and the content of every listed path under a project root (the last graph's too, so a project `discover` names counts before it is one), any `project.json`, or at the root (manifests, lockfiles, `tsconfig*.json`). A different key, or no snapshot, runs `node_modules/.bin/nx graph --file=<snapshot>` (or, where the root links no `nx`, a Lerna repo on pnpm, the `nx` Lerna depends on, which `lerna run` runs) — the one time Nx itself runs, served from the daemon when one is up. So a source edit that adds a cross-package `import` (an edge Nx derives) or a config an Nx plugin infers targets from (`vite.config.ts`) re-exports before the run, tracked or untracked, and a touch without an edit, or a stray file a task writes at the root, does not. Outside a git worktree the plugin falls back to the manifests' mtimes. The snapshot and its key live in the cache dir, which ignores itself (a `*` `.gitignore` inside it), so writing them moves nothing. Nx's own caches (`.nx/cache/`, `.nx/workspace-data/`, which the export writes) never enter the key: under a root project (a standalone repo) that does not ignore them, each export re-exported on the next run. An export that fails with a snapshot in hand warns and runs on the previous graph. The snapshot is machine-local, like the cache: nothing about it enters a key. Measured at 1,000 projects: the export runs once (1.5 s with the daemon off after an edit, 0.9 s with it on; Nx's own computation), and a warm run with nothing changed pays the key, 43 ms at min where the manifest stats it replaced took 9 (item 1075), plus the mapping. Under `vx watch` the same rule runs per cycle: a `project.json` edit is the next cycle's tasks, the export included — 1.3 s from the edit to the new command's effect on that workspace. The mapping itself is kept beside it (`<cache dir>/vx-migrate-nx-mapping.json`), keyed on everything it reads — the graph, `nx.json` and its `extends` chain, every package manifest, each project dir's `.env` names, `NX_LOAD_DOT_ENV_FILES`, which bins are installed and the mapper's own code — so a warm run with nothing changed maps nothing.
 
 ### What it does not do
 

package/package.json

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

package/src/adoption-plugin.ts

@@ -5,7 +5,7 @@
 // against all of them at once). `turbo()` and `nx()` each carried this
 // skeleton until item 592; what differs is only how the mapping is made.
 
-import { definePlugin, type ProjectHookContext, type TaskConfig, type VxPlugin } from '@vzn/vx'
+import { definePlugin, type ProjectHookContext, type VxPlugin } from '@vzn/vx'
 import { type AdoptionMapping, cachedMapping } from './mapping-cache.js'
 import { warnGaps } from './plugin-gaps.js'
 import { headStamp, spareTrackedOutputs, trackedFiles } from './tracked-outputs.js'
@@ -111,8 +111,7 @@ 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).
-        if (!Object.hasOwn(config.tasks, t.name))
-          config.tasks[t.name] = t.task as unknown as TaskConfig
+        if (!Object.hasOwn(config.tasks, t.name)) config.tasks[t.name] = t.task
       }
     },
     // The root files the mapping reads (`turbo.json`, `nx.json`) shape every

package/src/migrate-nx.ts

@@ -7,6 +7,7 @@ import { type MigrationFormat, type MigrationPlan, type ProjectMeta } from '@vzn
 import { mapNxWorkspace, nxSizeText, parseNxGraph, readNxJson } from './nx/nx-map.js'
 import { spareTrackedOutputs, trackedFiles, trackedKinds } from './tracked-outputs.js'
 import { adoptedToolNotes } from './workspace-notes.js'
+import { relPosix } from './paths.js'
 
 /** What a task's `npm_package_*` read: the manifest, so a bump reaches them. */
 const MANIFEST_IMPORT = "import pkg from './package.json' with { type: 'json' }"
@@ -90,7 +91,7 @@ async function unlistedProjects(
     (p) => path.resolve(p.dir) !== path.resolve(root) && !listed.has(path.resolve(p.dir)),
   )
   if (unlisted.length === 0) return { manifests: [], notes: [] }
-  const rels = unlisted.map((p) => path.relative(root, p.dir).split(path.sep).join('/')).sort()
+  const rels = unlisted.map((p) => relPosix(root, p.dir)).sort()
   const manifests: { relPath: string; contents: string }[] = []
   for (const p of unlisted) {
     const file = path.join(p.dir, 'package.json')
@@ -102,7 +103,7 @@ async function unlistedProjects(
     )
       continue
     manifests.push({
-      relPath: path.relative(root, file).split(path.sep).join('/'),
+      relPath: relPosix(root, file),
       contents: `${JSON.stringify({ name: p.name, private: true }, null, 2)}\n`,
     })
   }

package/src/migrate-turbo.ts

@@ -217,7 +217,7 @@ function hoistTaskEnv(projects: readonly TurboMappedProject[]): {
       const env = own((t.task as Task).cache?.inputs?.env)
       const name = env === null ? undefined : nameOf.get(keyOf(t.name, env))
       if (name === undefined) continue
-      for (const list of lists(t.task as Task)) {
+      for (const list of lists(t.task)) {
         const names = own(list)
         if (names === null || list === undefined) continue
         if (!env!.every((n, i) => names[i] === n)) continue
@@ -250,20 +250,16 @@ function identifier(task: string): string {
  * keys them through a shell line that prints each file. Inline in every
  * package's config, that line read as noise nobody could review.
  */
-type Probe = { name: string; command: string; doc: string; field: string }
+type Probe = { name: string; command: string }
 
 const PROBES: readonly Probe[] = [
   {
     name: 'dotenvFiles',
     command: DOTENV_PROBE_TOP,
-    doc: "Each `.env` file in the task's directory, name and bytes",
-    field: 'runtime',
   },
   {
     name: 'dotenvFilesDeep',
     command: DOTENV_PROBE,
-    doc: "Each `.env` file under the task's directory, name and bytes",
-    field: 'runtime',
   },
 ]
 
@@ -282,8 +278,6 @@ function nameProbes(projects: readonly TurboMappedProject[]): {
     const probe: Probe = {
       name: `dotenvRootFiles${rootGlobs.length === 0 ? '' : rootGlobs.length + 1}`,
       command: v,
-      doc: "The `.env` files the workspace's root globs name, name and bytes",
-      field: 'workspaceRuntime',
     }
     rootGlobs.push(probe)
     return probe
@@ -320,49 +314,12 @@ function renderPreset(
   // glob, or an env name a user hand-wrote) may contain a `'`/`\`/newline that
   // would otherwise splice into a malformed, unloadable `vx-preset.ts`.
   const arr = (xs: string[]): string => `[${xs.map(quote).join(', ')}]`
-  const lines = [
-    "// TypeScript composition replaces turbo's global fields: each vx.config.ts imports these",
-    '// arrays and spreads them into the matching task fields.',
-  ]
-  if (inputs.length > 0) {
-    lines.push(
-      '',
-      '// From globalDependencies and what Turbo adds to them (the packages the',
-      '// root depends on, microfrontends configs) — workspace-root-relative,',
-      '// spread into each task’s cache.inputs.workspaceFiles.',
-      `export const globalInputs = ${arr(inputs)}`,
-    )
-  }
-  if (env.length > 0) {
-    lines.push(
-      '',
-      '// From globalEnv: cache inputs AND passed through to every task',
-      '// (vx child environments are isolated; see docs/schema.md).',
-      `export const globalEnvInputs = ${arr(env)}`,
-    )
-  }
-  if (pass.length > 0) {
-    lines.push(
-      '',
-      '// From globalPassThroughEnv: forwarded to every task, never hashed.',
-      `export const globalPassThroughEnv = ${arr(pass)}`,
-    )
-  }
-  for (const l of shared)
-    lines.push(
-      '',
-      `// turbo.json's \`${l.task}\` env: hashed and passed where a config spreads it.`,
-      `export const ${l.name} = ${arr([...l.values])}`,
-    )
-  for (const probe of probes) {
-    lines.push(
-      '',
-      `// ${probe.doc}. Turbo hashes`,
-      "// `.env` files although git ignores them, and a glob over git's files",
-      `// sees none: cache.inputs.${probe.field} keys them.`,
-      `export const ${probe.name} = ${quote(probe.command)}`,
-    )
-  }
+  const lines: string[] = []
+  if (inputs.length > 0) lines.push(`export const globalInputs = ${arr(inputs)}`)
+  if (env.length > 0) lines.push(`export const globalEnvInputs = ${arr(env)}`)
+  if (pass.length > 0) lines.push(`export const globalPassThroughEnv = ${arr(pass)}`)
+  for (const l of shared) lines.push(`export const ${l.name} = ${arr([...l.values])}`)
+  for (const probe of probes) lines.push(`export const ${probe.name} = ${quote(probe.command)}`)
   lines.push('')
   return lines.join('\n')
 }

package/src/nx/export-graph.ts

@@ -1,6 +1,7 @@
 // The resolved Nx graph, exported by the workspace's own nx: `nx()` keys and
 // keeps it, `vx-migrate --from nx` maps it once.
 
+import { readFileSync, realpathSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
 
@@ -10,9 +11,10 @@ import path from 'node:path'
  * daemon up the export is served from memory, without it Nx computes.
  */
 export async function exportGraph(root: string, snapshot: string): Promise<string | null> {
-  const bin = path.join(root, 'node_modules', '.bin', 'nx')
-  if (!(await Bun.file(bin).exists())) {
-    return `no ${path.relative(root, bin)} — install nx, or export a graph with \`nx graph --file=<path>\` and pass it as graph: '<path>'`
+  const linked = path.join(root, 'node_modules', '.bin', 'nx')
+  const bin = (await Bun.file(linked).exists()) ? linked : lernasNx(root)
+  if (bin === undefined) {
+    return `no ${path.relative(root, linked)} — install nx, or export a graph with \`nx graph --file=<path>\` and pass it as graph: '<path>'`
   }
   // `discover` runs before the run opens (and makes) the cache dir.
   await mkdir(path.dirname(snapshot), { recursive: true })
@@ -27,3 +29,19 @@ export async function exportGraph(root: string, snapshot: string): Promise<strin
   const tail = err.trim().split('\n').slice(-3).join(' ')
   return `nx graph --file exited ${code}${tail ? `: ${tail}` : ''}`
 }
+
+/**
+ * The nx Lerna 6+ runs on, from Lerna's own dependencies: pnpm links only
+ * a root's direct dependencies into `node_modules/.bin`, so a Lerna repo
+ * on pnpm has no `nx` there, and `lerna run` uses this one.
+ */
+function lernasNx(root: string): string | undefined {
+  try {
+    const lerna = realpathSync(path.join(root, 'node_modules', 'lerna'))
+    const manifest = Bun.resolveSync('nx/package.json', lerna)
+    const bin = (JSON.parse(readFileSync(manifest, 'utf8')) as { bin?: { nx?: unknown } }).bin?.nx
+    return typeof bin === 'string' ? path.join(path.dirname(manifest), bin) : undefined
+  } catch {
+    return undefined
+  }
+}

package/src/nx/index.ts

@@ -524,7 +524,7 @@ async function graphInputKey(
   if (changed === null) return null
   // The cache dir holds the snapshot itself: a workspace that does not
   // ignore it would see the export move the key it was keyed on.
-  const cacheRel = path.relative(root, cacheDir).split(path.sep).join('/')
+  const cacheRel = relPosix(root, cacheDir)
   const inCache = (p: string): boolean =>
     cacheRel !== '' &&
     !cacheRel.startsWith('..') &&
@@ -540,7 +540,7 @@ async function graphInputKey(
   // stray write at the root (a report, a log) is not, and counting it
   // re-exported the graph on every run after it.
   // A `project.json` anywhere: a new one is a project no root lists yet.
-  const roots = dirs.map((d) => path.relative(root, d).split(path.sep).join('/'))
+  const roots = dirs.map((d) => relPosix(root, d))
   const graphFile = (p: string): boolean =>
     p === 'project.json' ||
     p.endsWith('/project.json') ||

package/src/nx/nx-inputs.ts

@@ -77,7 +77,14 @@ export function expandNxInputs(
           todos.push(`input ${JSON.stringify(entry)}: glob syntax vx cannot take — map manually`)
           return
         }
-        const own = underProject(g, at.rel)
+        // Nx globs a `{workspaceRoot}` path over every file of the
+        // workspace, a vx project glob only over its project's own: on the
+        // root project TanStack Query's `{workspaceRoot}/**/package.json`
+        // (sherif's input) left every package's manifest out of the key.
+        const own =
+          (at.rel === '' || at.rel === '.') && s.startsWith('{workspaceRoot}')
+            ? null
+            : underProject(g, at.rel)
         if (own === null) into.wsFiles.push(neg + withProjectDir(g, at.rel, true))
         else into.files.push(neg + withProjectDir(own, at.rel, true))
         return

package/src/nx/nx-map.ts

@@ -36,7 +36,7 @@ import {
   wildcardTodo,
 } from '../shared-outputs.js'
 import type { TrackedKinds } from '../tracked-outputs.js'
-import { packageScripts, relPosix } from '../paths.js'
+import { isRecord, packageScripts, relPosix } from '../paths.js'
 import { withLernaOrder } from './lerna.js'
 import { mapNxDeps, matchNxProjects, type TaskNameFor } from './nx-deps.js'
 import {
@@ -143,9 +143,6 @@ const LEGACY: Readonly<Record<string, string>> = {
   '@nx/workspace:run-script': 'nx:run-script',
 }
 
-const isRecord = (v: unknown): v is Record<string, unknown> =>
-  typeof v === 'object' && v !== null && !Array.isArray(v)
-
 /** Every dependency name the root package.json declares; none without one. */
 async function rootDependencies(root: string): Promise<ReadonlySet<string>> {
   const pkg = (await Bun.file(path.join(root, 'package.json'))

package/src/nx/nx-upstream.ts

@@ -339,7 +339,14 @@ export function planNxUpstream(
         if (u.of !== 'deps') foldProjects(u.name, u.of, inputs, todos, edges)
         else if (u.name !== name) fold(node, u.name, peers, inputs, todos, edges)
       }
-      const cacheInputs: Record<string, unknown> = { files: inputs.files }
+      // Nx hashes a fileset that matches nothing as nothing; core warns of
+      // an input set that resolves to no file. A project has a package.json
+      // or a project.json, and Nx keys each task on both (its manifest, its
+      // configuration), so listing them keeps the twin of an absent
+      // `tsconfig.spec.json` (or a dependency's unbuilt `*.d.ts`) quiet; the
+      // file appearing still re-keys it, and a missing literal is silent.
+      const files = [...new Set(['package.json', 'project.json', ...inputs.files])]
+      const cacheInputs: Record<string, unknown> = { files }
       if (inputs.wsFiles.length > 0) cacheInputs.workspaceFiles = inputs.wsFiles
       if (inputs.envNames.length > 0) cacheInputs.env = inputs.envNames
       if (inputs.runtimeCmds.length > 0) cacheInputs.workspaceRuntime = inputs.runtimeCmds

package/src/nx-cache/index.ts

@@ -20,7 +20,7 @@ import {
   refuseUnknownOptions,
   type PluginOptionKinds,
 } from '@vzn/vx'
-import { deadlineNamed } from '../remote-deadline.js'
+import { deadline } from '../remote-deadline.js'
 import { OutageBreaker } from '../remote-breaker.js'
 import { withRetry } from '../remote-retry.js'
 import { headerValueFault } from '../remote-token.js'
@@ -142,23 +142,19 @@ export class NxRemoteCache implements RemoteCacheLayer {
       // every hit read as a corrupt artifact (nx#33092).
       headers['Accept'] = 'application/octet-stream'
     }
-    const res = await this.breaker
-      .send(() =>
-        withRetry(
-          () =>
-            this.fetchImpl(`${this.config.server}/v1/cache/${hash}`, {
-              method,
-              headers,
-              ...(body === undefined ? {} : { body }),
-              signal: AbortSignal.timeout(this.config.timeoutMs),
-            }),
-          this.config.retries,
-          this.wait,
-        ),
-      )
-      .catch((err: unknown) => {
-        throw deadlineNamed(err, this.config.timeoutMs)
-      })
+    const res = await this.breaker.send(() =>
+      withRetry(
+        () =>
+          this.fetchImpl(`${this.config.server}/v1/cache/${hash}`, {
+            method,
+            headers,
+            ...(body === undefined ? {} : { body }),
+            signal: deadline(this.config.timeoutMs),
+          }),
+        this.config.retries,
+        this.wait,
+      ),
+    )
     if (method === 'PUT' && res.status === 403) {
       const first = !this.writesRefused
       this.writesRefused = true

package/src/paths.ts

@@ -33,6 +33,9 @@ export function relPosix(from: string, to: string): string {
 export function packageScripts(meta: ProjectMeta): Record<string, unknown> {
   const raw = (meta.packageJson as unknown as { scripts?: unknown }).scripts
   const scripts: Record<string, unknown> = Object.create(null)
-  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) return scripts
+  if (!isRecord(raw)) return scripts
   return Object.assign(scripts, raw)
 }
+
+export const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null && !Array.isArray(v)

package/src/remote-deadline.ts

@@ -2,10 +2,18 @@
  * A request's deadline, named. The runtime's abort says "The operation
  * timed out." and nothing else; core's degrade line already names the
  * request, the artifact and the server, so the cause names the deadline
- * that was spent. Shared by `turboCache()` and `nxCache()`.
+ * that was spent. The name rides the signal's reason, not a catch around
+ * `fetch`: the deadline covers the body too, and a body read past it
+ * (core's ingest, the signed download's temp) rejects with the reason
+ * (measured on Bun 1.4.2), where a catch around `fetch` never saw it.
+ * Unref'd, as `AbortSignal.timeout`'s timer is. Shared by `turboCache()`
+ * and `nxCache()`.
  */
-export function deadlineNamed(err: unknown, timeoutMs: number): unknown {
-  return (err as { name?: unknown } | null)?.name === 'TimeoutError'
-    ? new Error(`no answer within ${timeoutMs} ms`)
-    : err
+export function deadline(timeoutMs: number): AbortSignal {
+  const controller = new AbortController()
+  setTimeout(
+    () => controller.abort(new Error(`no answer within ${timeoutMs} ms`)),
+    timeoutMs,
+  ).unref()
+  return controller.signal
 }

package/src/tracked-outputs.ts

@@ -10,6 +10,7 @@
 import { lstat, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { isLiteralPattern, outputsOverlap } from '@vzn/vx'
+import { relPosix } from './paths.js'
 
 /** The files git tracks under `root`, root-relative; null outside a repo or without git. */
 export async function trackedFiles(root: string): Promise<string[] | null> {
@@ -220,7 +221,7 @@ export function spareTrackedOutputs(
   /** Drop the `!` entries readers carry for a committed file no output names any more. */
   const unhide = (owner: (typeof projects)[number] | null, rooted: string) => {
     for (const q of projects) {
-      const qrel = path.relative(root, q.dir).split(path.sep).join('/')
+      const qrel = relPosix(root, q.dir)
       for (const r of q.tasks) {
         const inputs = (r.task?.['cache'] as { inputs?: Outputs } | undefined)?.inputs
         if (inputs === undefined) continue
@@ -238,7 +239,7 @@ export function spareTrackedOutputs(
     }
   }
   for (const p of projects) {
-    const rel = path.relative(root, p.dir).split(path.sep).join('/')
+    const rel = relPosix(root, p.dir)
     const own = rel === '' ? tracked : filesUnder(tracked, rel).map((f) => f.slice(rel.length + 1))
     for (const t of p.tasks) {
       const outputs = (t.task?.['cache'] as { outputs?: Outputs } | undefined)?.outputs

package/src/turbo/turbo-map.ts

@@ -28,7 +28,7 @@ import {
   wildcardOutput,
   wildcardTodo,
 } from '../shared-outputs.js'
-import { packageScripts, relPosix } from '../paths.js'
+import { isRecord, packageScripts, relPosix } from '../paths.js'
 import { MAX_SPARED, type TrackedKinds } from '../tracked-outputs.js'
 import {
   DOTENV_PROBE,
@@ -439,9 +439,6 @@ async function readTurboJson(file: string, root: string): Promise<TurboJson> {
   return parsed as TurboJson
 }
 
-const isRecord = (v: unknown): v is Record<string, unknown> =>
-  typeof v === 'object' && v !== null && !Array.isArray(v)
-
 const TOP_LISTS = [
   'globalDependencies',
   'globalEnv',
@@ -1166,14 +1163,19 @@ export async function mapTurboWorkspace(
   // One with edges of its own (with-shell-commands' `tooling-config#build`
   // → `prebuild`) was a group, which keys nothing: Turbo's node still
   // hashes the package's files, so it is key-only with its edges. A node
-  // that starts persistent sidecars stays a group.
+  // that starts persistent sidecars stays a group. One a `^name` reaches
+  // whose own edges lack `^name` (opencode's `build: { dependsOn: [] }`)
+  // is key-only too: Turbo's `^build` stops at it, and core's walked past
+  // it to the builds below, running and keying ones Turbo never waits on.
   const keyOnly = new Map<string, Set<string>>()
   for (const meta of metas) {
     const scripts = packageScripts(meta)
     const { defined, defFor } = definitions(meta)
+    const depended = metas.some((m) => m !== meta && declares(m, meta.name))
     for (const name of defined) {
       const def = defFor(name)
-      if (!caretSelf.has(name) || !withScript.has(name) || transit.has(name)) continue
+      const stops = depended && caretNames.has(name) && !(def?.dependsOn ?? []).includes(`^${name}`)
+      if (!(caretSelf.has(name) || stops) || !withScript.has(name) || transit.has(name)) continue
       if (scripts[name] !== undefined || commandOverride(def) !== undefined) continue
       if (sidecarGroups.has(`${meta.name}#${name}`)) continue
       if (def?.cache === false || def?.persistent === true) continue
@@ -1293,7 +1295,13 @@ export async function mapTurboWorkspace(
       // Core gives a project with no `build` this very node (a group behind
       // `^build`, keyed on the project's files), so writing it is noise:
       // solid's three script-less packages each got a `build` running `true`.
-      if (noop && name === 'build' && (defFor(name)!.dependsOn ?? []).every((d) => d === '^build'))
+      const noopEdges = defFor(name)!.dependsOn ?? []
+      if (
+        noop &&
+        name === 'build' &&
+        noopEdges.includes('^build') &&
+        noopEdges.every((d) => d === '^build')
+      )
         continue
       if (
         override === undefined &&

package/src/turbo-cache/index.ts

@@ -24,7 +24,7 @@ import {
   refuseUnknownOptions,
   type PluginOptionKinds,
 } from '@vzn/vx'
-import { deadlineNamed } from '../remote-deadline.js'
+import { deadline } from '../remote-deadline.js'
 import { OutageBreaker } from '../remote-breaker.js'
 import { withRetry } from '../remote-retry.js'
 import { headerValueFault } from '../remote-token.js'
@@ -468,32 +468,28 @@ export class TurboRemoteCache implements RemoteCacheLayer {
   ): Promise<Response | undefined> {
     const timeoutMs = init.timeoutMs ?? this.config.timeoutMs
     // 0 is Turbo's "no deadline".
-    const signal = () => (timeoutMs === 0 ? undefined : AbortSignal.timeout(timeoutMs))
+    const signal = () => (timeoutMs === 0 ? undefined : deadline(timeoutMs))
     // The batch query is never preflighted, as in Turbo.
     const preflight = this.config.preflight && method !== 'POST'
-    const res = await this.breaker
-      .send(() =>
-        withRetry(
-          async () => {
-            const extra = init.headers ?? {}
-            const to = preflight
-              ? await this.preflight(this.url(pathname), method, extra, signal)
-              : { url: this.url(pathname), auth: true }
-            const s = signal()
-            return this.fetchImpl(to.url, {
-              method,
-              headers: this.headers(extra, to.auth),
-              ...(init.body === undefined ? {} : { body: init.body }),
-              ...(s === undefined ? {} : { signal: s }),
-            })
-          },
-          this.config.retries,
-          this.wait,
-        ),
-      )
-      .catch((err: unknown) => {
-        throw deadlineNamed(err, timeoutMs)
-      })
+    const res = await this.breaker.send(() =>
+      withRetry(
+        async () => {
+          const extra = init.headers ?? {}
+          const to = preflight
+            ? await this.preflight(this.url(pathname), method, extra, signal)
+            : { url: this.url(pathname), auth: true }
+          const s = signal()
+          return this.fetchImpl(to.url, {
+            method,
+            headers: this.headers(extra, to.auth),
+            ...(init.body === undefined ? {} : { body: init.body }),
+            ...(s === undefined ? {} : { signal: s }),
+          })
+        },
+        this.config.retries,
+        this.wait,
+      ),
+    )
     if (method === 'PUT' && res.status === 403) {
       const first = !this.writesRefused
       this.writesRefused = true

package/src/vite-task/vite-task-map.ts

@@ -67,6 +67,36 @@ function viteConfigFile(dir: string): string | null {
   return name === undefined ? null : path.join(dir, name)
 }
 
+// Bun's resolver reads `\` as a separator, even in a file: URL, so a config
+// under `a\b` was looked for under `a/b`. Resolved here, the path stays as
+// written; the file is read from it.
+const LITERAL_QUERY = /\?vx-literal$/
+let servingLiteral = false
+
+function importAsWritten(file: string): Promise<{ default?: unknown }> {
+  if (!file.includes('\\')) return import(file)
+  if (!servingLiteral) {
+    servingLiteral = true
+    Bun.plugin({
+      name: 'vx-migrate-literal',
+      setup(build) {
+        build.onResolve({ filter: LITERAL_QUERY }, (args) => ({
+          path: args.path,
+          namespace: 'file',
+        }))
+        build.onLoad({ filter: LITERAL_QUERY }, async (args) => {
+          const at = args.path.replace(LITERAL_QUERY, '')
+          return {
+            contents: await Bun.file(at).text(),
+            loader: /\.[cm]?ts$/.test(at) ? 'ts' : 'js',
+          }
+        })
+      },
+    })
+  }
+  return import(`${file}?vx-literal`)
+}
+
 /**
  * A package's `run` block, as `vp run` reads it: the config evaluated in
  * build mode (vite-plus resolves it with `command: 'build'`), a function
@@ -75,7 +105,7 @@ function viteConfigFile(dir: string): string | null {
 async function readRunConfig(file: string, root: string): Promise<RunConfig | null> {
   let config: unknown
   try {
-    config = ((await import(file)) as { default?: unknown }).default
+    config = (await importAsWritten(file)).default
     if (typeof config === 'function')
       config = await (config as (env: object) => unknown)({
         command: 'build',
@@ -89,7 +119,7 @@ async function readRunConfig(file: string, root: string): Promise<RunConfig | nu
     )
   }
   const run = (config as { run?: unknown } | null | undefined)?.run
-  return typeof run === 'object' && run !== null ? (run as RunConfig) : null
+  return typeof run === 'object' && run !== null ? run : null
 }
 
 /** `run.cache` at the root: what `vp run` caches with no flag. */
@@ -292,7 +322,7 @@ export async function mapViteTaskWorkspace(
     }
     for (const [name, raw] of Object.entries(own)) {
       const def: TaskDef =
-        typeof raw === 'string' || Array.isArray(raw) ? { command: raw } : ((raw ?? {}) as TaskDef)
+        typeof raw === 'string' || Array.isArray(raw) ? { command: raw } : (raw ?? {})
       tasks.push(
         mapTask(name, def, {
           pkgDir,
@@ -408,7 +438,7 @@ function mapTask(name: string, def: TaskDef, ctx: TaskCtx): GeneratedTask {
     def.cache === false || !ctx.cacheOn
       ? null
       : typeof def.cache === 'object' && def.cache !== null
-        ? (def.cache as CacheDef)
+        ? def.cache
         : def
 
   const env = envNames('cache.env', cache?.env, todos, ctx)