@vzn/vx 0.0.495 → 0.0.498

package/README.md

@@ -18,16 +18,14 @@
 
 <!-- bench:start — generated by packages/vx-bench/update-site.ts from results.json; do not hand-edit -->
 
-| 1,090 packages, 3,270 tasks      | vx         | Turborepo                  | Nx                       |
-| -------------------------------- | ---------- | -------------------------- | ------------------------ |
-| Cold build: time the runner adds | **9 s**    | 1 min 35 s (vx 91% faster) | 31 min (vx 99% faster)   |
-| Cold build: CPU burned           | **34 s**   | 1 min 13 s (vx 53% faster) | 114 min (vx 99% faster)  |
-| Fully cached run                 | **476 ms** | 760 ms (vx 37% faster)     | 3.59 s (vx 86% faster)   |
-| Overhead per package             | **8 ms**   | 88 ms (vx 91% faster)      | 1,712 ms (vx 99% faster) |
-
-vx N% faster: vx takes N% less time than that tool (1 − vx ÷ theirs); N% slower: N% more (vx ÷ theirs − 1).
-
-Nx's column ran every task through npm run (~200 ms of CPU each; Turbo ran bun run), a harness fault since fixed; with bun, on a 4-core Linux box, Nx took 6m 59s cold and 4.50 s fully cached (vx 47% and 92% faster).
+| 1,090 packages, 3,270 tasks      | vx         | Turborepo                  | Nx                     |
+| -------------------------------- | ---------- | -------------------------- | ---------------------- |
+| Cold build: time the runner adds | **2 s**    | 1 min 21 s (vx 34× faster) | 11 s (vx 4.7× faster)  |
+| Cold build: CPU burned           | **17 s**   | 21 s (vx 1.2× faster)      | 52 s (vx 3× faster)    |
+| Fully cached run                 | **393 ms** | 463 ms (vx 1.1× faster)    | 6.45 s (vx 16× faster) |
+| Overhead per package             | **2 ms**   | 74 ms (vx 34× faster)      | 10 ms (vx 4.7× faster) |
+
+vx N× faster: that tool takes N times as long as vx (theirs ÷ vx); N× slower: vx takes N times as long (vx ÷ theirs).
 
 Time added is the wall time over the tasks' own ideal schedule (3 min 38 s).
 Same graph, commands and concurrency: [how it is measured](https://vznjs.github.io/vx/benchmarks/).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.495",
+  "version": "0.0.498",
   "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.495",
-    "@vzn/vx-linux-arm64": "0.0.495",
-    "@vzn/vx-darwin-x64": "0.0.495",
-    "@vzn/vx-darwin-arm64": "0.0.495"
+    "@vzn/vx-linux-x64": "0.0.498",
+    "@vzn/vx-linux-arm64": "0.0.498",
+    "@vzn/vx-darwin-x64": "0.0.498",
+    "@vzn/vx-darwin-arm64": "0.0.498"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/exec/sandbox-runtime.ts

@@ -991,7 +991,16 @@ export function resolveSandboxConfig(
       (a.write ?? []).map((p) => {
         const real = resolve(p)
         assertWriteStaysHome(p, real, projectDir)
-        return real
+        // A directory a write glob matches is writable whole, as Linux's
+        // bind of the hit makes it: `<glob>/**` collapses below into the
+        // glob and its subtree. SRT compiles a glob as an exact regex, so
+        // `/tmp/pnpm-store-operation-locks-*/` covered the directory and
+        // not the lock file pnpm 12 opens inside it.
+        return process.platform !== 'linux' &&
+          !isMountableLiteral(real) &&
+          !/\/\*\*(?:\/\*)?$/.test(real)
+          ? `${real}/**`
+          : real
       }),
       walls,
       pending,

package/src/graph/scheduler.ts

@@ -195,7 +195,7 @@ export interface ScheduleOptions {
   /**
    * Where the line naming a rejected `execute` goes, before its failed
    * outcome lands. Absent = stderr. The run gives it the task's own
-   * stderr, so its frame and the failure recap carry the reason.
+   * stderr, so its frame carries the reason.
    */
   onError?: (node: TaskNode, line: string) => void
   /**

package/src/orchestrator/framed-output.ts

@@ -30,7 +30,6 @@ import { maskedCommand } from '../util/index.js'
 import { paint, type ColorSupport } from './colors.js'
 import { formatDuration } from './summary.js'
 import { outcomeLabel, skippedReason } from './events.js'
-import type { RecapTail } from './failure-recap.js'
 
 const NO_COLOR: ColorSupport = { enabled: false }
 
@@ -498,60 +497,6 @@ export function formatPersistentList(
   )
 }
 
-/** One failed task's section of the end-of-run recap. */
-export interface RecapEntry {
-  node: TaskNode
-  outcome: TaskOutcome
-  tail: RecapTail
-  /** Characters a bounded capture (a persistent task's) dropped before the tail saw them. */
-  droppedChars: number
-}
-
-/**
- * The run's last block: each failed task's last lines, under the failure's
- * label, then the ids of the failures past the tail limit. The lines are
- * raw, like a frame's, and `fence` wraps them where a task's text could be
- * read as something other than text (GitHub Actions' workflow commands).
- */
-export function formatFailureRecap(
-  entries: readonly RecapEntry[],
-  more: readonly string[],
-  colors: ColorSupport = NO_COLOR,
-  fence: (lines: string[]) => string[] = (lines) => lines,
-): string[] {
-  const total = entries.length + more.length
-  const dim = (s: string) => paint('', s, colors, { dim: true })
-  const lines = [
-    '',
-    `  Failed:   ${total} task${total === 1 ? '' : 's'} — the last lines ${total === 1 ? 'it' : 'each one'} printed`,
-  ]
-  for (const e of entries) {
-    lines.push(
-      '',
-      `  ${paint(ERROR, '◼︎', colors)} ${paintTaskId(e.node, colors, { bold: true })} ${dim('—')} ${paint(ERROR, outcomeLabel(e.outcome), colors, { bold: true })}`,
-    )
-    const cut: string[] = []
-    const { earlierLines, cutBytes } = e.tail
-    if (earlierLines > 0)
-      cut.push(`${count(earlierLines)} earlier line${earlierLines === 1 ? '' : 's'}`)
-    if (cutBytes > 0) cut.push(`${count(cutBytes)} bytes cut from the start of the line below`)
-    if (e.droppedChars > 0) {
-      cut.push(`the capture dropped ${count(e.droppedChars)} characters of the task's output`)
-    }
-    if (cut.length > 0) lines.push(dim(`  … ${cut.join(', and ')}`))
-    if (e.tail.text.length === 0) lines.push(dim('  (no output)'))
-    else lines.push(...fence(e.tail.text.split('\n')))
-  }
-  if (more.length > 0) {
-    lines.push('', `  … and ${more.length} more failed: ${more.join(', ')}`)
-  }
-  return lines
-}
-
-function count(n: number): string {
-  return n.toLocaleString('en-US')
-}
-
 function formatBlockHeader(o: TaskOutcome, colors: ColorSupport): string {
   const shortHash = o.hash ? o.hash.slice(0, 8) : ''
   const dim = (s: string) => paint('', s, colors, { dim: true })

package/src/orchestrator/logger.ts

@@ -1,7 +1,6 @@
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
 import { detectColors, type ColorSupport } from './colors.js'
 import {
-  formatFailureRecap,
   formatFrameClose,
   formatFrameOpen,
   formatKeptLines,
@@ -10,15 +9,7 @@ import {
   formatTaskExecutedLine,
   formatTaskHitLine,
   formatTaskSkippedLine,
-  type RecapEntry,
 } from './framed-output.js'
-import {
-  appendRecapRing,
-  createRecapRing,
-  RECAP_TASKS,
-  recapTail,
-  type RecapRing,
-} from './failure-recap.js'
 import {
   createOutputWriter,
   formatFailureLine,
@@ -63,13 +54,8 @@ export interface Logger {
   runEnd?(): void
 }
 
-/** The logger `run()` builds when none is passed, and the one that owns the recap. */
+/** The logger `run()` builds when none is passed. */
 export interface DefaultLogger extends Logger {
-  /**
-   * The run's last block: each failed task's last lines (item 706). Empty
-   * when nothing failed, and in the modes that promise no task output.
-   */
-  failureRecap(): string[]
   /**
    * Hand over any output still coalesced, and write straight through from
    * now on. `runEnd` does it; the run's own `finally` does it again for a
@@ -352,13 +338,6 @@ export function defaultLogger(
   }
   const printsKept = (tail: { outcome?: TaskOutcome }): boolean =>
     flushedPersistent && tail.outcome !== undefined && view.mode !== 'errors-only'
-  // The recap's material, decided at each failure so nothing is held for a
-  // task that passed. A buffered task's tail is read off the buffers the
-  // frame drains; a live-streamed one keeps no buffer, so a bounded ring
-  // follows it from its frame-open until its outcome.
-  const recapEntries: RecapEntry[] = []
-  const recapMore: string[] = []
-  const liveRings = new Map<string, RecapRing>()
 
   const refresh = (force: boolean): void => {
     if (statusDead) return
@@ -457,20 +436,6 @@ export function defaultLogger(
       flushKept()
       writer.settle()
     },
-    failureRecap() {
-      if (recapEntries.length === 0) return []
-      // Fenced like a frame: a tail is the task's own text, and a line of it
-      // must not become a workflow command. Never inside a group, so it reads
-      // with every group collapsed.
-      const fence =
-        view.gha === true
-          ? (lines: string[]) =>
-              ghaFence(`${lines.join('\n')}\n`, ghaToken)
-                .slice(0, -1)
-                .split('\n')
-          : undefined
-      return formatFailureRecap(recapEntries, recapMore, colors, fence)
-    },
     status(line) {
       writer.write(`${line}\n`)
     },
@@ -508,7 +473,6 @@ export function defaultLogger(
         // Open the live frame: full task info even when the command
         // streams nothing (or the hit replays nothing).
         emitLine(formatFrameOpen(node, colors))
-        liveRings.set(node.id, createRecapRing())
         return
       }
       // Bound a persistent task's output from its FIRST chunk. Waiting for
@@ -578,8 +542,6 @@ export function defaultLogger(
         streamedSinceBlock = true
         if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
         writer.write(chunk)
-        const ring = liveRings.get(node.id)
-        if (ring !== undefined) appendRecapRing(ring, chunk)
         return
       }
       const tail = persistentTails.get(node.id)
@@ -596,8 +558,6 @@ export function defaultLogger(
         streamedSinceBlock = true
         if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
         writer.write(chunk)
-        const ring = liveRings.get(node.id)
-        if (ring !== undefined) appendRecapRing(ring, chunk)
         return
       }
       const tail = persistentTails.get(node.id)
@@ -623,28 +583,6 @@ export function defaultLogger(
       // The pre-ready window closed either way: a failed task is over, and
       // a ready one starts a fresh post-ready tail below.
       persistentTails.delete(node.id)
-      const liveRing = liveRings.get(node.id)
-      liveRings.delete(node.id)
-      if (outcome.status === 'failed' && !discardsOutput) {
-        if (recapEntries.length === RECAP_TASKS) recapMore.push(node.id)
-        else {
-          let ring = liveRing
-          if (ring === undefined) {
-            ring = createRecapRing()
-            appendRecapRing(ring, stdout)
-            if (stdout.length > 0 && stderr.length > 0 && !stdout.endsWith('\n')) {
-              appendRecapRing(ring, '\n')
-            }
-            appendRecapRing(ring, stderr)
-          }
-          recapEntries.push({
-            node,
-            outcome,
-            tail: recapTail(ring),
-            droppedChars: (preReady?.out.dropped ?? 0) + (preReady?.err.dropped ?? 0),
-          })
-        }
-      }
       // An aborted task (child killed by a shutdown signal) reverts
       // to pending: free its worker slot, but never count or render it
       // — the run is tearing down and it has no honest outcome.

package/src/orchestrator/run.ts

@@ -319,7 +319,7 @@ export async function run(options: RunOptions): Promise<RunSummary> {
   }
   let held = false
   try {
-    const summary = await runOnBus(options, bus, colors, () => terminal?.failureRecap() ?? [])
+    const summary = await runOnBus(options, bus, colors)
     if (summary.persistent === undefined) return summary
     // Servers handed back still running still write: `vx watch dev` printed
     // none of its server's log while it idled, the renderer gone with this
@@ -342,7 +342,6 @@ async function runOnBus(
   options: RunOptions,
   bus: EventBus,
   colors: ColorSupport,
-  failureRecap: () => string[],
 ): Promise<RunSummary> {
   const log = busLogger(bus)
 
@@ -1094,8 +1093,6 @@ async function runOnBus(
         `  Deferred: ${stillDeferred.length} task(s) left outputs remote (--download=none): ${stillDeferred.join(', ')}`,
       )
     }
-    // Last, where a long log's reader lands: each failure's own last lines.
-    for (const line of failureRecap()) log.status(line)
 
     // Optional artifacts. Errors are surfaced to the user but don't
     // change the run's exit code — the run already happened.

package/src/orchestrator/failure-recap.ts

@@ -1,121 +0,0 @@
-// The end of each failed task's output, kept for the run's last lines
-// (item 706). A failure's frame prints when the task finishes, which in a
-// long CI log is thousands of lines above the end, and GitHub's API returns
-// only a job log's last 5,000 lines: the summary is the one place a reader
-// reliably looks, so the failure's own words are repeated there.
-//
-// The capture is a ring over the output's END: it keeps at most
-// RECAP_TASK_BYTES characters (and a newline) however much a task prints,
-// and counts what it evicts, so the recap can say how much it is not
-// showing.
-
-/** Lines of each failed task's output the recap repeats. */
-const RECAP_LINES = 30
-/** The byte cap on one task's repeated lines. */
-const RECAP_TASK_BYTES = 8 * 1024
-/**
- * Tasks that get a tail; the rest are named by id. Five tails at the
- * per-task cap is 40 KiB, so the recap stays under 64 KiB with no cap
- * of its own.
- */
-export const RECAP_TASKS = 5
-
-export interface RecapRing {
-  chunks: string[]
-  chars: number
-  /** Newlines evicted from the head. */
-  cutLines: number
-  /** Bytes evicted from the line the kept text starts with; 0 when it starts a line. */
-  cutPartialBytes: number
-}
-
-export interface RecapTail {
-  /** The last lines, at most RECAP_LINES of them and RECAP_TASK_BYTES bytes. */
-  text: string
-  /** Whole lines above `text`. */
-  earlierLines: number
-  /** Bytes cut from the start of `text`'s first line. */
-  cutBytes: number
-}
-
-export function createRecapRing(): RecapRing {
-  return { chunks: [], chars: 0, cutLines: 0, cutPartialBytes: 0 }
-}
-
-// The ring counts characters, the cap bytes: a UTF-16 unit is at least one
-// UTF-8 byte, so the last RECAP_TASK_BYTES characters always hold the last
-// RECAP_TASK_BYTES bytes. One more for the final newline the tail drops.
-const RING_CHARS = RECAP_TASK_BYTES + 1
-
-export function appendRecapRing(r: RecapRing, chunk: string): void {
-  if (chunk.length === 0) return
-  r.chunks.push(chunk)
-  r.chars += chunk.length
-  // A whole chunk goes only when what follows it still fills the ring:
-  // evicting past the cap would leave the recap fewer lines than it shows.
-  while (r.chunks.length > 1 && r.chars - r.chunks[0]!.length >= RING_CHARS) {
-    const gone = r.chunks.shift()!
-    r.chars -= gone.length
-    evict(r, gone, gone.length)
-  }
-  if (r.chars > RING_CHARS) {
-    const head = r.chunks[0]!
-    const at = r.chars - RING_CHARS
-    evict(r, head, at)
-    r.chunks[0] = head.slice(at)
-    r.chars = RING_CHARS
-  }
-}
-
-function evict(r: RecapRing, s: string, end: number): void {
-  const last = s.lastIndexOf('\n', end - 1)
-  const partial = Buffer.byteLength(s.slice(last + 1, end))
-  if (last < 0) {
-    r.cutPartialBytes += partial
-    return
-  }
-  r.cutLines += countNewlines(s, last + 1)
-  r.cutPartialBytes = partial
-}
-
-function countNewlines(s: string, end: number): number {
-  let n = 0
-  for (let i = s.indexOf('\n'); i !== -1 && i < end; i = s.indexOf('\n', i + 1)) n++
-  return n
-}
-
-/**
- * The recap's view of what the ring kept: its last RECAP_LINES lines, then
- * its last RECAP_TASK_BYTES bytes (cut on a character boundary). The text
- * is a fresh copy, so it holds nothing of the chunks it came from.
- */
-export function recapTail(r: RecapRing): RecapTail {
-  const t = r.chunks.join('')
-  const end = t.endsWith('\n') ? t.length - 1 : t.length
-  let start = 0
-  for (let pos = end, taken = 1; ; pos = start - 1, taken++) {
-    const nl = pos === 0 ? -1 : t.lastIndexOf('\n', pos - 1)
-    if (nl < 0) {
-      start = 0
-      break
-    }
-    start = nl + 1
-    if (taken === RECAP_LINES) break
-  }
-  let earlierLines = r.cutLines + countNewlines(t, start)
-  let cutBytes = start === 0 ? r.cutPartialBytes : 0
-  const bytes = Buffer.from(t.slice(start, end), 'utf8')
-  if (bytes.length <= RECAP_TASK_BYTES)
-    return { text: bytes.toString('utf8'), earlierLines, cutBytes }
-  let at = bytes.length - RECAP_TASK_BYTES
-  while ((bytes[at]! & 0xc0) === 0x80) at++
-  const lastNl = bytes.lastIndexOf(0x0a, at - 1)
-  if (lastNl < 0) cutBytes += at
-  else {
-    for (let i = bytes.indexOf(0x0a); i !== -1 && i <= lastNl; i = bytes.indexOf(0x0a, i + 1)) {
-      earlierLines++
-    }
-    cutBytes = at - lastNl - 1
-  }
-  return { text: bytes.subarray(at).toString('utf8'), earlierLines, cutBytes }
-}