@vzn/vx 0.0.625 → 0.0.626

package/package.json

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

package/src/orchestrator/framed-output.ts

@@ -59,11 +59,15 @@ const ABORTED = '#f97316' // orange-500 — killed by a shutdown signal
 const LOCAL = '#38bdf8' // sky-400 — local cache hit
 const REMOTE = '#2563eb' // blue-600 — remote cache hit
 
+/** A piece of a task's output, as written: `err` for stderr. */
+export interface OutputChunk {
+  text: string
+  err: boolean
+}
+
 export interface TaskBlockBody {
-  /** stdout chunks accumulated during the task. Renders under `├─ stdout`. */
-  stdout?: string
-  /** stderr chunks. Renders under `├─ stderr`. */
-  stderr?: string
+  /** What the task wrote, in order. Renders under `├─ OUTPUT`, stderr lines marked. */
+  output?: readonly OutputChunk[]
   /**
    * Characters the capture dropped from the head of each stream. Non-zero
    * only for a task whose output is bounded (a persistent one — nothing
@@ -92,8 +96,7 @@ export function formatTaskBlock(
   // pass already make.
   if (isGroupTask(node)) return ''
 
-  const stdout = body.stdout ?? ''
-  const stderr = body.stderr ?? ''
+  const output = body.output ?? []
 
   const idPainted = paintTaskId(node, colors, { bold: true })
   const corner = (s: string) => paint('', s, colors, { dim: true })
@@ -110,8 +113,7 @@ export function formatTaskBlock(
     lines.push('', corner(`$ ${shownCommand(node, forwardArgs)}`), '')
   }
 
-  pushStreamSection(lines, stdout, 'STDOUT', SUCCESS, body.droppedStdout ?? 0, colors)
-  pushStreamSection(lines, stderr, 'STDERR', ERROR, body.droppedStderr ?? 0, colors)
+  pushOutputSection(lines, output, (body.droppedStdout ?? 0) + (body.droppedStderr ?? 0), colors)
 
   lines.push(...violationSection(outcome, colors))
 
@@ -141,6 +143,48 @@ function pushStreamSection(
   lines.push('')
 }
 
+/**
+ * The one `├─ OUTPUT` section: the task's lines in the order it wrote
+ * them, so an error stays beside what it is about (a test runner prints
+ * progress to stdout and the failure to stderr). A stderr line is red;
+ * without colour it is the task's bytes untouched. A line the task
+ * coloured itself keeps its own colours, since a reset inside it would
+ * end ours mid-line. A line takes the stream that began it.
+ */
+function pushOutputSection(
+  lines: string[],
+  output: readonly OutputChunk[],
+  lost: number,
+  colors: ColorSupport,
+): void {
+  if (output.every((c) => c.text.trim().length === 0)) return
+  lines.push(sectionLine('OUTPUT', '', colors), '')
+  if (lost > 0) {
+    lines.push(paint('', `… ${lost} earlier characters dropped`, colors, { dim: true }))
+  }
+  const body: Array<{ text: string; err: boolean }> = []
+  let open: { parts: string[]; err: boolean } | null = null
+  for (const c of output) {
+    let rest = c.text
+    while (rest.length > 0) {
+      const nl = rest.indexOf('\n')
+      const piece = nl < 0 ? rest : rest.slice(0, nl)
+      if (open === null) open = { parts: [], err: c.err }
+      open.parts.push(piece)
+      if (nl < 0) break
+      body.push({ text: open.parts.join(''), err: open.err })
+      open = null
+      rest = rest.slice(nl + 1)
+    }
+  }
+  if (open !== null) body.push({ text: open.parts.join(''), err: open.err })
+  for (const l of body) {
+    if (!l.err || !colors.enabled) lines.push(l.text)
+    else lines.push(l.text.includes('\x1b') ? l.text : paint(ERROR, l.text, colors))
+  }
+  lines.push('')
+}
+
 /**
  * Section labels are bold + state-colored (owner design): stdout green,
  * stderr red, sandbox yellow, command plain white — only the command
@@ -520,7 +564,9 @@ function isPersistentNode(node: TaskNode): boolean {
 export function formatPersistentTailBlock(
   node: TaskNode,
   outcome: TaskOutcome,
-  body: TaskBlockBody,
+  // Two bounded tails, one per stream: their order is lost, so the
+  // streams print apart.
+  body: { stdout?: string; stderr?: string },
   dropped: { stdout?: number; stderr?: number } = {},
   colors: ColorSupport = NO_COLOR,
   forwardArgs: readonly string[] = [],

package/src/orchestrator/logger.ts

@@ -11,6 +11,7 @@ import {
   flakyNote,
   formatTaskHitLine,
   formatTaskSkippedLine,
+  type OutputChunk,
 } from './framed-output.js'
 import {
   createOutputWriter,
@@ -210,8 +211,7 @@ export function defaultLogger(
   // appending via `+=`; concatenating N small chunks via `+=` is O(N²)
   // because each `+=` allocates a fresh string of the full accumulated
   // length. Bun-friendly: join('') is a single contiguous allocation.
-  const stdoutBuffers = new Map<string, string[]>()
-  const stderrBuffers = new Map<string, string[]>()
+  const outputBuffers = new Map<string, OutputChunk[]>()
   // Separator bookkeeping: blocks are blank-line-delimited on BOTH
   // sides — raw (unprefixed) frame content must never collide with a
   // neighbouring one-liner (owner feedback). A block leaves its own
@@ -222,16 +222,16 @@ export function defaultLogger(
   // True while the live stream sits mid-line (chunk without trailing
   // newline) — the frame close must not glue onto partial output.
   let streamMidLine = false
-  const pushChunk = (buffers: Map<string, string[]>, id: string, chunk: string): void => {
-    const arr = buffers.get(id)
-    if (arr) arr.push(chunk)
-    else buffers.set(id, [chunk])
+  const pushChunk = (id: string, text: string, err: boolean): void => {
+    const arr = outputBuffers.get(id)
+    if (arr) arr.push({ text, err })
+    else outputBuffers.set(id, [{ text, err }])
   }
-  const takeChunks = (buffers: Map<string, string[]>, id: string): string => {
-    const arr = buffers.get(id)
-    if (!arr) return ''
-    buffers.delete(id)
-    return arr.length === 1 ? arr[0]! : arr.join('')
+  const takeChunks = (id: string): OutputChunk[] => {
+    const arr = outputBuffers.get(id)
+    if (!arr) return []
+    outputBuffers.delete(id)
+    return arr
   }
 
   // `none` is the ONE mode whose contract guarantees the output is
@@ -682,7 +682,7 @@ export function defaultLogger(
         else appendTail(tail.out, chunk)
         return
       }
-      pushChunk(stdoutBuffers, node.id, chunk)
+      pushChunk(node.id, chunk, false)
     },
     taskStderr(node, chunk) {
       if (discardsOutput) return
@@ -698,7 +698,7 @@ export function defaultLogger(
         else appendTail(tail.err, chunk)
         return
       }
-      pushChunk(stderrBuffers, node.id, chunk)
+      pushChunk(node.id, chunk, true)
     },
     taskComplete(node, outcome) {
       if (!statusDead) finished.add(node.id)
@@ -707,8 +707,14 @@ export function defaultLogger(
       // there — carrying how much the cap dropped, since a truncated log
       // that reads as complete is worse than one that says what it lost.
       const preReady = persistentTails.get(node.id)
-      const stdout = preReady ? tailText(preReady.out) : takeChunks(stdoutBuffers, node.id)
-      const stderr = preReady ? tailText(preReady.err) : takeChunks(stderrBuffers, node.id)
+      // In the order the task wrote it; a bounded tail kept its streams
+      // apart, so its stdout reads first.
+      const output: OutputChunk[] = preReady
+        ? [
+            { text: tailText(preReady.out), err: false },
+            { text: tailText(preReady.err), err: true },
+          ]
+        : takeChunks(node.id)
       const dropped =
         preReady && (preReady.out.dropped > 0 || preReady.err.dropped > 0)
           ? { droppedStdout: preReady.out.dropped, droppedStderr: preReady.err.dropped }
@@ -745,16 +751,9 @@ export function defaultLogger(
           emitFrameClose(formatFrameClose(node, outcome, colors))
           return
         }
-        if (framed && (stdout.length > 0 || stderr.length > 0)) {
+        if (framed && output.some((c) => c.text.length > 0)) {
           emitBlock(
-            formatTaskBlock(
-              node,
-              outcome,
-              { stdout, stderr, ...dropped },
-              colors,
-              true,
-              forwardArgs,
-            ),
+            formatTaskBlock(node, outcome, { output, ...dropped }, colors, true, forwardArgs),
           )
           return
         }
@@ -847,14 +846,7 @@ export function defaultLogger(
           if (outcome.status !== 'failed') return
           emitLine(failureRow(node, outcome))
           deferredFailures.push(
-            formatTaskBlock(
-              node,
-              outcome,
-              { stdout, stderr, ...dropped },
-              colors,
-              false,
-              forwardArgs,
-            ),
+            formatTaskBlock(node, outcome, { output, ...dropped }, colors, false, forwardArgs),
           )
           return
         case 'broad':
@@ -866,14 +858,7 @@ export function defaultLogger(
             // ◼ row now; the full frame replays at runEnd.
             emitLine(failureRow(node, outcome))
             deferredFailures.push(
-              formatTaskBlock(
-                node,
-                outcome,
-                { stdout, stderr, ...dropped },
-                colors,
-                false,
-                forwardArgs,
-              ),
+              formatTaskBlock(node, outcome, { output, ...dropped }, colors, false, forwardArgs),
             )
           } else if (outcome.status === 'success') {
             emitLine(formatTaskExecutedLine(node, outcome, colors))
@@ -910,28 +895,14 @@ export function defaultLogger(
             if (outcome.status === 'failed') {
               emitLine(failureRow(node, outcome))
               deferredFailures.push(
-                formatTaskBlock(
-                  node,
-                  outcome,
-                  { stdout, stderr, ...dropped },
-                  colors,
-                  false,
-                  forwardArgs,
-                ),
+                formatTaskBlock(node, outcome, { output, ...dropped }, colors, false, forwardArgs),
               )
               return
             }
             // forceCommand: a requested task's frame shows `$ cmd`
             // whether it ran or was cached — same frame every run.
             emitBlock(
-              formatTaskBlock(
-                node,
-                outcome,
-                { stdout, stderr, ...dropped },
-                colors,
-                true,
-                forwardArgs,
-              ),
+              formatTaskBlock(node, outcome, { output, ...dropped }, colors, true, forwardArgs),
             )
             return
           }
@@ -942,14 +913,7 @@ export function defaultLogger(
           } else if (outcome.status === 'failed') {
             emitLine(failureRow(node, outcome))
             deferredFailures.push(
-              formatTaskBlock(
-                node,
-                outcome,
-                { stdout, stderr, ...dropped },
-                colors,
-                false,
-                forwardArgs,
-              ),
+              formatTaskBlock(node, outcome, { output, ...dropped }, colors, false, forwardArgs),
             )
           }
           return
@@ -960,7 +924,7 @@ export function defaultLogger(
           // replayed stdout keep their frame (the output is the
           // point); misses/failures are always framed. One-liners
           // stay outside ::group:: — there's nothing to collapse.
-          if (isHit && stdout.trim().length === 0 && stderr.trim().length === 0) {
+          if (isHit && output.every((c) => c.text.trim().length === 0)) {
             emitLine(formatTaskHitLine(node, outcome, colors))
             return
           }
@@ -971,7 +935,7 @@ export function defaultLogger(
           const block = formatTaskBlock(
             node,
             outcome,
-            { stdout, stderr, ...dropped },
+            { output, ...dropped },
             colors,
             false,
             forwardArgs,