@vzn/vx-migrate 0.0.639 → 0.0.641

package/src/nx/nx-map.ts

@@ -16,6 +16,7 @@
 // configuration is a task of its own, `<target>:<configuration>`; the
 // default configuration is folded into the base task.
 
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { type Duration, type GeneratedProject, type GeneratedTask, UserError } from '@vzn/vx'
 import type { PackageMeta } from '../packages.js'
@@ -270,6 +271,8 @@ export const BUILTIN_EXECUTORS: ReadonlySet<string> = new Set([
 /** The options with what the mapper reads itself: the root's dependency names. */
 type MapOpts = MapNxOptions & {
   readonly rootDeps: ReadonlySet<string>
+  /** The root TypeScript config Nx folds into every task's hash, if any. */
+  readonly rootTsConfig: string | undefined
   readonly pnp: boolean
   /** Tasks per `syncGenerators` list, said once in the notes. */
   readonly syncTasks: Map<string, number>
@@ -317,6 +320,9 @@ export async function mapNxWorkspace(
     ...opts,
     cacheable: new Set([...opts.cacheable, ...cacheable]),
     rootDeps: await rootDependencies(root),
+    rootTsConfig: ['tsconfig.base.json', 'tsconfig.json'].find((f) =>
+      existsSync(path.join(root, f)),
+    ),
     pnp: yarnPnp(root),
     syncTasks: new Map(),
   }
@@ -881,7 +887,19 @@ function buildTask(
   if (wild !== undefined && cacheWanted && !persistent) todos.push(wildcardTodo(wild))
   // The manifest or config an output covers is taken back, so core loads it.
   if (wild === undefined) outFiles.push(...ownFileTakeBacks(outFiles, opts.ownConfig?.(projectRel)))
-  const cacheEnabled = !persistent && cacheWanted && wild === undefined
+  // Nx keys the outputs of the tasks this one depends on, and vx their
+  // keys through `dependsOn`. With no such edge left (the producer is a
+  // project vx did not migrate: nx-examples' .NET ProductsApi), the key
+  // saw nothing the task reads, and a changed document replayed the old
+  // generated client (Growth, 2026-10-16).
+  const orphanReader =
+    inputs.dependentOutputs.length > 0 && !deps.some((d) => !d.includes('#nx-input:'))
+  if (orphanReader && cacheWanted && !persistent) {
+    todos.push(
+      `reads ${inputs.dependentOutputs.map((g) => `\`${g}\``).join(', ')} from the outputs of the tasks it depends on, and no task it depends on is migrated (dependsOn ${JSON.stringify(target.dependsOn ?? [])}) — uncached here, so it never replays output generated from an older input; migrate the producer and depend on it to cache this task`,
+    )
+  }
+  const cacheEnabled = !persistent && cacheWanted && wild === undefined && !orphanReader
   if (persistent && cacheWanted) {
     todos.push('Nx caches this target, and vx never caches a persistent task — uncached here')
   }
@@ -898,17 +916,28 @@ function buildTask(
     const gens = target.syncGenerators.map((g) => JSON.stringify(g)).join(', ')
     opts.syncTasks.set(gens, (opts.syncTasks.get(gens) ?? 0) + 1)
   }
-  if (cacheEnabled && mapped !== null) {
+  // vx keys an uncached task too, and a dependant folds that key. Its own
+  // inputs are enough there: Nx never folds a dependency's hash, so what a
+  // dependant reads upstream its own `^` inputs already name, and twins
+  // for the uncached one's `^` inputs would key nothing new.
+  if (mapped !== null) {
     // No `inputs` is Nx's `default` and `^default`: the project's
     // `default` named input (its whole tree unless declared) and each
     // dependency's. No gap to report (487 lines per run on refine,
     // 2026-09-22).
     if (target.inputs === undefined)
-      expandNxInputs(['default', '^default'], upstream.namedOf(nodeName), at, inputs, todos)
+      expandNxInputs(
+        cacheEnabled ? ['default', '^default'] : ['default'],
+        upstream.namedOf(nodeName),
+        at,
+        inputs,
+        todos,
+      )
     if (inputs.files.length === 0 && target.inputs === undefined) inputs.files.push('**/*')
     // Before the env block: a dependency's `{ env }` passes through too.
-    for (const edge of upstream.resolve(nodeName, inputs, todos))
-      if (!deps.includes(edge)) deps.push(edge)
+    if (cacheEnabled)
+      for (const edge of upstream.resolve(nodeName, inputs, todos))
+        if (!deps.includes(edge)) deps.push(edge)
   }
 
   if (mapped === null) {
@@ -957,18 +986,25 @@ function buildTask(
   }
   const task: Record<string, unknown> = { exec }
   if (deps.length > 0) task.dependsOn = deps
+  const keyed: Record<string, unknown> = { files: withoutTakenBack(inputs.files) }
+  // Nx hashes the root TypeScript config into every task (its
+  // TsConfiguration input, other projects' `paths` left out): a
+  // compilerOptions edit re-ran Nx's tests and replayed vx's (Growth,
+  // 2026-10-16). The whole file here: a `paths` edit re-keys every task.
+  if (opts.rootTsConfig !== undefined && !inputs.wsFiles.includes(opts.rootTsConfig))
+    inputs.wsFiles.push(opts.rootTsConfig)
+  if (inputs.wsFiles.length > 0) keyed.workspaceFiles = withoutTakenBack(inputs.wsFiles)
+  if (inputs.envNames.length > 0) keyed.env = inputs.envNames
+  // The `.env` files the task loads are inputs, and gitignored ones
+  // (`.env.local`) are invisible to a glob: their bytes, read per run.
+  // Their paths are project-relative: `runtime`, in the project dir.
+  if (mapped.envInputs.length > 0) keyed.runtime = [envProbe(mapped.envInputs)]
+  if (inputs.runtimeCmds.length > 0) keyed.workspaceRuntime = inputs.runtimeCmds
+  task.inputs = keyed
   if (cacheEnabled) {
-    const cacheInputs: Record<string, unknown> = { files: withoutTakenBack(inputs.files) }
-    if (inputs.wsFiles.length > 0) cacheInputs.workspaceFiles = withoutTakenBack(inputs.wsFiles)
-    if (inputs.envNames.length > 0) cacheInputs.env = inputs.envNames
-    // The `.env` files the task loads are inputs, and gitignored ones
-    // (`.env.local`) are invisible to a glob: their bytes, read per run.
-    // Their paths are project-relative: `runtime`, in the project dir.
-    if (mapped.envInputs.length > 0) cacheInputs.runtime = [envProbe(mapped.envInputs)]
-    if (inputs.runtimeCmds.length > 0) cacheInputs.workspaceRuntime = inputs.runtimeCmds
     const outputs: Record<string, unknown> = { files: outFiles }
     if (wsOutFiles.length > 0) outputs.workspaceFiles = wsOutFiles
-    task.cache = { inputs: cacheInputs, outputs }
+    task.cache = { outputs }
   }
 
   return { name: variant.name, todos, task }
@@ -1211,7 +1247,7 @@ function argsTodo(options: Record<string, unknown>, todos: string[]): void {
 }
 
 /**
- * Prints each file's name and bytes, for `cache.inputs.runtime`: the name
+ * Prints each file's name and bytes, for `inputs.runtime`: the name
  * keeps a line moved from one file to the next (a different precedence) a
  * different key.
  */

package/src/nx/nx-upstream.ts

@@ -347,16 +347,16 @@ export function planNxUpstream(
       // `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
+      const keyed: Record<string, unknown> = { files }
+      if (inputs.wsFiles.length > 0) keyed.workspaceFiles = inputs.wsFiles
+      if (inputs.envNames.length > 0) keyed.env = inputs.envNames
+      if (inputs.runtimeCmds.length > 0) keyed.workspaceRuntime = inputs.runtimeCmds
       // A keyed group: dependants fold its key; nothing spawns.
       const task: Record<string, unknown> = {}
       if (isFileset(name))
         task.description = `Nx fileset ${name} of this project and what it reaches`
       if (edges.size > 0) task.dependsOn = [...edges].sort()
-      task.cache = { inputs: cacheInputs, outputs: { files: [] } }
+      task.inputs = keyed
       const list = out.get(node) ?? []
       list.push({ name: inputTask(name), task, todos })
       out.set(node, list)

package/src/nx-cache/index.ts

@@ -46,10 +46,6 @@ export function resolveNxCacheConfig(
   options: NxCacheOptions,
   env: Record<string, string | undefined> = Bun.env,
 ): NxCacheConfig | undefined {
-  // Nx's own off switches (`skipRemoteCache`): a CI that sets one for an
-  // untrusted pull request kept Nx off the shared cache and not vx.
-  if (env['NX_SKIP_REMOTE_CACHE'] === 'true' || env['NX_DISABLE_REMOTE_CACHE'] === 'true')
-    return undefined
   const server = (options.server ?? env['NX_SELF_HOSTED_REMOTE_CACHE_SERVER'])?.replace(/\/+$/, '')
   if (!server) return undefined
   // The URL is printed in every refusal line, so a `user:pass@` in it would

package/src/shared-outputs.ts

@@ -354,11 +354,21 @@ function prefixIndex(): {
  * task core refuses, and every verb failed.
  */
 export const isKeyedGroup = (t: { readonly task: Record<string, unknown> | null }): boolean =>
-  t.task !== null && t.task['exec'] === undefined && t.task['cache'] !== undefined
+  t.task !== null && t.task['exec'] === undefined && t.task['inputs'] !== undefined
 
-/** A task's cached `inputs` block, when it has one with a `files` list. */
+/**
+ * A task whose key cannot be complete: no cache and no key, so it runs
+ * every time and every dependant misses (core's keyless task). Uncached
+ * alone, its incomplete key still let a dependant hit stale.
+ */
+export function unkey(task: Record<string, unknown>): void {
+  delete task['cache']
+  delete task['inputs']
+}
+
+/** A task's `inputs` block, when it has one with a `files` list. */
 function inputsOf(t: GeneratedTask): { files: string[]; workspaceFiles?: unknown } | undefined {
-  const inputs = (t.task?.['cache'] as { inputs?: { files?: unknown } } | undefined)?.inputs
+  const inputs = t.task?.['inputs'] as { files?: unknown } | undefined
   return Array.isArray(inputs?.files)
     ? (inputs as { files: string[]; workspaceFiles?: unknown })
     : undefined
@@ -366,7 +376,7 @@ function inputsOf(t: GeneratedTask): { files: string[]; workspaceFiles?: unknown
 
 /**
  * Core refuses a task whose inputs can match another task's declared
- * outputs (`rules.upfrontKeys`, on by default, core X-54): such a key
+ * outputs (`vx lock`, always, core X-54): such a key
  * reads what a producer writes this run and cannot be known before it ran.
  * Turbo and Nx default a task's inputs to every file of its package
  * (`**\/*`), which matches a sibling build's `dist`. Each overlapping
@@ -396,7 +406,7 @@ export function excludeSiblingOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
         const literal = read.find((g) => isLiteralPattern(g))
         if (literal !== undefined && isKeyedGroup(t)) continue
         if (literal !== undefined) {
-          delete t.task!['cache']
+          unkey(t.task!)
           t.todos.push(
             `reads ${JSON.stringify(literal)}, which ${JSON.stringify(w.name)} writes — vx keys a ` +
               'task only on files no other task writes, so it runs uncached; read the source ' +
@@ -480,7 +490,7 @@ export function resolveSharedWorkspaceOutputs(
 }
 
 /**
- * `excludeSiblingOutputs` for root-anchored `cache.inputs.workspaceFiles`:
+ * `excludeSiblingOutputs` for root-anchored `inputs.workspaceFiles`:
  * every other task's `outputs.workspaceFiles`, and its `outputs.files` at
  * their workspace path, is taken back from a reader's workspace inputs
  * (Turbo's `globalDependencies` and `$TURBO_ROOT$` entries, Nx's
@@ -530,8 +540,7 @@ export function excludeWorkspaceOutputs(
   if (writers.length === 0) return
   for (const p of projects) {
     for (const t of p.tasks) {
-      const inputs = (t.task?.['cache'] as { inputs?: { workspaceFiles?: unknown } } | undefined)
-        ?.inputs
+      const inputs = t.task?.['inputs'] as { workspaceFiles?: unknown } | undefined
       if (inputs === undefined || !Array.isArray(inputs.workspaceFiles)) continue
       const files = inputs.workspaceFiles as string[]
       const reads = positive(files.flatMap((f) => (typeof f === 'string' ? [f] : expand(f))))
@@ -546,7 +555,7 @@ export function excludeWorkspaceOutputs(
           const literal = read.find((g) => isLiteralPattern(g))
           if (literal !== undefined && isKeyedGroup(t)) continue
           if (literal !== undefined) {
-            delete t.task!['cache']
+            unkey(t.task!)
             t.todos.push(
               `reads ${JSON.stringify(literal)}, which ${w.id} writes — vx keys a task only on ` +
                 'files no other task writes, so it runs uncached; read the source instead in a ' +
@@ -556,7 +565,7 @@ export function excludeWorkspaceOutputs(
           }
           files.push(`!${out}`)
         }
-        if (t.task?.['cache'] === undefined) break
+        if (t.task?.['inputs'] === undefined) break
       }
     }
   }
@@ -581,7 +590,7 @@ export function excludeWorkspaceOutputs(
           const literal = out.startsWith(at) ? read.find((g) => isLiteralPattern(g)) : read[0]
           if (literal !== undefined && isKeyedGroup(t)) continue
           if (literal !== undefined) {
-            delete t.task!['cache']
+            unkey(t.task!)
             t.todos.push(
               `reads ${JSON.stringify(literal.slice(at.length))}, which ${w.id} writes — vx keys ` +
                 'a task only on files no other task writes, so it runs uncached; read the ' +
@@ -591,7 +600,7 @@ export function excludeWorkspaceOutputs(
           }
           files.push(back)
         }
-        if (t.task?.['cache'] === undefined) break
+        if (t.task?.['inputs'] === undefined) break
       }
     }
   }

package/src/tracked-outputs.ts

@@ -11,7 +11,7 @@ import { lstat, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { isLiteralPattern, outputsOverlap } from '@vzn/vx'
 import { relPosix } from './paths.js'
-import { isKeyedGroup } from './shared-outputs.js'
+import { isKeyedGroup, unkey } from './shared-outputs.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> {
@@ -243,7 +243,7 @@ export function spareTrackedOutputs(
     for (const q of projects) {
       const qrel = relPosix(root, q.dir)
       for (const r of q.tasks) {
-        const inputs = (r.task?.['cache'] as { inputs?: Outputs } | undefined)?.inputs
+        const inputs = r.task?.['inputs'] as Outputs | undefined
         if (inputs === undefined) continue
         const own =
           q === owner &&
@@ -309,7 +309,7 @@ export function spareTrackedOutputs(
       for (const q of projects) {
         for (const r of q.tasks) {
           if (r === t) continue
-          const inputs = (r.task?.['cache'] as { inputs?: Outputs } | undefined)?.inputs
+          const inputs = r.task?.['inputs'] as Outputs | undefined
           if (inputs === undefined) continue
           const f =
             (q === p ? hidden(inputs.files, local) : undefined) ??
@@ -324,7 +324,7 @@ export function spareTrackedOutputs(
               inputs.workspaceFiles = unhidden(inputs.workspaceFiles, wsBacks, rooted)
             continue
           }
-          delete r.task!['cache']
+          unkey(r.task!)
           todos.push([
             `${q.name}#${r.name}`,
             `reads the committed ${f}, which its inputs take back with ${p.name}#${t.name}'s ` +