@vzn/vx 0.0.355 → 0.0.357

package/package.json

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

package/src/cache/archive.ts

@@ -122,10 +122,6 @@ const drain = async (body: AsyncIterable<Uint8Array>): Promise<void> => {
   }
 }
 
-const WIN32 = process.platform === 'win32'
-// A Windows link target may be spelled with either separator.
-const LINK_SEP = WIN32 ? /[\\/]/ : '/'
-
 /**
  * Sidecar shape. `files` maps an entry name to `[mode, mtimeMs]` — a
  * pair, not an object, because the sidecar is real entropy inside an
@@ -271,9 +267,7 @@ export async function planArtifact(args: PackArgs): Promise<ArtifactPlan> {
           `output ${shown} is not a regular file (a symlink to a directory?): vx stores regular files only — emit a file there, or narrow cache.outputs.files to the files the task produces, or take it back with a '!' entry`,
         )
       }
-      // Windows reports 0o666 (0o444 read-only) and never an exec bit: a
-      // Linux restore of that would be world-writable.
-      const mode = WIN32 ? 0o644 : st.mode & 0o777
+      const mode = st.mode & 0o777
       meta.files[name] = [mode, Math.floor(st.mtimeMs)]
       return {
         name,
@@ -788,9 +782,7 @@ class Extractor {
     let n = 0
     for (const s of this.staged) {
       const [mode, mtimeMs] = metaFor(s.name)
-      // Windows has no mode bits: chmod there only sets the read-only
-      // attribute, and a read-only restore refuses the next rename over it.
-      if ((mode & 0o777) !== createdMode && !WIN32) chmodSync(s.tmp, mode & 0o777)
+      if ((mode & 0o777) !== createdMode) chmodSync(s.tmp, mode & 0o777)
       if (mtimeMs !== undefined) {
         // A Date, not seconds: Bun reads a negative number of seconds as
         // "now", and a Date before 1970 as itself (Bun 1.4.2).
@@ -904,7 +896,7 @@ async function resolveThrough(p: string): Promise<string> {
       at = path.parse(link).root
       rest = link.slice(at.length)
     }
-    pending.push(...rest.split(LINK_SEP).filter(Boolean).reverse())
+    pending.push(...rest.split('/').filter(Boolean).reverse())
   }
   return at
 }

package/src/cache/cache.ts

@@ -2026,8 +2026,8 @@ const SQLITE_FCNTL_PERSIST_WAL = 10
  * Close for real. A plain `close()` leaves the connection open while any
  * statement from `db.prepare()` lives (bun:sqlite 1.4.2 defers it, as
  * `sqlite3_close_v2` does), so `cache.db` and its `-wal` and `-shm` stayed
- * open after `Cache.close()`: a leaked descriptor per run for an embedder,
- * and on Windows a cache directory nothing could delete (O-10).
+ * open after `Cache.close()`: a leaked descriptor per run for an embedder
+ * (O-10).
  * `close(true)` finalizes them and closes.
  */
 function closeDb(db: Database): void {

package/src/cache/inputs.ts

@@ -22,7 +22,6 @@ import { rm, rmdir } from 'node:fs/promises'
 import type { CacheInputs } from '../config.js'
 import {
   asTrees,
-  executablePath,
   isExecutableMissing,
   isLiteralPattern,
   normalizeGlob,
@@ -394,17 +393,15 @@ async function runRuntimeCommand(
     // vx's own `sh`, resolved on its PATH before the probe's: Bun.spawn looks
     // a bare name up on the child's PATH, which leads with the project's
     // `node_modules/.bin`, so a dependency's `sh` bin ran every probe (J-69).
-    const argv =
-      process.platform === 'win32' ? shellArgv(command) : [executablePath('sh'), '-c', command]
-    proc = Bun.spawn(argv, {
+    proc = Bun.spawn(shellArgv(command), {
       cwd,
       env: { ...process.env, PATH: ambient ? `${prefix}${path.delimiter}${ambient}` : prefix },
       stdin: 'ignore',
       stdout: 'pipe',
       stderr: 'pipe',
       // Its own group, so the probe's whole tree can be taken down with vx
-      // (`killProbesOnExit`). Windows has no groups.
-      detached: process.platform !== 'win32',
+      // (`killProbesOnExit`).
+      detached: true,
     })
   } catch (err) {
     // The probe runs through `sh -c` like a task: a box without sh names

package/src/cli/help.ts

@@ -61,7 +61,8 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '                             foo, @scope/*, ./packages/foo, foo..., ...foo,',
     '                             foo^..., !foo, [<since>]',
     '      --affected[=<base>]  Sugar for --filter "...[<base>]". Default base =',
-    '                             affectedBase, else origin/HEAD, else HEAD~1.',
+    '                             affectedBase, else origin/HEAD, else main or',
+    '                             master, else HEAD~1.',
     "  pkg#task                 Run a specific project's task directly.",
     '',
     'Execution (for run):',

package/src/cli/init.ts

@@ -193,7 +193,7 @@ async function adopt(
           ? ''
           : `${cache}(): ${remote}, so vx shares that remote cache (inert where the variable is unset).\n`
   process.stdout.write(
-    `vx init: ${source} found — ${runner}() from @vzn/vx-migrate runs this repo as it is; nothing else written.\n` +
+    `vx init: ${source} found — ${runner}() from @vzn/vx-migrate, a temporary start until bunx @vzn/vx-migrate writes native config; nothing else written.\n` +
       `${wrote}\n${cacheLine}\nnext: ${adoptionNext(root, runner, source)}\n`,
   )
   return 0

package/src/cli/upgrade.ts

@@ -21,11 +21,10 @@ const REPO = 'vznjs/vx'
 
 /**
  * A Bun standalone-binary path lives under the bunfs virtual root.
- * Marker differs by platform / Bun version: `/$bunfs/...` (posix) and
- * `B:\~BUN\...` or `B:/~BUN/...` (windows).
+ * Marker: `/$bunfs/...`.
  */
 export function isBunfsPath(p: string): boolean {
-  return p.startsWith('/$bunfs') || p.startsWith('B:\\~BUN') || p.startsWith('B:/~BUN')
+  return p.startsWith('/$bunfs')
 }
 
 /**

package/src/exec/env.ts

@@ -32,22 +32,6 @@ export const ESSENTIAL_ENV: readonly string[] = [
   'NO_COLOR',
   'CI',
   'NODE_OPTIONS',
-  'SYSTEMROOT',
-  'APPDATA',
-  'LOCALAPPDATA',
-  'PROGRAMDATA',
-  'PROGRAMFILES',
-  'PROGRAMFILES(X86)',
-  'COMSPEC',
-  'PATHEXT',
-  // Read on Windows by os.homedir(), npm and git, which break without them.
-  'SYSTEMDRIVE',
-  'WINDIR',
-  'USERPROFILE',
-  'HOMEDRIVE',
-  'HOMEPATH',
-  'NUMBER_OF_PROCESSORS',
-  'PROCESSOR_ARCHITECTURE',
 ]
 
 /**

package/src/exec/kill-tree.ts

@@ -15,25 +15,6 @@ import { executablePath, procfsIsOwn } from '../util/index.js'
 
 export type Child = ReturnType<typeof Bun.spawn>
 
-const WIN32 = process.platform === 'win32'
-
-/**
- * Windows has no process groups (`kill(-pid)` is ESRCH, which read as
- * "gone" and killed nothing) and no polite signal a console task hears
- * from another process, so every stop is `taskkill /T /F`: the child and
- * every descendant it still parents. A grandchild whose parent already
- * exited is out of the tree's reach (docs/design/windows-2026-09.md).
- */
-function killTreeWin32(child: Child): void {
-  try {
-    Bun.spawn(['taskkill', '/T', '/F', '/PID', String(child.pid)], {
-      stdio: ['ignore', 'ignore', 'ignore'],
-    })
-  } catch {
-    child.kill()
-  }
-}
-
 /**
  * A child whose polite signals go down a pipe instead of to its group: a
  * Linux sandboxed task. The group there is bwrap's, whose monitor dies of
@@ -97,8 +78,6 @@ const GUARD_SCRIPT = [
 function startGuard(): void {
   if (guardFd !== undefined) return
   guardFd = null
-  // The guard is an `sh` script over process groups; Windows has neither.
-  if (process.platform === 'win32') return
   try {
     const guard = Bun.spawn([executablePath('sh'), '-c', GUARD_SCRIPT], {
       argv0: 'vx-group-guard',
@@ -227,7 +206,6 @@ export function killTree(child: Child, signal: 'SIGINT' | 'SIGTERM' | 'SIGKILL')
   // A pid of 0 would name OUR group (kill(0)): a child that never
   // spawned has nothing to kill.
   if (!(child.pid > 0) || goneGroups.has(child)) return
-  if (WIN32) return killTreeWin32(child)
   const fd = signal === 'SIGKILL' ? undefined : channels.get(child)
   if (fd !== undefined) {
     try {
@@ -297,8 +275,6 @@ export async function untilGroupsGone(
  */
 function groupAlive(child: Child): boolean {
   if (!(child.pid > 0) || goneGroups.has(child)) return false
-  // No groups: the tree kill is `taskkill /T`, and the leader is what is left to ask.
-  if (WIN32) return child.exitCode === null && child.signalCode === null
   try {
     process.kill(-child.pid, 0)
   } catch (err) {

package/src/exec/local-executor.ts

@@ -4,7 +4,7 @@
 // plugin claims the task, so it sits at the TAIL of every executor list
 // (owner, 2026-09-05). An executor plugin places work ELSEWHERE; its
 // absence is "here".
-import { runCommand, signalExitCode } from './runner.js'
+import { runCommand, signalExitCode, stopSignal } from './runner.js'
 import { runSandboxed } from './sandbox-runtime.js'
 import type { TaskExecutor } from './executor.js'
 
@@ -29,8 +29,7 @@ export function localExecutor(): TaskExecutor {
       // runs after the teardown swept the run's children, and held the run
       // to the signal's bound.
       if (req.signal?.aborted === true) {
-        const reason: unknown = req.signal.reason
-        const signal = reason === 'SIGINT' || reason === 'SIGHUP' ? reason : 'SIGTERM'
+        const signal = stopSignal(req.signal.reason)
         const exitCode = signalExitCode(signal)
         return { exitCode, durationMs: 0, stdout: '', stderr: '', signal, violations: [] }
       }

package/src/exec/runner.ts

@@ -4,7 +4,7 @@
 // process exits. cpuMs / peakRssBytes are then surfaced on RunResult and
 // folded into the v11 `runs` table by the orchestrator.
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { constants as osConstants } from 'node:os'
 import {
   shellArgv,
@@ -25,9 +25,8 @@ import {
   untilGroupsGone,
 } from './kill-tree.js'
 
-const WIN32 = process.platform === 'win32'
-/** `sh` names itself in its errors; `bun exec` on Windows keeps its own. */
-const SH_ARGV0 = WIN32 ? {} : { argv0: 'sh' }
+/** `sh` names itself in its errors. */
+const SH_ARGV0 = { argv0: 'sh' }
 
 export interface RunResult {
   exitCode: number
@@ -224,8 +223,6 @@ const SHELL_BUILTINS = new Set([
  * the shell.
  */
 export function execWrap(command: string): string {
-  // Bun's shell, the task shell on Windows, has no `exec`.
-  if (WIN32) return command
   const first = execWord(command)
   return first === undefined ? command : `exec ${command}`
 }
@@ -238,9 +235,23 @@ export function execWrap(command: string): string {
  */
 export function execWord(command: string): string | undefined {
   if (SHELL_CONTROL.test(command)) return undefined
-  const first = command.trimStart().split(/\s+/)[0] ?? ''
-  if (first === '' || first.includes('=') || SHELL_BUILTINS.has(first)) return undefined
-  return first
+  // The word as the shell reads it: quotes group and are removed, so
+  // `"./my tool.sh"` names one file (the verdict looked for `"./my`).
+  const raw = command.trimStart()
+  let first = ''
+  let quote = ''
+  let i = 0
+  for (; i < raw.length; i++) {
+    const c = raw[i]!
+    if (quote !== '') {
+      if (c === quote) quote = ''
+      else first += c
+    } else if (c === "'" || c === '"') quote = c
+    else if (/\s/.test(c)) break
+    else first += c
+  }
+  if (quote !== '' || first === '' || raw.slice(0, i).includes('=')) return undefined
+  return SHELL_BUILTINS.has(first) ? undefined : first
 }
 
 /**
@@ -254,6 +265,16 @@ export function signalExitCode(signal: string): number {
   return num === undefined ? 130 : 128 + num
 }
 
+/**
+ * The signal a run's stop sends a task, from its abort reason: a task
+ * stopped before its spawn exits as if that signal had killed it. As
+ * `forwardedSignal` (orchestrator/signals.ts): a hang-up forwards SIGTERM
+ * (to many servers SIGHUP means "reload"), so it reads as SIGTERM here.
+ */
+export function stopSignal(reason: unknown): 'SIGINT' | 'SIGTERM' {
+  return reason === 'SIGINT' ? 'SIGINT' : 'SIGTERM'
+}
+
 /**
  * The reverse: the signal an exit above 128 stands for (137 → SIGKILL),
  * by the platform's numbering; undefined for a plain exit. The shell
@@ -484,9 +505,8 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
           ],
           // Its own session and process group, so a kill reaches what it
           // forked (kill-tree.ts). stdin is a pipe, so a background group
-          // never stops on a terminal read. Windows has no groups, and a
-          // detached child there has no console.
-          detached: !WIN32,
+          // never stops on a terminal read.
+          detached: true,
         },
       ),
     )
@@ -695,9 +715,8 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
         stdio: ['ignore', 'pipe', 'pipe', ...(guard === undefined ? [] : [guard])],
         // Its own session and process group, so a kill reaches what it
         // forked (kill-tree.ts). stdin is ignored, so a background group
-        // never stops on a terminal read. Windows has no groups, and a
-        // detached child there has no console.
-        detached: !WIN32,
+        // never stops on a terminal read.
+        detached: true,
       }),
     )
   } catch (err) {
@@ -750,18 +769,15 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
  * `true` read 44 MB through vx while its shell's `VmHWM` was 1.9 MB, and
  * 300 MB allocated in the parent made `true` read 328 MB (2026-09-12).
  * Read after the child exits so it covers the whole task's span (the mark
- * is monotonic). Linux reads `VmHWM`; elsewhere the current RSS is the
- * bound in hand.
+ * is monotonic). Linux reads its own peak (`getrusage`); elsewhere the
+ * current RSS is the bound in hand.
  */
 export function ownRssHighWater(): number {
-  if (process.platform === 'linux') {
-    try {
-      const m = /VmHWM:\s+(\d+) kB/.exec(readFileSync('/proc/self/status', 'utf8'))
-      if (m !== null) return Number(m[1]) * 1024
-    } catch {
-      // /proc unreadable: fall through to the current RSS.
-    }
-  }
+  // getrusage's own peak, not `/proc/self/status`'s `VmHWM`: one syscall
+  // where generating and parsing the status file was ~20 µs a task alone
+  // and ~70 ms of a 1,000-task cold run. It is the same mark, raised only
+  // by the image this one exec'd from (a shell), within the floor's slack.
+  if (process.platform === 'linux') return peakRssBytes(process.resourceUsage().maxRSS)
   return process.memoryUsage.rss()
 }
 

package/src/exec/sandbox-binds.ts

@@ -10,6 +10,7 @@ import {
   isMountableLiteral,
   localBindingOn,
   MOUNT_WILDCARDS,
+  toRealPath,
   unique,
 } from './sandbox-paths.js'
 import type { SandboxedRunArgs } from './sandbox-runtime.js'
@@ -27,27 +28,50 @@ type SrtModule = typeof import('@anthropic-ai/sandbox-runtime')
  * is "Device or resource busy"; binding `/w/dist` instead succeeds.
  *
  * So on Linux a file-shaped grant is widened to its directory. That IS a
- * widening — the task may write its siblings — and it is the narrowest
+ * widening — the task may write its siblings, and read them unrefused
+ * (`widenedEntries` has those reads reported) — and it is the narrowest
  * grant the mechanism can express: the alternative is a declared output
  * the task cannot produce. macOS needs none of this (seatbelt matches
  * paths, it does not mount), so the grant stays exact there.
  */
 export function bindableWrites(paths: readonly string[]): string[] {
   if (process.platform !== 'linux') return [...paths]
-  return unique(
-    paths
-      .filter((p) => !holdsGlobChar(p))
-      .map((p) => {
-        if (!isMountableLiteral(p)) return p
-        try {
-          if (statSync(p).isDirectory()) return p
-        } catch {
-          // Does not exist yet: `prepareOutputsForBind` creates a file for a
-          // file-shaped grant, so treat it as one.
-        }
-        return path.dirname(p)
-      }),
-  )
+  return unique(paths.filter((p) => !holdsGlobChar(p)).map(bindOf))
+}
+
+function bindOf(p: string): string {
+  if (!isMountableLiteral(p)) return p
+  try {
+    if (statSync(p).isDirectory()) return p
+  } catch {
+    // Does not exist yet: `prepareOutputsForBind` creates a file for a
+    // file-shaped grant, so treat it as one.
+  }
+  return path.dirname(p)
+}
+
+/**
+ * What each directory `bindableWrites` widened a file grant to held when
+ * the task started, by real path. A read there is never refused, so the
+ * strace pass reports one of these no grant covers: a task granted
+ * `write: ['out.txt']` read the whole project unreported, and a cached run
+ * replayed an undeclared file's old bytes. What the task creates there is
+ * its own, not an input, so only these entries count. Empty off Linux.
+ */
+export function widenedEntries(paths: readonly string[]): Map<string, Set<string>> {
+  const out = new Map<string, Set<string>>()
+  if (process.platform !== 'linux') return out
+  for (const p of paths) {
+    if (holdsGlobChar(p) || bindOf(p) === p) continue
+    const dir = toRealPath(path.dirname(p))
+    if (out.has(dir)) continue
+    try {
+      out.set(dir, new Set(readdirSync(dir).map((e) => path.join(dir, e))))
+    } catch {
+      // Gone or unreadable: nothing there to read.
+    }
+  }
+  return out
 }
 
 /**

package/src/exec/sandbox-runtime.ts

@@ -48,6 +48,7 @@ import {
   shellQuote,
   withForwardArgs,
   signalExitCode,
+  stopSignal,
   spawnFailureText,
   streamToString,
   resourceUsageToCpuRss,
@@ -63,7 +64,13 @@ import {
   UserError,
   xxh3hex,
 } from '../util/index.js'
-import { bindableReads, bindableWrites, buildCustomConfig, scratchWrites } from './sandbox-binds.js'
+import {
+  bindableReads,
+  bindableWrites,
+  buildCustomConfig,
+  scratchWrites,
+  widenedEntries,
+} from './sandbox-binds.js'
 import {
   atOrUnder,
   isMountableLiteral,
@@ -550,6 +557,9 @@ export async function initSandbox(opts?: {
   /** Whether any task of the run grants `gitConfig`: SRT reads it run-wide, so it is set per wrap (B-41). */
   gitConfig?: boolean
 }): Promise<void> {
+  // This run owns the session now; a reset an earlier run deferred to its
+  // last server would tear it down under this run's tasks (M-25).
+  resetDeferred = false
   // A reset a server's exit started unawaited: a watch cycle stops its
   // server and starts its run at once, and an init under that reset
   // found SRT up, hot-reloaded it, and had it torn down after (item 884).
@@ -947,6 +957,8 @@ export async function wrapSandboxedCommand(
       server?: boolean
       /** Trace the command's `openat` calls to descriptor TRACE_FD (Linux; `wantsStraceDetection`). */
       trace?: 'plain' | 'seccomp'
+      /** Trace with `-y`, each descriptor's path printed: a read under a widened grant is judged. */
+      tracePaths?: boolean
     },
 ): Promise<{
   wrapped: string
@@ -1004,7 +1016,7 @@ export async function wrapSandboxedCommand(
   const ports = process.platform === 'linux' ? bridgedPorts(args.config) : []
   const grouped =
     process.platform === 'linux'
-      ? ownGroupCommand(tag, inTmp, args.trace)
+      ? ownGroupCommand(tag, inTmp, args.trace, args.tracePaths === true)
       : { command: taggedCommand, forwards: false, traced: false }
   const inner = [
     ports.length > 0 ? portBridgeInner(ports, tag) : '',
@@ -1082,6 +1094,7 @@ function ownGroupCommand(
   tag: string,
   userCommand: string,
   trace?: 'plain' | 'seccomp',
+  tracePaths = false,
 ): { command: string; forwards: boolean; traced: boolean } {
   // `sh`, as an unsandboxed task runs (`runner.ts`): the command ran under
   // bash here, so `[[ … ]]`, brace expansion and `echo 'a\tb'` read one
@@ -1131,6 +1144,10 @@ function ownGroupCommand(
     '-DD',
     '-f',
     ...(trace === 'seccomp' ? ['--seccomp-bpf'] : []),
+    // A read through a directory's descriptor (`find`, `grep -r`) names
+    // only the entry; `-y` prints the path it opened. 40% slower on 2,000
+    // opens, so only where a widened grant's reads are judged.
+    ...(tracePaths ? ['-y'] : []),
     '-qq',
     '-e',
     // A process's cwd moves on `chdir` and starts as its parent's at the
@@ -1477,9 +1494,31 @@ async function runSandboxedOnce(
   // kernel filter stops only on `openat`. strace ≥ 5.3 (2019); an older
   // one gets the slow form rather than no detection.
   const useStrace = await wantsStraceDetection()
+  // Before the spawn: what the task creates under a widened grant is its own.
+  const widened = useStrace ? widenedEntries(args.config.allowWrite) : undefined
   const { wrapped, tag, srtCommand, baselines, scratch, forwardsSignals, traced } =
-    await wrapSandboxedCommand({ ...args, ...(useStrace ? { trace: useStrace } : {}) })
+    await wrapSandboxedCommand({
+      ...args,
+      ...(useStrace ? { trace: useStrace } : {}),
+      ...(widened !== undefined && widened.size > 0 ? { tracePaths: true } : {}),
+    })
   const takeRecords = collectRecords(SandboxManager.getSandboxViolationStore(), srtCommand)
+  // A stop that landed during the awaits above leaves nothing to kill yet:
+  // spawned now, the task ran after the teardown swept the run's children.
+  if (args.signal?.aborted === true) {
+    releaseBridges(tag)
+    takeRecords()
+    const signal = stopSignal(args.signal.reason)
+    return {
+      exitCode: signalExitCode(signal),
+      durationMs: Date.now() - start,
+      stdout: '',
+      stderr: '',
+      signal,
+      violations: [],
+      tracerFailed: false,
+    }
+  }
   // Beside the task directories, which every sandbox replaces with its own:
   // in the shared temp dir a concurrent task read this log, every path
   // this task opened (L-25).
@@ -1628,7 +1667,7 @@ async function runSandboxedOnce(
     process.platform === 'linux'
       ? [
           ...(straceLog
-            ? await parseStraceViolations(straceLog, args, baselines).catch(() => [])
+            ? await parseStraceViolations(straceLog, args, baselines, widened).catch(() => [])
             : []),
           ...refusedWrites(
             // Keyed by what SRT wrapped, the in-sandbox group wrapper

package/src/exec/sandbox-violations.ts

@@ -50,6 +50,25 @@ const STRACE_RESUMED_RE = new RegExp(
 )
 /** A resumed call that SUCCEEDED — clears the pending entry, emits nothing. */
 const STRACE_RESUMED_OK_RE = new RegExp(`^(\\d+)\\s+<\\.\\.\\. (${SYSCALLS}) resumed>`)
+/**
+ * An `openat` that succeeded, and not for writing alone: a read. Placed by
+ * the path `-y` prints for the descriptor it returned; without one, only
+ * from the cwd (`AT_FDCWD`) or by an absolute path.
+ */
+const READ_FLAGS = '(?![A-Z_|]*O_WRONLY)[A-Z_|]+'
+const OPEN_READ_RE = new RegExp(
+  `^(\\d+)\\s+openat\\((AT_FDCWD|\\d+)(?:<[^"]*>)?, ${QUOTED}, ${READ_FLAGS}[^)]*\\)\\s*=\\s*\\d+(?:<(.*)>)?$`,
+)
+const OPEN_READ_UNFINISHED_RE = new RegExp(
+  `^(\\d+)\\s+openat\\((AT_FDCWD|\\d+)(?:<[^"]*>)?, ${QUOTED}, ${READ_FLAGS}.*<unfinished`,
+)
+const RESUMED_FD_RE = /resumed>.*\)\s*=\s*\d+(?:<(.*)>)?$/
+
+/** Where a successful read opened: `-y`'s path, else the call's own when placeable. */
+function readPath(dirfd: string, rawPath: string, opened: string | undefined): string | undefined {
+  if (opened !== undefined) return cStringPath(opened)
+  return dirfd === 'AT_FDCWD' || rawPath.startsWith('/') ? rawPath : undefined
+}
 
 const C_ESCAPES: Record<string, number> = { n: 10, t: 9, r: 13, v: 11, f: 12, a: 7, b: 8 }
 
@@ -89,6 +108,8 @@ export interface DeniedCall {
   syscall: string
   rawPath: string
   errno: string
+  /** A read that SUCCEEDED (`errno` empty): asked for by `deniedCalls`' `reads`. */
+  read?: true
   /**
    * The directory a relative `rawPath` was opened from, when the trace
    * shows the process (or one it was forked from) changed into one; absent
@@ -132,8 +153,11 @@ type Op = { chdir: string } | { lost: true } | { call: number }
  * detector, and a synthetic trace pins the split-line shapes deterministically
  * where an end-to-end run only produces them when strace happens to interleave.
  */
-export function deniedCalls(text: string, cwd?: string): DeniedCall[] {
-  const pending = new Map<string, { syscall: string; rawPath: string }>()
+export function deniedCalls(text: string, cwd?: string, reads = false): DeniedCall[] {
+  const pending = new Map<
+    string,
+    { syscall: string; rawPath: string; read?: true; dirfd?: string }
+  >()
   const out: DeniedCall[] = []
   const ops = new Map<string, Op[]>()
   // A clone with CLONE_FS (every thread) shares its creator's cwd, so a
@@ -162,6 +186,15 @@ export function deniedCalls(text: string, cwd?: string): DeniedCall[] {
     const opener =
       line.includes('= -1') || line.includes('<unfinished') || line.includes('resumed>')
     if (!opener) {
+      if (reads && line.includes('openat(')) {
+        const m = OPEN_READ_RE.exec(line)
+        if (m !== null) {
+          const at = readPath(m[2]!, cStringPath(m[3]!), m[4])
+          if (at !== undefined)
+            denied(m[1]!, { syscall: 'openat', rawPath: at, errno: '', read: true })
+          continue
+        }
+      }
       if (
         cwd !== undefined &&
         (line.includes('chdir(') || line.includes('fork(') || line.includes('clone'))
@@ -180,7 +213,12 @@ export function deniedCalls(text: string, cwd?: string): DeniedCall[] {
       unfinished[2] !== undefined &&
       unfinished[3] !== undefined
     ) {
-      pending.set(unfinished[1], { syscall: unfinished[2], rawPath: cStringPath(unfinished[3]) })
+      pending.set(unfinished[1], {
+        syscall: unfinished[2],
+        rawPath: cStringPath(unfinished[3]),
+        ...(reads && OPEN_READ_UNFINISHED_RE.test(line) ? { read: true as const } : {}),
+        ...(reads ? { dirfd: OPEN_READ_UNFINISHED_RE.exec(line)?.[2] ?? 'AT_FDCWD' } : {}),
+      })
       continue
     }
     const resumedOk = STRACE_RESUMED_OK_RE.exec(line)
@@ -190,8 +228,14 @@ export function deniedCalls(text: string, cwd?: string): DeniedCall[] {
       const resumed = STRACE_RESUMED_RE.exec(line)
       // Only a resume that carries a DENIAL is a violation; a successful
       // resume just retires the pending entry.
+      const fd = held?.read === true ? RESUMED_FD_RE.exec(line) : null
       if (held !== undefined && resumed?.[3] !== undefined) {
-        denied(resumedOk[1], { ...held, errno: resumed[3] })
+        denied(resumedOk[1], { syscall: held.syscall, rawPath: held.rawPath, errno: resumed[3] })
+      } else if (held !== undefined && fd !== null) {
+        const at = readPath(held.dirfd ?? 'AT_FDCWD', held.rawPath, fd[1])
+        if (at !== undefined) {
+          denied(resumedOk[1], { syscall: held.syscall, rawPath: at, errno: '', read: true })
+        }
       }
       continue
     }
@@ -264,6 +308,8 @@ export async function parseStraceViolations(
   logPath: string,
   args: SandboxedRunArgs,
   baselines: { allowRead: readonly string[]; denyRead: readonly string[]; cwd: string },
+  /** `widenedEntries` taken as the task started: no entry, no read parse. */
+  widened: ReadonlyMap<string, ReadonlySet<string>> = new Map(),
 ): Promise<SandboxViolation[]> {
   const text = await Bun.file(logPath).text()
   if (text.length === 0) return []
@@ -281,29 +327,60 @@ export async function parseStraceViolations(
     ),
   )
   const denyAnchors = baselines.denyRead.map((p) => toRealPath(absolutize(p)))
+  // A read under a widened write grant's directory is never refused, so it
+  // is reported when it succeeds: an entry that was there at the start and
+  // no grant covers is an input the key never saw, and so is the
+  // directory's listing while it holds one. The granted files and what the
+  // task made itself stay readable.
+  const written = new Set(args.config.allowWrite.map((p) => toRealPath(absolutize(p))))
+  const undeclared = (abs: string): boolean => {
+    for (const [dir, entries] of widened) {
+      if (abs === dir)
+        return [...entries].some((e) => !isUnderAny(e, written) && !isUnderAny(e, allowAbs))
+      if (!atOrUnder(abs, dir)) continue
+      const top = path.join(dir, path.relative(dir, abs).split(path.sep)[0]!)
+      return entries.has(top) && !isUnderAny(abs, written)
+    }
+    return false
+  }
 
   const seen = new Set<string>()
   const out: SandboxViolation[] = []
-  for (const { syscall, rawPath, errno, dir } of deniedCalls(text, baselines.cwd)) {
+  for (const { syscall, rawPath, errno, dir, read } of deniedCalls(
+    text,
+    baselines.cwd,
+    widened.size > 0,
+  )) {
     const abs = toRealPath(absolutize(rawPath, dir ?? baselines.cwd))
     // Only report paths under the workspace-root deny anchor — system
     // libs / /proc / /sys / etc. probes are not interesting violations.
     if (!denyAnchors.some((root) => atOrUnder(abs, root))) continue
     // Skip paths the user explicitly allowed (and their descendants).
     if (isUnderAny(abs, allowAbs)) continue
+    if (read === true && !undeclared(abs)) continue
     const key = `${syscall}|${abs}`
     if (seen.has(key)) continue
     seen.add(key)
-    out.push({
-      line: `${syscall}(${rawPath}) = -1 ${errno}  [${abs}]`,
-      timestamp: new Date(),
-      target: abs,
-      path: abs,
-      // The trace is `-e trace=openat`, and an openat is a read or a
-      // write depending on flags the trace does not carry — so either
-      // list can silence it.
-      ignorable: ['read', 'write'],
-    })
+    out.push(
+      read === true
+        ? {
+            line: `${syscall}(${rawPath}) read under a write grant's directory, granted no read  [${abs}]`,
+            timestamp: new Date(),
+            target: abs,
+            path: abs,
+            ignorable: ['read'],
+          }
+        : {
+            line: `${syscall}(${rawPath}) = -1 ${errno}  [${abs}]`,
+            timestamp: new Date(),
+            target: abs,
+            path: abs,
+            // The trace is `-e trace=openat`, and an openat is a read or a
+            // write depending on flags the trace does not carry — so either
+            // list can silence it.
+            ignorable: ['read', 'write'],
+          },
+    )
   }
   return out
 }

package/src/orchestrator/events.ts

@@ -52,7 +52,12 @@ export interface EventBus {
 }
 
 export function createEventBus(): EventBus {
-  const subscribers: RunEventSubscriber[] = []
+  // Replaced, never mutated: an emit walks the list it started with, so a
+  // subscriber that unsubscribes itself (an embedder's `off()` on
+  // `run:end`) no longer shifts the next one past the event — the terminal
+  // renderer after it missed `run:end` (C-77). A subscriber added during
+  // an emit hears the next event, not this one.
+  let subscribers: readonly RunEventSubscriber[] = []
   return {
     emit(event) {
       // Synchronous, in-subscription-order fan-out. Ordering is part of
@@ -79,10 +84,10 @@ export function createEventBus(): EventBus {
       }
     },
     subscribe(subscriber) {
-      subscribers.push(subscriber)
+      subscribers = [...subscribers, subscriber]
       return () => {
         const i = subscribers.indexOf(subscriber)
-        if (i >= 0) subscribers.splice(i, 1)
+        if (i >= 0) subscribers = subscribers.toSpliced(i, 1)
       }
     },
   }

package/src/orchestrator/execute-task.ts

@@ -37,7 +37,7 @@ import {
 } from '../exec/index.js'
 import { isGroupTask, RestoreDemoted, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import { killGraceMs, maskedEmitter, printable, relPosix, secretMask, span } from '../util/index.js'
-import { SIGNAL_SHUTDOWN_GRACE_MS } from './signals.js'
+import { forwardedSignal, SIGNAL_SHUTDOWN_GRACE_MS } from './signals.js'
 import { executorLabel, nameExecutorFailure } from './plugin-host.js'
 import {
   mayWriteFingerprint,
@@ -354,6 +354,22 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
     persistentOpts.timeoutMs = effectiveTimeout
   }
 
+  // A stop that landed during the awaits above (the key, the sandbox's
+  // arming, request and wrap) leaves nothing to kill yet: spawned now, the
+  // server came up after the teardown and held the run's exit 7 s.
+  if (args.stopSignal?.aborted === true) {
+    if (bridgeTag !== undefined) releaseBridges(bridgeTag)
+    await placeholderSweeper(placeholders)()
+    return {
+      node,
+      status: 'aborted',
+      // The signal a spawned server would have been sent (a hang-up forwards SIGTERM).
+      exitCode: signalExitCode(forwardedSignal(args.stopSignal.reason)),
+      durationMs: 0,
+      wallclockStartNs,
+      wallclockEndNs: process.hrtime.bigint() - args.runStartHrTimeNs,
+    }
+  }
   const spawn = runPersistent(persistentOpts)
   // The host side of a port bridge lives exactly as long as the server:
   // released on the child's exit, whether the run tore it down or it died.
@@ -493,11 +509,22 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   // The local executor keeps its own timer (it signals the process group).
   let timeoutTimer: ReturnType<typeof setTimeout> | undefined
   let timeoutFired = false
+  // The attempt's listener on the run's stop signal, taken off once the
+  // attempt settles. Left on, every task of the run added one: the list
+  // grew to the task count, and each add scans it for a duplicate, ~100 ms
+  // of a 1,000-task cold run.
+  let unlistenStop: (() => void) | undefined
   function requestSignal(): AbortSignal {
     const stop = new AbortController()
     const abort = (): void => stop.abort(args.stopSignal?.reason)
+    unlistenStop?.()
+    unlistenStop = undefined
     if (args.stopSignal?.aborted === true) abort()
-    else args.stopSignal?.addEventListener('abort', abort, { once: true })
+    else if (args.stopSignal !== undefined) {
+      const run = args.stopSignal
+      run.addEventListener('abort', abort, { once: true })
+      unlistenStop = () => run.removeEventListener('abort', abort)
+    }
     if (effectiveTimeout !== undefined) {
       clearTimeout(timeoutTimer)
       timeoutFired = false
@@ -801,6 +828,8 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       })
       .finally(() => {
         clearTimeout(timeoutTimer)
+        unlistenStop?.()
+        unlistenStop = undefined
         flushMasked()
       })
     endExec()

package/src/orchestrator/run-lock.ts

@@ -240,7 +240,7 @@ async function place(lockDir: string): Promise<string | null> {
   await mkdir(staging)
   try {
     await writeFile(path.join(staging, entry), '')
-    await (WIN32 ? renameWin32(staging, lockDir) : rename(staging, lockDir))
+    await rename(staging, lockDir)
     return entry
   } catch (err) {
     await rm(staging, { recursive: true, force: true })
@@ -250,36 +250,6 @@ async function place(lockDir: string): Promise<string | null> {
   }
 }
 
-const WIN32 = process.platform === 'win32'
-
-/**
- * Windows renames no directory onto another, even an empty one: EPERM
- * where POSIX gives ENOTEMPTY, which read as a refusal and ran every
- * contender unlocked. A name that exists is taken; an empty one (a
- * holder's leave that lost its rmdir) is removed and the rename tried
- * once more, as POSIX's rename onto it would replace it.
- */
-async function renameWin32(staging: string, lockDir: string): Promise<void> {
-  try {
-    await rename(staging, lockDir)
-    return
-  } catch (err) {
-    const code = (err as NodeJS.ErrnoException).code
-    if (code !== 'EPERM' && code !== 'EACCES') throw err
-    const empty = await rmdir(lockDir).then(
-      () => true,
-      () => false,
-    )
-    if (!empty) throw Object.assign(new Error('run lock taken'), { code: 'EEXIST' })
-  }
-  await rename(staging, lockDir).catch((err: NodeJS.ErrnoException) => {
-    if (err.code === 'EPERM' || err.code === 'EACCES') {
-      throw Object.assign(new Error('run lock taken'), { code: 'EEXIST' })
-    }
-    throw err
-  })
-}
-
 /**
  * Unlink one taking's entry, then the directory if that left it empty.
  * Gone already is not an error (another waiter reclaimed it first); a

package/src/orchestrator/sandbox-request.ts

@@ -193,7 +193,7 @@ export async function sandboxRequestFor(
   // character class, so vx's own workspace wall matched nothing (B-65).
   // A `*` or `?` is one too, and its grants matched the project's siblings.
   const home = toRealPath(node.projectDir)
-  if (process.platform !== 'win32' && /[[\]*?]/.test(home)) {
+  if (/[[\]*?]/.test(home)) {
     throw new UserError(
       `exec.sandbox: ${home} holds [, ], * or ?, which the sandbox runtime reads as a ` +
         `pattern, not a name — rename the directory, or run the task without exec.sandbox`,

package/src/util/real-path.ts

@@ -1,11 +1,8 @@
 import { realpathSync } from 'node:fs'
 
 /**
- * A path's canonical spelling. On Windows `realpathSync` keeps an 8.3
- * short name (`C:\Users\RUNNER~1\…`) where git, `fs.promises.realpath`
- * and every other reader say `runneradmin`, so one file had two
- * spellings and a key or a comparison that folds the path split on
- * them (O-16). The native call asks the OS for the final path.
+ * A path's canonical spelling: the OS's own answer for the final path,
+ * so a key or a comparison that folds the path sees one spelling (O-16).
  */
 export function realPath(p: string): string {
   return realpathSync.native(p)

package/src/util/which.ts

@@ -48,13 +48,8 @@ export function executablePath(name: string): string {
 }
 
 /**
- * The argv that runs `script` in the task shell: `sh -c` on Linux and
- * macOS, and Bun's own shell (`bun exec`) on Windows, which ships no `sh`
- * (docs/design/windows-2026-09.md § Decisions 1). Bun's shell reads the
- * same `&&`, `|`, `$(…)` and `VAR=x cmd` syntax that `bun run` uses there.
+ * The argv that runs `script` in the task shell: `sh -c`.
  */
 export function shellArgv(script: string): string[] {
-  return process.platform === 'win32'
-    ? [process.execPath, 'exec', script]
-    : [executablePath('sh'), '-c', script]
+  return [executablePath('sh'), '-c', script]
 }

package/src/workspace/config-cache.ts

@@ -545,6 +545,21 @@ export async function configEvalKeyFromClosure(a: {
   return h.toString(16).padStart(16, '0')
 }
 
+/** `configEvalKeyFromClosure` over identities already in hand; null when one is missing. */
+export function configEvalKeyFromIdentities(a: {
+  closure: readonly string[]
+  identities: ReadonlyMap<string, string>
+  workspaceFingerprint: string
+}): string | null {
+  let h = keySeed(a.workspaceFingerprint)
+  for (const file of a.closure) {
+    const id = a.identities.get(file)
+    if (id === undefined) return null
+    h = xxh3(`${file}\0${id}`, h)
+  }
+  return h.toString(16).padStart(16, '0')
+}
+
 /**
  * Every file a config imports by relative specifier, transitively, outside
  * `node_modules`, the config itself excluded. `vx watch` watches these: a

package/src/workspace/migrate-scripts.ts

@@ -343,6 +343,16 @@ function cdsToMembers(script: string, rootDir: string, memberDirs: readonly stri
   return false
 }
 
+/**
+ * The hooks a package's build hides in when it has no `build` script:
+ * react-navigation's twelve packages build in `prepack: bob build`, their
+ * root's `build` (`lerna run prepack`) runs the members and is left out,
+ * and the repo mapped with no build at all.
+ */
+const LIFECYCLE_BUILD_HOOKS = ['prepack', 'prepublishOnly', 'prepublish', 'prepare']
+const BUILDER =
+  /(?:^|[\s;&|(])(?:bob build|tsc|tsup|tsdown|rollup|vite build|babel|unbuild|esbuild|webpack|microbundle|pkgroll|bunchee|preconstruct build)(?:\s|$)/
+
 /** The workspace flags that move a package manager off the package it runs in. */
 const ELSEWHERE_FLAG = /^(-r|--recursive|--filter|-F|--workspaces|-ws|--workspace)(=|$)/
 const DIR_FLAG = /^(-C|--dir|--cwd|--prefix)(?:=(.*))?$/
@@ -481,6 +491,7 @@ export function migrateScripts(
   // and maps.
   const root = metas.length > 1 ? workspaceRootOf(metas) : undefined
   const notes: string[] = []
+  const lifecycleBuilds: [string, string, string][] = []
   // The rest check the whole repo (`lint: oxlint .`, `test: vitest`):
   // `vx run lint` found no project in remix, wagmi or element-plus. Such a
   // script maps onto the root, when the root has a name (vx skips a
@@ -585,6 +596,12 @@ export function migrateScripts(
       return why === null ? [] : [[n, why] as const]
     })
     const names = runnable.filter((n) => taskNameProblem(n) === null)
+    if (meta !== rootMeta && !('build' in scripts)) {
+      const hook = LIFECYCLE_BUILD_HOOKS.find(
+        (h) => typeof scripts[h] === 'string' && BUILDER.test(scripts[h] as string),
+      )
+      if (hook !== undefined) lifecycleBuilds.push([meta.name, hook, scripts[hook] as string])
+    }
     if (runnable.length === 0) continue
     const hasBuild = names.includes('build')
     const has = (n: string): boolean => names.includes(n)
@@ -681,6 +698,13 @@ export function migrateScripts(
       projects.push({ name: meta.name, dir: meta.dir, importLines, tasks })
     }
   }
+  if (lifecycleBuilds.length > 0) {
+    const [name, hook, command] = lifecycleBuilds[0]!
+    const more = lifecycleBuilds.length - 1
+    notes.push(
+      `${lifecycleBuilds.length === 1 ? 'a package builds' : `${lifecycleBuilds.length} packages build`} only in a lifecycle script (\`${hook}: ${command}\` in ${name}${more > 0 ? ` and ${more} more` : ''}), which the package manager runs on pack or install and vx never runs: add a \`build\` script running it and run \`vx init\` again`,
+    )
+  }
   breakBuildCycles(projects, metas)
   pruneOrphanPersistentNotes(projects, PERSISTENT_TODO)
   return {

package/src/workspace/migration.ts

@@ -402,10 +402,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
       for (const f of replaced) report.push(`  ${relPosix(root, f)}`)
     }
   }
-  const firstTask =
-    plan.projects.flatMap((p) => p.tasks.map((t) => t.name)).find((n) => n === 'build') ??
-    plan.projects[0]?.tasks[0]?.name ??
-    'build'
+  const firstTask = nextTask(plan.projects.flatMap((p) => p.tasks))
   // A run of tasks none of which caches is never a hit, and a first try
   // that runs twice to see the cache work saw it run twice.
   if (!cached && [...todos.keys()].some(isCacheTodo)) {
@@ -442,6 +439,25 @@ function inGitWorkTree(root: string): boolean {
   }
 }
 
+/** Names that change the repo or the world rather than check it. */
+const NOT_A_TRY = /^(clean|reset|nuke|release|publish|deploy|version|format|fix)(?:$|[:\-_.])/
+
+/**
+ * The task the `next:` line runs: `build`, else the first task that
+ * neither serves nor changes anything, else the first. react-navigation, whose
+ * packages build in `prepack`, was told `vx run clean --all` (D-105).
+ */
+function nextTask(tasks: readonly GeneratedTask[]): string {
+  const names = tasks.filter((t) => t.task !== null).map((t) => t.name)
+  const fit = tasks.find(
+    (t) =>
+      t.task !== null &&
+      !NOT_A_TRY.test(t.name) &&
+      (t.task['exec'] as { persistent?: unknown } | undefined)?.persistent === undefined,
+  )
+  return names.includes('build') ? 'build' : (fit?.name ?? names[0] ?? 'build')
+}
+
 /**
  * How the user runs vx, for the report's `next:` line. After `npx vx init`
  * or `bunx @vzn/vx init` a bare `vx` is on no PATH (the first-five-minutes

package/src/workspace/project-loader.ts

@@ -8,6 +8,7 @@ import { hasEsmExport, unprovidedBareImports } from './config-imports.js'
 import {
   configEvalKey,
   configEvalKeyFromClosure,
+  configEvalKeyFromIdentities,
   configImports,
   type ConfigEvalStore,
 } from './config-cache.js'
@@ -297,7 +298,7 @@ export interface LoadProjectConfigOptions {
  * order given, so a failure names the first broken file the way a
  * one-by-one load did). A single-path load is the one-element case.
  */
-const LOAD_WIDTH = 64
+const LOAD_WIDTH = 128
 
 export async function loadProjectConfigs(
   configPaths: readonly string[],
@@ -323,49 +324,69 @@ export async function loadProjectConfigs(
   // the map; a file the batch could not stat has no identity, which makes
   // that config's fast key miss and sends it down the slow path exactly as
   // a throwing per-file `hashFile` did.
-  let fastHashFile = hashFile
+  let identities: Map<string, string> | undefined
   if (closures.size > 0 && store?.hashFiles !== undefined) {
     const files = new Set<string>()
     for (const closure of closures.values()) for (const f of closure) files.add(f)
-    const identities = await store.hashFiles([...files])
-    fastHashFile = (file: string): Promise<string> => {
-      const id = identities.get(file)
-      return id === undefined
-        ? Promise.reject(new Error(`no identity for ${file}`))
-        : Promise.resolve(id)
-    }
+    identities = await store.hashFiles([...files])
+  }
+  // With the batch in hand a fast key is synchronous: an async key per
+  // config, awaiting identities already in the map, was ~5 ms of a
+  // 1,000-config warm load. Only a config off the fast path is awaited.
+  const fastKeyOf = (configPath: string): string | null => {
+    const closure = closures.get(configPath)
+    if (closure === undefined || evalCache === undefined || identities === undefined) return null
+    return configEvalKeyFromIdentities({
+      closure,
+      identities,
+      workspaceFingerprint: evalCache.workspaceFingerprint,
+    })
+  }
+  const fastHashFile = identities === undefined ? hashFile : undefined
+  interface Prepared {
+    configPath: string
+    bytes: Uint8Array | null
+    cacheKey: string | null
+    indexed: boolean
+    closure?: string[] | undefined
   }
   const prepared = await Promise.all(
-    configPaths.map(async (configPath) => {
-      const closure = closures.get(configPath)
-      if (closure !== undefined && evalCache !== undefined && fastHashFile !== undefined) {
-        const fastKey = await configEvalKeyFromClosure({
-          closure,
-          hashFile: fastHashFile,
-          workspaceFingerprint: evalCache.workspaceFingerprint,
-        })
-        if (fastKey !== null) return { configPath, bytes: null, cacheKey: fastKey, indexed: true }
-      }
-      const bytes = await Bun.file(configPath).bytes()
-      const keyed =
-        evalCache === undefined
-          ? null
-          : await configEvalKey({
-              configPath,
-              bytes,
-              workspaceRoot: evalCache.workspaceRoot,
-              workspaceFingerprint: evalCache.workspaceFingerprint,
-              ...slowKeyHash,
-            })
-      return {
-        configPath,
-        bytes,
-        cacheKey: keyed?.key ?? null,
-        indexed: false,
-        closure: keyed !== null && keyed.indexable ? keyed.closure : undefined,
-      }
+    configPaths.map((configPath): Prepared | Promise<Prepared> => {
+      const fastKey = fastKeyOf(configPath)
+      return fastKey !== null
+        ? { configPath, bytes: null, cacheKey: fastKey, indexed: true }
+        : slowPrepared(configPath)
     }),
   )
+  async function slowPrepared(configPath: string): Promise<Prepared> {
+    const closure = closures.get(configPath)
+    if (closure !== undefined && evalCache !== undefined && fastHashFile !== undefined) {
+      const fastKey = await configEvalKeyFromClosure({
+        closure,
+        hashFile: fastHashFile,
+        workspaceFingerprint: evalCache.workspaceFingerprint,
+      })
+      if (fastKey !== null) return { configPath, bytes: null, cacheKey: fastKey, indexed: true }
+    }
+    const bytes = await Bun.file(configPath).bytes()
+    const keyed =
+      evalCache === undefined
+        ? null
+        : await configEvalKey({
+            configPath,
+            bytes,
+            workspaceRoot: evalCache.workspaceRoot,
+            workspaceFingerprint: evalCache.workspaceFingerprint,
+            ...slowKeyHash,
+          })
+    return {
+      configPath,
+      bytes,
+      cacheKey: keyed?.key ?? null,
+      indexed: false,
+      closure: keyed !== null && keyed.indexable ? keyed.closure : undefined,
+    }
+  }
   let hits = new Map<string, string>()
   if (evalCache !== undefined) {
     const keys = prepared.map((p) => p.cacheKey).filter((k): k is string => k !== null)
@@ -462,7 +483,9 @@ export async function loadProjectConfigs(
   try {
     // Loaded LOAD_WIDTH at a time: one import after another put 1,000 cold
     // configs at ~160 ms of imports where 64 at once take ~60 (D-68), and
-    // the width bounds the files a module load may hold open. A failure
+    // 128 took `load configs` from 432 to 411 ms more; the width bounds the
+    // files a module load may hold open, so it stays under macOS's default
+    // 256-descriptor limit. A failure
     // stops nothing (the rest are evaluated and stored for the next
     // attempt); the error thrown is the first in order, as the serial
     // loop's was.