@vzn/vx 0.0.650 → 0.0.652

package/src/report/index.ts

@@ -30,9 +30,14 @@ export {
   resolveOutputView,
   warnOf,
 } from './logger.js'
-export { formatPersistentList } from './framed-output.js'
-export { blocksCounts, createForecast } from './forecast.js'
-export { fileLocations, fileMemo, type OutputLocation } from './path-links.js'
+export {
+  formatPersistentList,
+  formatRecordedRow,
+  planList,
+  type PlannedRow,
+  taskList,
+} from './framed-output.js'
+export { createForecast } from './forecast.js'
 export { plainOutput } from './plain-output.js'
 export type { LiveUsage } from './status-line.js'
 export { formatOutcomeTable, formatRunSummary } from './summary.js'

package/src/report/logger.ts

@@ -6,26 +6,22 @@ import {
   formatKeptLines,
   formatPersistentTailBlock,
   formatListHeader,
+  usualCell,
   formatTaskAbortedLine,
   formatTaskBlock,
   executedCells,
-  waited,
   formatTaskExecutedLine,
   flakyNote,
   pathNote,
   formatTaskHashLine,
   formatTaskHitLine,
   formatTaskSkippedLine,
-  leavesStyle,
-  RESET,
   type OutputChunk,
 } from './framed-output.js'
 import {
-  createOutputWriter,
   formatFailureLine,
   formatStatusRegion,
   formatStepLine,
-  type StatusStream,
   type WorkerSlot,
 } from './status-line.js'
 import {
@@ -44,21 +40,26 @@ import {
   resetTail,
   tailText,
   type Tail,
-  detectColors,
   envFlagOn,
-  type ColorSupport,
-  ui,
 } from '../util/index.js'
-import { isCacheHit } from '../graph/index.js'
-import { failedLabel, outcomeWord, ranNoCache } from './events.js'
-import type { BlockedTask, Forecast } from './forecast.js'
+import * as ui from '../ui/index.js'
 import {
+  createOutputWriter,
+  detectColors,
+  hasEscape,
+  leavesStyle,
   notifyEscape,
   PROGRESS_CLEAR,
   progressEscape,
+  STYLE_END,
   terminalLinks,
   terminalSignals,
-} from './terminal-signals.js'
+  type ColorSupport,
+  type StatusStream,
+} from '../ui/index.js'
+import { isCacheHit } from '../graph/index.js'
+import { failedLabel, outcomeWord, ranNoCache } from './events.js'
+import type { BlockedTask, Forecast } from './forecast.js'
 
 export interface Logger {
   /** Header / footer / status text. Written verbatim, one trailing \n added. */
@@ -92,8 +93,7 @@ export interface Logger {
     /** The run's canonical start (epoch ms) — equals the final summary's `startedAt`. */
     startedAtMs?: number
   }): void
