@vzn/vx 0.0.617 → 0.0.619

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.617",
+  "version": "0.0.619",
   "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.617",
-    "@vzn/vx-linux-arm64": "0.0.617",
-    "@vzn/vx-darwin-x64": "0.0.617",
-    "@vzn/vx-darwin-arm64": "0.0.617"
+    "@vzn/vx-linux-x64": "0.0.619",
+    "@vzn/vx-linux-arm64": "0.0.619",
+    "@vzn/vx-darwin-x64": "0.0.619",
+    "@vzn/vx-darwin-arm64": "0.0.619"
   },
   "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/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

package/src/orchestrator/prepare.ts

@@ -189,6 +189,18 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // fingerprint. A watch cycle is a new run and reads it afresh.
   const reads: LoadReads = new Map()
   const workspaceRoot = await findWorkspaceRoot(options.cwd, reads)
+  // A frozen run with nothing staged reads the lock whatever discovery
+  // finds, so the read (1.1 MB at 1,000 projects, ~10 ms to read and
+  // parse) starts here and overlaps discovery's I/O instead of following
+  // the cache open (X-181). A missing or malformed lock still refuses at
+  // the config load, after any earlier refusal.
+  let lockRead: Promise<Lockfile> | undefined
+  const readLock = (): Promise<Lockfile> =>
+    (lockRead ??= readLockfile(workspaceRoot).then((read) => {
+      if (read === null) throw new UserError(FROZEN_WITHOUT_LOCK)
+      return read
+    }))
+  if (options.frozen === true && options.staged === undefined) void readLock().catch(() => {})
   // An UNSCOPED run (no explicit scope, at least one bare task name)
   // enumerates the whole tree whatever the configs say, so git starts
   // HERE — the walk needs only the root — and overlaps the workspace
@@ -313,13 +325,8 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // Read once, and only when a config is to be read from it: the CLI's
   // selection pass may have staged every config (`options.staged`), and
   // its load refused a frozen run without a lock. A 1,000-project lock is
-  // 1.1 MB of JSON (I-27).
-  let lockRead: Promise<Lockfile> | undefined
-  const readLock = (): Promise<Lockfile> =>
-    (lockRead ??= readLockfile(workspaceRoot).then((read) => {
-      if (read === null) throw new UserError(FROZEN_WITHOUT_LOCK)
-      return read
-    }))
+  // 1.1 MB of JSON (I-27); a run with nothing staged started its read
+  // beside discovery, above.
   const staged = options.staged
   const allStaged =
     staged !== undefined &&

package/src/workspace/lockfile.ts

@@ -179,13 +179,18 @@ export async function frozenProjectConfigs(
   // The lock is hand-editable; the stored config crosses the same
   // boundary a freshly evaluated one does.
   const digest = store === undefined ? undefined : lockDigests.get(lock)
-  const keys =
+  const prefix =
     digest === undefined
       ? undefined
-      : metas.map(
-          (m) =>
-            `vx-lock-valid-v${CONFIG_EVAL_VERSION}\0${VERSION}\0${Bun.version}\0${digest}\0${m.name}`,
-        )
+      : `vx-lock-valid-v${CONFIG_EVAL_VERSION}\0${VERSION}\0${Bun.version}\0${digest}`
+  // One row for a lock whose every entry was accepted: a warm `--all` run
+  // asked for 1,090 per-project rows in one `IN` query, ~10 ms of its
+  // config load, where the eval-cache path it replaces is cheaper (X-181).
+  // A scoped run still validates, and remembers, only what it loads.
+  if (prefix !== undefined && store !== undefined && store.getConfigEval(prefix) !== null) {
+    return entries.map((e) => e.config)
+  }
+  const keys = prefix === undefined ? undefined : metas.map((m) => `${prefix}\0${m.name}`)
   const known =
     keys === undefined || store === undefined
       ? new Map<string, string>()
@@ -199,6 +204,14 @@ export async function frozenProjectConfigs(
     validateProjectConfig(entries[i]!.config, `${LOCKFILE_NAME} (${metas[i]!.name})`)
     if (key !== undefined) accepted.push([key, '1'])
   }
+  // Every meta found its entry above, so as many distinct names as the
+  // lock holds is every entry of it.
+  if (
+    prefix !== undefined &&
+    new Set(metas.map((m) => m.name)).size === Object.keys(lock.projects).length
+  ) {
+    accepted.push([prefix, '1'])
+  }
   if (store !== undefined && accepted.length > 0) {
     if (store.putConfigEvals !== undefined) store.putConfigEvals(accepted)
     else for (const [k, v] of accepted) store.putConfigEval(k, v)