@vzn/vx 0.0.645 → 0.0.648

package/src/report/path-links.ts

@@ -6,12 +6,19 @@
 
 import { statSync } from 'node:fs'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 
 // `src/a.ts`, `./a.ts:12`, `/abs/a.ts:12:5`, tsc's `src/a.ts(12,5)`. Not
 // after a word, dot, slash or `@`, so a URL's path or a scoped name's tail
-// never starts a match. Groups: file, then line and column of either form.
-const PATH =
-  /(?<![\w./@+-])((?:\/|\.{1,2}\/)?(?:[\w@.+-]+\/)*[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,9})(?::(\d+)(?::(\d+))?|\((\d+),(\d+)\))?/g
+// never starts a match. Colour codes (`\x1b[4m`) are invisible: a path one
+// starts is linked (tasks run with FORCE_COLOR), one it splits from its
+// directory is not. Groups: file, then line and column of either form.
+const SGR = String.raw`\x1b\[[\d;]*m`
+const PATH = new RegExp(
+  String.raw`(?<!\x1b\[[\d;]*)(?:(?<![\w./@+-])|(?<=${SGR}))(?<![\w./@+-](?<!${SGR})(?:${SGR})+)` +
+    String.raw`((?:\/|\.{1,2}\/)?(?:[\w@.+-]+\/)*[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,9})(?::(\d+)(?::(\d+))?|\((\d+),(\d+)\))?`,
+  'g',
+)
 
 /** A file a task's output names; `file` absolute. */
 export interface OutputLocation {
@@ -29,7 +36,8 @@ export function linkPaths(text: string, dir: string, isFile: (abs: string) => bo
   return text.replace(PATH, (match: string, file: string) => {
     const abs = path.resolve(dir, file)
     if (!isFile(abs)) return match
-    return `\x1b]8;;file://${encodeURI(abs)}\x1b\\${match}\x1b]8;;\x1b\\`
+    // Not `encodeURI`: it keeps a `#` or `?`, which the URL reads as its fragment or query.
+    return `\x1b]8;;${pathToFileURL(abs).href}\x1b\\${match}\x1b]8;;\x1b\\`
   })
 }
 

package/src/report/plain-output.ts

@@ -1,11 +1,12 @@
 import type { TaskNode } from '../graph/index.js'
 import type { Logger } from './logger.js'
 
-// A prefix that may yet complete as a CSI or OSC sequence. An escape cut
-// at a chunk's end is held for the next chunk: stripped alone, its
-// remainder (`1m`) reached the log as text.
+// A prefix that may yet complete as a CSI, OSC or charset sequence
+// (`tput sgr0` writes `\x1b(B`). An escape cut at a chunk's end is held for
+// the next chunk: stripped alone, its remainder (`1m`, `B`) reached the log
+// as text.
 // eslint-disable-next-line no-control-regex -- ESC is the point
-const PARTIAL_ESCAPE = /^\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b]*\x1b?)?$/
+const PARTIAL_ESCAPE = /^\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b]*\x1b?|[ -/]+)?$/
 
 /**
  * `sink` with terminal escapes stripped from task output. Tasks run with
@@ -34,12 +35,19 @@ export function plainOutput(sink: Logger): Logger {
     if (text !== '') write(node, text)
   }
   // Delegated one by one, never spread: an embedder's logger may be a class
-  // whose methods live on its prototype and read `this`.
+  // whose methods live on its prototype and read `this`. Every hook the sink
+  // has: a dropped `warn` put warnings on stdout, a dropped `runDone` left
+  // the live region under the footer.
   return {
     status: (line) => sink.status(line),
+    ...(sink.warn && { warn: (line) => sink.warn!(line) }),
     ...(sink.runStart && { runStart: (info) => sink.runStart!(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) }),
+    ...(sink.runStop && { runStop: () => sink.runStop!() }),
+    ...(sink.runDone && { runDone: () => sink.runDone!() }),
     taskStdout(node, chunk) {
       const text = strip(`${node.id}\0out`, chunk)
       if (text !== '' || chunk === '') sink.taskStdout(node, text)

package/src/report/status-line.ts

@@ -6,7 +6,13 @@
 // then redraws, so the display can never interleave with task output.
 
 import { dumbTerminal, paint, type ColorSupport } from '../util/index.js'
-import { formatTaskRow, paintIdParts, TIME_COL } from './framed-output.js'
+import {
+  formatListHeader,
+  formatTaskRow,
+  paintIdParts,
+  pathNote,
+  placeNote,
+} from './framed-output.js'
 import type { BlockedTask } from './forecast.js'
 
 const NO_COLOR: ColorSupport = { enabled: false }
@@ -32,6 +38,9 @@ export interface StatusStream {
   rows?: number
 }
 
+/** A region's lines, or what builds them when it is drawn. */
+export type Region = readonly string[] | (() => readonly string[])
+
 export interface OutputWriter {
   /** True only when the stream is a TTY and the run isn't CI. */
   readonly enabled: boolean
@@ -49,9 +58,11 @@ export interface OutputWriter {
   setStatus(line: string, opts?: { force?: boolean }): void
   /**
    * Replace the multi-line status region. Same throttle contract as
-   * `setStatus`; the two share one display slot.
+   * `setStatus`; the two share one display slot. A function is called
+   * when the region is next drawn, once: a set the throttle coalesces
+   * builds nothing.
    */
-  setRegion(lines: readonly string[], opts?: { force?: boolean }): void
+  setRegion(lines: Region, opts?: { force?: boolean }): void
   /** Hand over what `coalesce` holds and write straight through from now on. */
   settle(): void
   /** Permanently remove the status display; later set* is a no-op. */
@@ -107,7 +118,7 @@ export function createOutputWriter(
     stream.write(text)
   }
 
-  let current: readonly string[] | null = null
+  let current: Region | null = null
   let shown = false
   // PHYSICAL rows the shown region occupies, not logical lines — see
   // `regionRows`.
@@ -193,13 +204,18 @@ export function createOutputWriter(
     // only repeat these bytes.
     cancelTrailing()
     const erase = shown ? eraseSeq() : CLEAR
+    // Built here, not at the set: a warm run's task events set the
+    // region hundreds of times inside one floor, and each build was a
+    // forecast pass and a summary render no frame showed (200 hits on a
+    // terminal: run graph 62 → 9 ms). Kept built: a write redraws it.
+    if (typeof current === 'function') current = current()
     const lines = fitted(current!)
     stream.write(erase + lines.join('\n'))
     shown = true
     shownRows = regionRows(lines)
     lastDraw = now()
   }
-  const set = (lines: readonly string[], o: { force?: boolean }): void => {
+  const set = (lines: Region, o: { force?: boolean }): void => {
     if (!enabled || dead) return
     current = lines
     if (!atLineStart || holds > 0) return
@@ -306,18 +322,18 @@ export function createOutputWriter(
   }
 }
 
-const IDLE = '#6b7280'
-
 export interface WorkerSlot {
   id: string
   startedMs: number
+  /** Its executor holds it for a machine to begin it (`TaskExecutor.running` is `null`). */
+  waiting?: boolean
 }
 
 export interface StatusRegionState {
-  /** A running task's unfinished dependents (`blocks 14` on its row); 0 says nothing. */
-  blocks?: ReadonlyMap<string, number>
   /** The running task at the head of the longest unfinished chain. */
   critical?: string
+  /** Where a running task runs, when not here (`TaskExecutor.running`); its row shows it. */
+  where?: (taskId: string) => string | null | undefined
   /** A running task's usual duration from history; its row shows it. */
   expected?: ReadonlyMap<string, number>
   /**
@@ -327,17 +343,23 @@ export interface StatusRegionState {
    * the honest end of their life.
    */
   pinnedPersistent: readonly string[]
-  /** Fixed-size slot array; null = idle worker. Index = display row. */
+  /** The running tasks by slot, null for a free one; a task past the slots follows them. */
   slots: readonly (WorkerSlot | null)[]
-  /** The blocked task an idle slot's row holds instead of `idle`, by the same index. */
-  blocked?: readonly (BlockedTask | null)[]
-  /** Running tasks beyond the displayed slots. */
-  overflow: number
+  /** The list's height: one row per worker, whatever runs, so it never jumps. */
+  size?: number
+  /**
+   * The tasks the scheduler has picked for the next free workers, each
+   * nested under the running task it waits on, in the rows no running task
+   * takes; nothing further ahead.
+   */
+  next?: readonly BlockedTask[]
+  /** Each running task's count of the tasks it holds back: its `blocked` cell. */
+  blockedBy?: ReadonlyMap<string, number>
   /** The run was stopped: running rows say `aborting`, idle rows leave. */
   stopping?: boolean
   /**
    * vx's own steps still running, shown below the worker rows: no worker
-   * slot or `--concurrency` bounds them (M, 2026-10-15).
+   * slot or `--concurrency` bounds them (2026-10-15).
    */
   steps?: readonly WorkerSlot[]
   /** Clock value used for per-slot elapsed (injectable for tests). */
@@ -392,7 +414,7 @@ const INTERNAL = 'internal'
 /**
  * The list row of one of vx's own steps (`vx:uploads`), on the task grid
  * with `internal` in the cache column: a step is no task and caches
- * nothing (M, 2026-10-16: `4.60s success internal vx:keep-run`).
+ * nothing (2026-10-16: `4.60s success internal vx:keep-run`).
  */
 export function formatStepLine(
   id: string,
@@ -441,31 +463,39 @@ export function formatStatusRegion(
         '',
         paintPinnedId(id, colors),
         colors,
+        // A blank `blocked` cell, so the id sits under the header's `task`.
+        '',
       ),
     )
   }
 
-  // Worker rows: NO glyph — the live elapsed time leads (no spinner;
-  // the ticking time IS the motion), then `running`, full id (never
-  // truncated — name is the last column). Idle rows hold their slot's
-  // place, dim, aligned under the status column: the blocked task the row
-  // holds and what holds it back, else `idle`.
-  // One task running has no path to compare against.
-  const busy = s.slots.filter((x) => x !== null).length
-  for (const [row, slot] of s.slots.entries()) {
-    if (slot === null && s.stopping === true) continue
-    if (slot === null) {
-      const w = s.blocked?.[row]
-      lines.push(
-        w == null
-          ? `${' '.repeat(3 + TIME_COL + 1)}${paint(IDLE, 'idle', colors, { dim: true })}`
-          : formatTaskRow(' ', null, 'blocked', '', '', '', paintPinnedId(w.id, colors), colors) +
-              `  ${dim(`by ${w.by}`)}`,
-      )
-      continue
+  // Running rows: NO glyph — the live elapsed time leads (no spinner;
+  // the ticking time IS the motion), then `running`, the usual duration,
+  // how many tasks wait on it, and the full id (never truncated — name is
+  // the last column). The rows no task runs in hold the tasks planned
+  // next, each nested under what it waits on; the rest stay blank, so the
+  // list keeps its height.
+  const running = s.slots.filter((x): x is WorkerSlot => x !== null && x.waiting !== true)
+  // Placed by an executor (DTE), the list is what runs: blocked tasks are
+  // the tasks line's count alone, and its size is no machine's.
+  const placed = s.where !== undefined
+  const free = Math.max(0, (s.size ?? 0) - running.length)
+  const nested = new Map<string, BlockedTask[]>()
+  if (!placed && s.stopping !== true) {
+    const ids = new Set(running.map((x) => x.id))
+    let n = 0
+    for (const b of s.next ?? []) {
+      if (n === free) break
+      if (!ids.has(b.by)) continue
+      let list = nested.get(b.by)
+      if (list === undefined) nested.set(b.by, (list = []))
+      list.push(b)
+      n++
     }
-    // What waits on it, after the id: the row to watch is the one the
-    // longest chain waits on, and the one the most tasks wait on.
+  }
+  let rows = 0
+  for (const slot of running) {
+    rows++
     if (s.stopping === true) {
       lines.push(
         formatTaskRow(
@@ -477,14 +507,12 @@ export function formatStatusRegion(
           '',
           paintPinnedId(slot.id, colors),
           colors,
+          '',
         ),
       )
       continue
     }
-    const waiting = s.blocks?.get(slot.id) ?? 0
-    const notes: string[] = []
-    if (s.critical === slot.id && busy > 1) notes.push(paint(WARN, 'critical path', colors))
-    if (waiting > 0) notes.push(dim(`blocks ${waiting}`))
+    const at = s.where?.(slot.id)
     const usual = s.expected?.get(slot.id)
     lines.push(
       formatTaskRow(
@@ -496,12 +524,29 @@ export function formatStatusRegion(
         '',
         paintPinnedId(slot.id, colors),
         colors,
-      ) + (notes.length > 0 ? `  ${notes.join(dim(' \u00b7 '))}` : ''),
+        String(s.blockedBy?.get(slot.id) ?? 0),
+      ) +
+        (s.critical === slot.id ? pathNote(colors) : '') +
+        (at != null ? placeNote(at, colors) : ''),
     )
+    for (const b of nested.get(slot.id) ?? []) {
+      rows++
+      lines.push(
+        formatTaskRow(
+          ' ',
+          null,
+          'blocked',
+          '',
+          '',
+          '',
+          `${dim('\u2514')} ${paintPinnedId(b.id, colors)}`,
+          colors,
+          '',
+        ),
+      )
+    }
   }
-  if (s.overflow > 0) {
-    lines.push(dim(`\u2026 +${s.overflow} more running`))
-  }
+  if (!placed) for (; rows < (s.size ?? 0); rows++) lines.push('')
   for (const step of s.steps ?? []) {
     lines.push(
       formatTaskRow(
@@ -513,9 +558,11 @@ export function formatStatusRegion(
         '',
         paintPinnedId(step.id, colors),
         colors,
+        '',
       ),
     )
   }
+  if (lines.length > 1) lines.splice(1, 0, formatListHeader(placed, colors, true))
   // The live summary section — identical shape to the final printout,
   // so the region visually BECOMES the summary when the run ends.
   lines.push(...s.summaryLines)
@@ -524,11 +571,12 @@ export function formatStatusRegion(
 
 /**
  * A running task's usual duration, fixed while the elapsed time counts up
- * toward it (M, 2026-10-14): `~5.2s`, `~42s`, `~2m 05s`. Fits the cache
+ * toward it (2026-10-14): `~5.2s`, `~42s`, `~2m 05s`. Fits the cache
  * column below 100 minutes.
  */
 function formatExpected(ms: number): string {
-  if (ms < 1000) return `~${Math.round(ms)}ms`
+  // The tier by the rounded value: 999.6 ms printed `~1000ms` (item 1034's class).
+  if (Math.round(ms) < 1000) return `~${Math.round(ms)}ms`
   if (ms < 9950) return `~${(ms / 1000).toFixed(1)}s`
   const s = Math.round(ms / 1000)
   if (s < 60) return `~${s}s`