@vzn/vx 0.0.616 → 0.0.618

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.616",
+  "version": "0.0.618",
   "description": "The fastest task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.616",
-    "@vzn/vx-linux-arm64": "0.0.616",
-    "@vzn/vx-darwin-x64": "0.0.616",
-    "@vzn/vx-darwin-arm64": "0.0.616"
+    "@vzn/vx-linux-x64": "0.0.618",
+    "@vzn/vx-linux-arm64": "0.0.618",
+    "@vzn/vx-darwin-x64": "0.0.618",
+    "@vzn/vx-darwin-arm64": "0.0.618"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/archive.ts

@@ -689,6 +689,14 @@ class Extractor {
     // resolve was a round trip spent on a comparison never made (item 627).
     let probe = path.dirname(targetResolved)
     while (probe.startsWith(baseResolved + path.sep)) {
+      // Nothing there resolves either: the lstat answers the common case
+      // (a clean pruned the directory) without the failed realpath's round
+      // trip and error (X-163). A dangling link is there and falls through,
+      // as does an lstat that fails otherwise: the realpath decides.
+      if (absent(probe)) {
+        probe = path.dirname(probe)
+        continue
+      }
       const real = await realOf(probe).then(
         (r) => r,
         () => null,
@@ -918,6 +926,15 @@ async function linkOutError(base: string, probe: string, realBase: string): Prom
   )
 }
 
+/** Whether nothing at all is at `p` (a dangling link is something). */
+function absent(p: string): boolean {
+  try {
+    return lstatSync(p, { throwIfNoEntry: false }) === undefined
+  } catch {
+    return false
+  }
+}
+
 /**
  * `realpath`, for a path holding a backslash too: Bun's answers ENOENT for
  * any such path (1.4.2), so the containment walk took a link named

package/src/cache/cache.ts

@@ -1399,6 +1399,7 @@ export class Cache implements CacheLayer {
     })
     const liveHashes = live.map((r) => r.hash)
     const fileRows = this.loadOutputFilesBatch(liveHashes)
+    this.outputs.hold(fileRows)
     const dirRows = this.loadOutputDirsBatch(liveHashes)
     for (const row of live) {
       this.touched.add(row.hash)
@@ -1534,7 +1535,7 @@ export class Cache implements CacheLayer {
     // same truncated expectation against the same truncated tree and agrees
     // forever. Refuse instead of silently under-restoring — checked before
     // anything is renamed into place.
-    const rows = this.loadOutputFilesBatch([hash]).get(hash) ?? []
+    const rows = this.guard(() => this.outputs.rowsOf(hash))
     const expected = rows
       .filter((r) => workspaceRoot !== undefined || !r.path.startsWith(WORKSPACE_OUTPUT_PREFIX))
       .map((r) => (r.path.startsWith(WORKSPACE_OUTPUT_PREFIX) ? r.path : `outputs/${r.path}`))

package/src/cache/inputs.ts

@@ -797,8 +797,15 @@ export async function cleanOutputs(args: {
   projectDir: string
   outputs: readonly string[]
   nestedProjectDirs: string[]
+  /**
+   * What `resolveOutputs` returned for these same arguments, when the
+   * caller walked the tree with no await since: a hit that found its tree
+   * stale walked it to say so, and a second walk here was half the
+   * restore's tree work (X-161).
+   */
+  resolved?: readonly string[] | undefined
 }): Promise<string[]> {
-  const files = await resolveOutputs(args)
+  const files = args.resolved ?? (await resolveOutputs(args))
   // `force: true` makes rm tolerate ENOENT (e.g. when two output
   // globs overlap and a sibling already deleted a path mid-iteration).
   // A symlink is unlinked, never followed.
@@ -1131,8 +1138,10 @@ export async function resolveWorkspaceOutputs(args: {
 export async function cleanWorkspaceOutputs(args: {
   workspaceRoot: string
   outputs: readonly string[]
+  /** `cleanOutputs`'s `resolved`, from `resolveWorkspaceOutputs`. */
+  resolved?: readonly string[] | undefined
 }): Promise<string[]> {
-  const files = await resolveWorkspaceOutputs(args)
+  const files = args.resolved ?? (await resolveWorkspaceOutputs(args))
   await pruneEmptiedDirs(
     args.workspaceRoot,
     await removeAll(files, args.workspaceRoot),

package/src/cache/output-index.ts

@@ -49,6 +49,17 @@ export class OutputIndex {
   private readonly pendingDirs = new Map<string, Array<[string, number]> | null>()
   /** Stamps taken and not yet written, flushed with the directory snapshots. */
   private readonly pendingStamps = new Map<string, Array<[string, number, number]>>()
+  /**
+   * The rows the last batched probe loaded, by hash: a hit's restore and
+   * the stamps after it read their rows here instead of the index, twice
+   * a restore (X-162). Read for path, size, mode and mtime only; a stamp
+   * taken since is the overlay `loadOutputFilesBatch` adds. Dropped when
+   * an entry's rows are replaced, and replaced by the next probe; rows
+   * held for an entry since pruned serve a restore that finds no artifact.
+   * Another process's save under the same key is the race the hit's own
+   * skip-restore check, which reads these rows, already runs.
+   */
+  private readonly held = new Map<string, readonly OutputFileRow[]>()
 
   constructor(private readonly db: Database) {
     this.insertOutputFile = lazyStatement(
@@ -108,6 +119,7 @@ export class OutputIndex {
    */
   replaceFileRows(hash: string, rows: ReadonlyArray<[string, number, number, number]>): void {
     // A stamp taken for the rows this replaces describes their files, not these.
+    this.held.delete(hash)
     this.pendingStamps.delete(hash)
     this.deleteOutputFiles.run(hash)
     this.deleteStamps.run(hash)
@@ -116,6 +128,17 @@ export class OutputIndex {
     }
   }
 
+  /** Hold a probe's rows for its restores (`held`), in place of the last probe's. */
+  hold(rows: ReadonlyMap<string, readonly OutputFileRow[]>): void {
+    this.held.clear()
+    for (const [hash, list] of rows) this.held.set(hash, list)
+  }
+
+  /** `hash`'s rows: the probe's when held, else read. Path, size, mode and mtime only. */
+  rowsOf(hash: string): readonly OutputFileRow[] {
+    return this.held.get(hash) ?? this.loadOutputFilesBatch([hash]).get(hash) ?? []
+  }
+
   loadOutputFilesBatch(hashes: readonly string[]): Map<string, OutputFileRow[]> {
     const out = new Map<string, OutputFileRow[]>()
     if (hashes.length === 0) return out
@@ -298,7 +321,7 @@ export class OutputIndex {
    * Written with the directory snapshots, in one transaction.
    */
   recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
-    const rows = this.loadOutputFilesBatch([hash]).get(hash) ?? []
+    const rows = this.rowsOf(hash)
     const stamps: Array<[string, number, number]> = []
     for (const e of rows) {
       const ws = e.path.startsWith(WORKSPACE_OUTPUT_PREFIX)

package/src/graph/priorities.ts

@@ -24,7 +24,17 @@ export function tieredReverseDepCount(
 ): Map<string, number> {
   const exec = new Map<string, TaskNode>()
   for (const [id, node] of nodes) if (!restoreTier.has(id)) exec.set(id, node)
-  const counts = computeReverseDepCount(exec)
+  // An exec tier with no edge inside it (a warm run's groups) counts 0
+  // everywhere: no closure to build.
+  let linked = false
+  for (const node of exec.values()) {
+    if (node.deps.some((d) => exec.has(d))) {
+      linked = true
+      break
+    }
+  }
+  const counts = linked ? computeReverseDepCount(exec) : new Map<string, number>()
+  if (!linked) for (const id of exec.keys()) counts.set(id, 0)
   let feeds = false
   for (const node of exec.values()) {
     const weight = 1 + counts.get(node.id)!

package/src/graph/scheduler.ts

@@ -324,6 +324,9 @@ export interface ScheduleOptions {
 class ReadyHeap {
   private readonly ids: string[] = []
   private readonly seq: number[] = []
+  // Each slot's priority, read once at push: a map lookup per comparison
+  // was two per heap level on every push and pop.
+  private readonly prio: number[] = []
   private next = 0
   constructor(private readonly priority: ReadonlyMap<string, number>) {}
   get size(): number {
@@ -331,8 +334,8 @@ class ReadyHeap {
   }
   /** True if slot i outranks slot j (higher priority, or equal priority + earlier seq). */
   private higher(i: number, j: number): boolean {
-    const pi = this.priority.get(this.ids[i]!) ?? 0
-    const pj = this.priority.get(this.ids[j]!) ?? 0
+    const pi = this.prio[i]!
+    const pj = this.prio[j]!
     return pi !== pj ? pi > pj : this.seq[i]! < this.seq[j]!
   }
   private swap(i: number, j: number): void {
@@ -342,6 +345,9 @@ class ReadyHeap {
     const si = this.seq[i]!
     this.seq[i] = this.seq[j]!
     this.seq[j] = si
+    const pi = this.prio[i]!
+    this.prio[i] = this.prio[j]!
+    this.prio[j] = pi
   }
   /**
    * `seq` defaults to a fresh monotonic counter. A parked-then-repushed
@@ -361,6 +367,7 @@ class ReadyHeap {
   push(id: string, seq: number = this.next++): void {
     this.ids.push(id)
     this.seq.push(seq)
+    this.prio.push(this.priority.get(id) ?? 0)
     let i = this.ids.length - 1
     while (i > 0) {
       const parent = (i - 1) >> 1
@@ -379,9 +386,11 @@ class ReadyHeap {
     const top = this.ids[0]!
     const lastId = this.ids.pop()!
     const lastSeq = this.seq.pop()!
+    const lastPrio = this.prio.pop()!
     if (n > 1) {
       this.ids[0] = lastId
       this.seq[0] = lastSeq
+      this.prio[0] = lastPrio
       let i = 0
       for (;;) {
         const l = 2 * i + 1
@@ -701,14 +710,18 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
     // could fail anyway.
     const aborted = (): boolean => options.signal?.aborted === true
     const serverDied = options.serverDied ?? ((): boolean => false)
-    const deadServerVia = (id: string): string | undefined =>
-      deadServerBehind(nodes, serverDied, id)
     const servers =
       options.serverDied === undefined
         ? []
         : [...nodes.values()]
             .filter((n) => n.config.exec?.persistent !== undefined)
             .map((n) => n.id)
+    // Only a server can die: with none in the graph, no walk (a stack and
+    // a set per dependency of every exec-tier task, X-171).
+    const deadServerVia =
+      servers.length === 0
+        ? (): undefined => undefined
+        : (id: string): string | undefined => deadServerBehind(nodes, serverDied, id)
     const willSkip = (id: string): boolean => {
       if (failFastTripped || aborted()) return true
       if (continueMode === 'never' && servers.some(serverDied)) {

package/src/orchestrator/hit-restore.ts

@@ -102,6 +102,10 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
   // — 1.7 ms each on a four-task real repo whose `link` and `element`
   // tasks declare `outputs: []` (2026-09-10, VX_TIMING).
   let skipRestore = !anyOutputs
+  // The walk that found the tree stale, handed to the clean when nothing
+  // was awaited between them: the clean's own walk would only repeat it
+  // (X-161).
+  let walked: { proj: string[]; ws: string[] } | undefined
   if (anyOutputs) {
     const endRows = span('output rows')
     const expected = hit.outputRows ?? args.cache.loadOutputFilesBatch([hash]).get(hash) ?? []
@@ -180,6 +184,7 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
         treeMatches = additive
           ? rowsPresent(actualRels, projExpected) && rowsPresent(actualWsRels, wsExpected)
           : setsMatch(actualRels, projExpected) && setsMatch(actualWsRels, wsExpected)
+        if (!treeMatches) walked = { proj: actualAbs, ws: actualWsAbs }
       }
       if (treeMatches) {
         const endStat = span('output stat')
@@ -216,6 +221,7 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
       })
       endGlob()
       skipRestore = actual.length === 0 && actualWs.length === 0
+      walked = { proj: actual, ws: actualWs }
     }
   }
   if (!skipRestore) {
@@ -233,8 +239,12 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
         outputs: wsOutputs,
       })
     } else {
-      if (outputs.length > 0) cleanedRels = await cleanOutputs(cleanArgs)
-      if (wsOutputs.length > 0) cleanedWsRels = await cleanWorkspaceOutputs(wsCleanArgs)
+      if (outputs.length > 0) {
+        cleanedRels = await cleanOutputs({ ...cleanArgs, resolved: walked?.proj })
+      }
+      if (wsOutputs.length > 0) {
+        cleanedWsRels = await cleanWorkspaceOutputs({ ...wsCleanArgs, resolved: walked?.ws })
+      }
     }
     await args.cache.restoreOutputs(hash, node.projectDir, args.workspaceRoot)
     // The tree now holds this entry's bytes: stamp them for the next hit