-  /** `waitedMs`: how long it waited ready for a slot, when not started at once. */
-  taskStart?(node: TaskNode, info?: { waitedMs?: number }): void
+  taskStart?(node: TaskNode): void
   /** The task graph finished (any outcome); vx's own closing steps follow. Idempotent. */
   runEnd?(): void
   /**
@@ -355,9 +355,7 @@ export function defaultLogger(
   // Tasks the region showed on the critical path: their finished rows say so too.
   const onPath = new Set<string>()
   let blockedCount = 0
-  let expected: ReadonlyMap<string, number> | undefined
   // Each task's usual time once history is read: the results' `±usual`.
-  let usualOf: ReadonlyMap<string, number> | undefined
   let blocked: readonly BlockedTask[] | undefined
   let blockedBy: ReadonlyMap<string, number> | undefined
   let etaAtMs = 0
@@ -375,7 +373,7 @@ export function defaultLogger(
   let slots: (WorkerSlot | null)[] = []
   const slotQueue: WorkerSlot[] = []
   let succeeded = 0
-  // Executed with no `cache` block: never a miss, counted apart.
+  // Executed without `cache: true`: never a miss, counted apart.
   let noCache = 0
   let upToDate = 0
   let restoredLocal = 0
@@ -522,10 +520,8 @@ export function defaultLogger(
             : Math.min(deadlineMs ?? now, now)
       critical = f.critical
       blockedCount = f.waiting
-      expected = f.expected
       blocked = f.blocked
       blockedBy = f.blockedBy
-      usualOf = f.usual
     }
     const etaMs = deadlineMs === undefined ? undefined : deadlineMs - now
     if (signals.progress && total > 0) {
@@ -610,7 +606,7 @@ export function defaultLogger(
         summaryLines,
         ...(runContext?.whereRunning !== undefined ? { where: runContext.whereRunning } : {}),
         ...(runContext?.usage !== undefined ? { usage: runContext.usage } : {}),
-        ...(expected !== undefined ? { expected } : {}),
+        ...(runContext?.usual !== undefined ? { usual: runContext.usual } : {}),
         ...(critical !== undefined ? { critical } : {}),
       },
       colors,
@@ -660,7 +656,7 @@ export function defaultLogger(
   // task`, and took its colour.
   let streamStyled = false
   const endStreamLine = (): void => {
-    const end = (streamStyled ? RESET : '') + (streamMidLine ? '\n' : '')
+    const end = (streamStyled ? STYLE_END : '') + (streamMidLine ? '\n' : '')
     streamStyled = false
     streamMidLine = false
     if (end.length > 0) logWrite(end)
@@ -672,10 +668,11 @@ export function defaultLogger(
   const streamWrite = (chunk: string): void => {
     streamedSinceBlock = true
     if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
-    if (chunk.includes('\x1b[')) streamStyled = leavesStyle(chunk)
+    if (hasEscape(chunk)) streamStyled = leavesStyle(chunk)
     logWrite(chunk)
   }
   const logWrite = (chunk: string): void => {
+    if (panelOpen !== undefined && !inPanel && chunk.length > 0) closePanel()
     if (chunk.length > 0) endsBlank = chunk.endsWith('\n\n')
     if (!logOpened && chunk.length > 0) {
       logOpened = true
@@ -688,15 +685,33 @@ export function defaultLogger(
     taskWrite(`${line}\n`)
     lineEmitted = true
   }
-  // The list's header, once over its first row, where the live region
-  // heads its own rows the same way (2026-10-21).
-  let headed = !writer.enabled
+  // The open panel: rows of one kind share one box, the Tasks list on the
+  // log's stream and the Warnings on stderr; anything else said closes it
+  // first, and the next row opens it again. Painted, a box; plain on a
+  // terminal, the Tasks rule and header over the rows, as the live region
+  // heads its own (2026-10-21); piped, the bare rows a script reads.
+  const panels = colors.enabled || writer.enabled
+  let panelOpen: 'Tasks' | 'Warnings' | undefined
+  let inPanel = false
+  function closePanel(): void {
+    const was = panelOpen
+    if (was === undefined) return
+    panelOpen = undefined
+  }
   const emitRow = (line: string): void => {
-    if (!headed) {
-      headed = true
+    if (!panels) {
+      emitLine(line)
+      return
+    }
+    if (panelOpen === 'Warnings') closePanel()
+    inPanel = true
+    if (panelOpen !== 'Tasks') {
+      emitLine(ui.panelTop('Tasks', colors))
       emitLine(formatListHeader(colors))
+      panelOpen = 'Tasks'
     }
     emitLine(line)
+    inPanel = false
   }
   // formatTaskBlock returns '' for group tasks (no exec) — skip the
   // write so a stray newline doesn't sneak into the output.
@@ -739,14 +754,14 @@ export function defaultLogger(
 
   // How many tasks are downstream of each: every results row's `blocks`.
   const blocksOf = (id: string): number | undefined => runContext?.blocks?.().get(id)
+  // A row's usual time: null for a task history never timed, undefined with no history to ask.
+  const usualMsOf = (id: string): number | null | undefined =>
+    runContext?.usual === undefined ? undefined : (runContext.usual(id) ?? null)
   const failureRow = (node: TaskNode, outcome: TaskOutcome): string =>
-    formatFailureLine(
-      node.id,
-      outcome.durationMs,
-      colors,
-      cacheWordOf(outcome),
-      executedCells(outcome, blocksOf(node.id)),
-    ) +
+    formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(outcome), {
+      ...executedCells(outcome, blocksOf(node.id)),
+      usual: usualCell(outcome.durationMs, usualMsOf(node.id), colors),
+    }) +
     (onPath.has(node.id) ? pathNote(colors) : '') +
     flakyNote(outcome, colors)
 
@@ -764,6 +779,7 @@ export function defaultLogger(
       // A live-streamed server keeps writing after its frame closes, so a
       // summary row or "exited with code" can follow its partial line.
       endStreamLine()
+      closePanel()
       if (line === '' && endsBlank) return
       endsBlank = line === ''
       writer.write(`${line}\n`)
@@ -771,7 +787,20 @@ export function defaultLogger(
     warn(line) {
       flushKept()
       endStreamLine()
-      writer.writeTo(errOut, `${ui.tagged('warn', line, colors)}\n`)
+      if (!colors.enabled) {
+        writer.writeTo(errOut, `${ui.tagged('warn', line, colors)}\n`)
+        return
+      }
+      if (panelOpen === 'Tasks') closePanel()
+      if (panelOpen !== 'Warnings') {
+        writer.writeTo(errOut, `${ui.panelTop('Warnings', colors)}\n`)
+        panelOpen = 'Warnings'
+      }
+      const rows = line
+        .replace(/\n+$/, '')
+        .split('\n')
+        .map((l) => ui.tagged('warn', l, colors))
+      writer.writeTo(errOut, `${rows.join('\n')}\n`)
     },
     runStart(info) {
       total = info.total
@@ -779,7 +808,13 @@ export function defaultLogger(
       runContext = info.context
       startedAtMs = Date.now()
       started = true
-      slots = Array.from({ length: Math.max(1, info.concurrency ?? 10) }, () => null)
+      // No more slots than tasks: one per allowed worker, every frame walked
+      // them all (`--concurrency=100000000` over six tasks took 80 s, and
+      // 2^32 threw here).
+      slots = Array.from(
+        { length: Math.max(1, Math.min(info.concurrency ?? 10, info.total)) },
+        () => null,
+      )
       tick()
       refresh(true)
     },
@@ -811,7 +846,7 @@ export function defaultLogger(
       tail = false
       killStatus()
     },
-    taskStart(node, info) {
+    taskStart(node) {
       if (isGroupTask(node)) return
       if (holdsTerminal(node)) {
         killStatus()
@@ -837,7 +872,6 @@ export function defaultLogger(
         id: node.id,
         startedMs: Date.now(),
         cache: ranNoCache({ node }) ? 'no-cache' : 'miss',
-        ...(waited(info?.waitedMs) ? { waitedMs: info!.waitedMs! } : {}),
       }
       const free = slots.indexOf(null)
       if (free >= 0) slots[free] = slot
@@ -930,6 +964,7 @@ export function defaultLogger(
         flushedFailures = true
         for (const block of deferredFailures) emitBlock(fenced(block))
       }
+      closePanel()
       // The summary and the CLI's own lines follow on the stream directly:
       // nothing may still be held, and nothing after this is.
       writer.settle()
@@ -1161,7 +1196,7 @@ export function defaultLogger(
                 colors,
                 onPath.has(node.id),
                 blocksOf(node.id),
-                usualOf?.get(node.id),
+                usualMsOf(node.id),
               ),
             )
           } else if (outcome.status === 'skipped') {

package/src/report/plain-output.ts

@@ -42,7 +42,7 @@ export function plainOutput(sink: Logger): Logger {
     status: (line) => sink.status(line),
     ...(sink.warn && { warn: (line) => sink.warn!(line) }),
     ...(sink.runStart && { runStart: (info) => sink.runStart!(info) }),
-    ...(sink.taskStart && { taskStart: (node, info) => sink.taskStart!(node, info) }),
+    ...(sink.taskStart && { taskStart: (node) => sink.taskStart!(node) }),
     ...(sink.runEnd && { runEnd: () => sink.runEnd!() }),
     ...(sink.stepStart && { stepStart: (id) => sink.stepStart!(id) }),
     ...(sink.stepEnd && { stepEnd: (id, info) => sink.stepEnd!(id, info) }),
@@ -57,6 +57,8 @@ export function plainOutput(sink: Logger): Logger {
       if (text !== '' || chunk === '') sink.taskStderr(node, text)
     },
     taskComplete(node, outcome) {
+      // Nearly every task ends with no escape held: its keys go unbuilt.
+      if (held.size === 0) return sink.taskComplete(node, outcome)
       flush(node, `${node.id}\0out`, (n, c) => sink.taskStdout(n, c))
       flush(node, `${node.id}\0err`, (n, c) => sink.taskStderr(n, c))
       sink.taskComplete(node, outcome)