@vzn/vx-migrate 0.0.638 → 0.0.640

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/shared-outputs.ts

@@ -171,6 +171,8 @@ interface Cached {
   name: string
   files: string[]
   hasUpstreamEdge: boolean
+  /** Globs of a sibling's this task's `!` entries take back (`separable`). */
+  back: Set<string>
 }
 
 function cachedOutputs(t: GeneratedTask, index: number): Cached | null {
@@ -186,9 +188,32 @@ function cachedOutputs(t: GeneratedTask, index: number): Cached | null {
   const deps = task['dependsOn']
   const hasUpstreamEdge =
     Array.isArray(deps) && deps.some((d) => typeof d === 'string' && d.startsWith('^'))
-  return { index, name: t.name, files: strings, hasUpstreamEdge }
+  return { index, name: t.name, files: strings, hasUpstreamEdge, back: new Set() }
 }
 
+/**
+ * Can the keeper's `ga` give `gb`'s tree back? Only when `ga` is a
+ * directory at any depth (`**\/dist`, `**\/dist/**`) and `gb`'s literal
+ * head names no such directory: the two meet only at a `dist` nested in
+ * `gb`'s tree, which is the sibling's. solid's build outputs `**\/dist`
+ * beside types' `types/**`; Turbo caches both, and uncaching types made
+ * vx the slower of the two.
+ */
+function separable(ga: string, gb: string): boolean {
+  const name = /^\*\*\/([^*?[\]{}()!/\\]+)(?:\/\*\*)?$/.exec(ga)?.[1]
+  if (name === undefined) return false
+  const head: string[] = []
+  for (const seg of gb.replace(/^(\.\/)+/, '').split('/')) {
+    if (!isLiteralPattern(seg) || seg === '') break
+    head.push(seg)
+  }
+  return head.length > 0 && !head.includes(name)
+}
+
+/** Does keeper `k`'s `ga` still reach `gb` once its `!` entries are read? */
+const hits = (k: Cached, ga: string, gb: string): boolean =>
+  !k.back.has(gb) && outputsOverlap(ga, gb)
+
 /**
  * Uncache every task whose declared outputs overlap a keeper's, in place,
  * and return the tasks. Deterministic: keepers are chosen in declaration
@@ -220,14 +245,28 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
     const kept: Cached[] = [keeper]
     for (const c of all) {
       if (c === keeper) continue
-      const clash = kept.find((k) =>
-        c.files.some((gb) => k.files.some((ga) => outputsOverlap(ga, gb))),
-      )
+      const clash = kept.find((k) => c.files.some((gb) => k.files.some((ga) => hits(k, ga, gb))))
       if (clash === undefined) {
         kept.push(c)
         continue
       }
       const t = tasks[c.index]!
+      const pairs = kept.flatMap((k) =>
+        c.files.flatMap((gb) =>
+          k.files.filter((ga) => hits(k, ga, gb)).map((ga) => ({ k, ga, gb })),
+        ),
+      )
+      if (pairs.every((p) => separable(p.ga, p.gb))) {
+        for (const { k, gb } of pairs) {
+          if (k.back.has(gb)) continue
+          k.back.add(gb)
+          ;(tasks[k.index]!.task!['cache'] as { outputs: { files: string[] } }).outputs.files.push(
+            `!${gb}`,
+          )
+        }
+        kept.push(c)
+        continue
+      }
       // tsc's incremental state is no product: create-t3-turbo's build and
       // typecheck both output `.cache/tsbuildinfo.json`, and typecheck ran
       // uncached on every first run (Growth funnel F8). Left to the keeper,
@@ -236,7 +275,7 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
       // the keeper's tsbuildinfo calls built, missing or not, so its save
       // could be a partial dist.
       const sharedFiles = c.files.filter((gb) =>
-        kept.some((k) => k.files.some((ga) => outputsOverlap(ga, gb))),
+        kept.some((k) => k.files.some((ga) => hits(k, ga, gb))),
       )
       if (
         sharedFiles.length === c.files.length &&
@@ -249,7 +288,7 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
         continue
       }
       dropped.add(c.index)
-      const shared = c.files.find((gb) => clash.files.some((ga) => outputsOverlap(ga, gb)))!
+      const shared = c.files.find((gb) => clash.files.some((ga) => hits(clash, ga, gb)))!
       delete t.task!['cache']
       t.todos.push(
         `declares the output ${JSON.stringify(shared)} that ${JSON.stringify(clash.name)} also ` +
@@ -315,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 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 cached `inputs` block, when it has one with a `files` list. */
+/** 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
@@ -327,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
@@ -357,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 ' +
@@ -441,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
@@ -491,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))))
@@ -507,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 ' +
@@ -517,7 +565,7 @@ export function excludeWorkspaceOutputs(
           }
           files.push(`!${out}`)
         }
-        if (t.task?.['cache'] === undefined) break
+        if (t.task?.['inputs'] === undefined) break
       }
     }
   }
@@ -542,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 ' +
@@ -552,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 ` +