@vzn/vx 0.0.638 → 0.0.640

package/src/util/paths.ts

@@ -163,7 +163,7 @@ export function isLiteralPattern(glob: string): boolean {
 }
 
 /**
- * The alphabet of a TASK glob (`cache.inputs.files`, `cache.outputs.files`,
+ * The alphabet of a TASK glob (`inputs.files`, `cache.outputs.files`,
  * `workspaceFiles`), behind {@link isLiteralPattern}, for the callers that
  * need the POSITION of the first wildcard rather than a verdict. Every site
  * that asks "must this declaration be matched?" reads this one regex: item

package/src/util/report.ts

@@ -5,16 +5,24 @@ import { paint, type ColorSupport } from './colors.js'
 // are off.
 const GRADIENT_FROM = [0xa7, 0x8b, 0xfa] as const
 const GRADIENT_TO = [0xf4, 0x72, 0xb6] as const
-// Rule ends flush with the bars: 2 indent + 8 label + 2 gap + 50 cells.
-const RULE_DASHES = 57
+// The bars' label column: 2 indent + 8 label + 2 gap.
+const LABEL = 12
 
-/** Total visible rule width: `─ <mark> ` + dashes. Shared by the run summary and every report. */
+/** A meter's cells: 50, or fewer so the bar fits a narrower terminal. */
+export function barWidth(colors: ColorSupport): number {
+  const columns = colors.columns
+  return columns === undefined ? 50 : Math.max(10, Math.min(50, columns - LABEL))
+}
+
+/** `─ <mark> ` + dashes, flush with the bars. Shared by the run summary and every report. */
 export function gradientRule(colors: ColorSupport, mark = 'vx'): string {
   const head = `─ `
-  const dashes = '─'.repeat(Math.max(8, RULE_DASHES + 2 - mark.length))
+  const width = LABEL + barWidth(colors)
+  const dashes = '─'.repeat(Math.max(8, width - 3 - mark.length))
   if (!colors.enabled) return `${head}${mark} ${dashes}`
   const chunks = 8
-  const per = Math.ceil(RULE_DASHES / chunks)
+  // The gradient spans the rule as if its mark were `vx`.
+  const per = Math.ceil((width - 5) / chunks)
   let out = ''
   for (let i = 0; i < chunks; i++) {
     const seg = dashes.slice(i * per, (i + 1) * per)

package/src/util/settle.ts

@@ -7,54 +7,29 @@ import { parseDuration } from './size.js'
 /** Default upper bound on one end-of-run flush/teardown await. */
 const DEFAULT_TIMEOUT_MS = 3000
 
-/** A bound the run resolved from its flag or `.vx/workspace`. */
-export interface SettleBound {
-  readonly ms: number
-  readonly from: 'flag' | 'workspace'
-}
-
-let teardownSet: SettleBound | undefined
-let killGraceSet: SettleBound | undefined
-
-/**
- * The run's `run.teardownTimeout` and `run.killGrace` from its flag or
- * workspace (the orchestrator resolves them; util sits below settings).
- * The variable, read per call, sits between the two, so a test drives the
- * deadline instead of waiting it out.
- */
-export function setSettleBounds(b: { teardown?: SettleBound; killGrace?: SettleBound }): void {
-  teardownSet = b.teardown
-  killGraceSet = b.killGrace
-}
-
 /**
- * A flag's bound, else the variable's (a positive duration inside the
- * timer's range: the CLI refuses any other before a run, and an embedder's
- * falls back), else the workspace's.
+ * A timer a test shortens: `VX_TEST_<name>`, a duration. Undocumented and
+ * in no settings table: the suites that prove a deadline drive it instead
+ * of waiting the real one out. Zero only where `zero` allows it.
  */
-function bound(name: string, set: SettleBound | undefined, zero = false): number | undefined {
-  if (set?.from === 'flag') return set.ms
-  const raw = process.env[name]
-  if (raw !== undefined && raw !== '') {
-    const n = parseDuration(raw)
-    if (n !== null && (n > 0 || zero) && n <= MAX_TIMEOUT_MS) return n
-  }
-  return set?.ms
+export function testTimerMs(name: string, defaultMs: number, zero = false): number {
+  const raw = process.env[`VX_TEST_${name}`]
+  if (raw === undefined || raw === '') return defaultMs
+  const n = parseDuration(raw)
+  return n !== null && (n > 0 || (zero && n === 0)) && n <= MAX_TIMEOUT_MS ? n : defaultMs
 }
 
 /**
- * The bound on one end-of-run flush or teardown (`run.teardownTimeout`).
- * There is no "no limit": the deadline exists so a plugin's flush cannot
- * hold the run's exit hostage, so a timer past the platform's range (which
- * would fire at once and drop every buffered record) is no value.
+ * The bound on one end-of-run flush or teardown: a plugin's flush cannot
+ * hold the run's exit hostage.
  */
 export function teardownTimeoutMs(): number {
-  return bound('VX_RUN_TEARDOWN_TIMEOUT', teardownSet, true) ?? DEFAULT_TIMEOUT_MS
+  return testTimerMs('TEARDOWN_TIMEOUT', DEFAULT_TIMEOUT_MS, true)
 }
 
 /**
- * The SIGTERM→SIGKILL grace a run grants a child that ignores SIGTERM
- * (`run.killGrace`): the one-shot timeout escalation (`exec/runner.ts`),
+ * The SIGTERM→SIGKILL grace a run grants a child that ignores SIGTERM:
+ * the one-shot timeout escalation (`exec/runner.ts`),
  * the signal teardown (`orchestrator/signals.ts`) and the end-of-run
  * persistent shutdown (`orchestrator/persistent.ts`) share it. Two seconds
  * is generous for a real server's cleanup and is what every run waits when
@@ -63,7 +38,7 @@ export function teardownTimeoutMs(): number {
  * 200 ms grace proves too.
  */
 export function killGraceMs(defaultMs: number): number {
-  return bound('VX_RUN_KILL_GRACE', killGraceSet) ?? defaultMs
+  return testTimerMs('KILL_GRACE', defaultMs)
 }
 
 /**

package/src/util/tail.ts

@@ -6,7 +6,7 @@
 // needs a cap, and the cap has to be honest — a truncated log that reads as
 // complete is worse than one that says what it lost.
 //
-// `orchestrator/logger.ts` is the sole holder: it registers a tail per
+// `report/logger.ts` is the sole holder: it registers a tail per
 // persistent task at taskStart and keeps one for the rest of the run, so a
 // single mechanism covers both the pre-ready window and everything after.
 // `exec/runner.ts` used to keep a SECOND pre-ready copy fed from the same

package/src/util/ui.ts

@@ -3,14 +3,20 @@
 // color, indent and spacing, so every surface shares one look. Colors
 // are decided at print time, per stream.
 
-import { detectColors, ERROR, paint, SUCCESS, WARN, type ColorSupport } from './colors.js'
+import {
+  detectColors,
+  ERROR,
+  identityColor,
+  paint,
+  SUCCESS,
+  WARN,
+  type ColorSupport,
+} from './colors.js'
 import { gradientRule } from './report.js'
 
 export type Tone = 'ok' | 'warn' | 'error' | 'info'
 
 const INFO = '#06b6d4'
-const PROJECT = '#a78bfa'
-const TASK = '#f472b6'
 const HUE: Record<Tone, string> = { ok: SUCCESS, warn: WARN, error: ERROR, info: INFO }
 const SYMBOL: Record<Tone, string> = { ok: '✓', warn: '!', error: '✗', info: '›' }
 const INDENT = '  '
@@ -26,7 +32,7 @@ export interface Block {
   readonly lines: (colors: ColorSupport) => string[]
 }
 
-/** A `project#task` id, in the run's project and task hues. */
+/** A `project` or `project#task` id, each half in its name's hue, the `#` dim. */
 export const id = (text: string): Inline => ({ style: 'id', text })
 /** A path, glob or file: bold. */
 export const path = (text: string): Inline => ({ style: 'bold', text })
@@ -48,8 +54,13 @@ function inline(x: Inline, c: ColorSupport): string {
       return paint('', text, c, { bold: true })
     case 'id': {
       const hash = text.lastIndexOf('#')
-      if (hash < 0) return paint(PROJECT, text, c)
-      return paint(PROJECT, text.slice(0, hash), c) + paint(TASK, text.slice(hash), c)
+      if (hash < 0) return paint(identityColor(text), text, c)
+      const task = text.slice(hash + 1)
+      return (
+        paint(identityColor(text.slice(0, hash)), text.slice(0, hash), c) +
+        paint('', '#', c, { dim: true }) +
+        paint(identityColor(task), task, c)
+      )
     }
     default:
       return paint(HUE[style], text, c)

package/src/workspace/affected.ts

@@ -6,7 +6,7 @@
 // index + unstaged — so it captures everything you touched and nothing
 // the base branch moved on with. Matches Turbo's `[<since>]` semantics.
 
-import { realpath } from 'node:fs/promises'
+import { realpath, stat } from 'node:fs/promises'
 import path from 'node:path'
 import {
   executablePath,
@@ -75,7 +75,7 @@ export interface AffectedArgs {
   since: string
   projects: readonly ProjectMeta[]
   /**
-   * Which projects declare a `cache.inputs.workspaceFiles` glob matching one of
+   * Which projects declare a `inputs.workspaceFiles` glob matching one of
    * these workspace-relative paths.
    *
    * A workspace-anchored glob is the documented escape hatch for inputs
@@ -107,6 +107,12 @@ export interface AffectedArgs {
    * run then paid again (I-26).
    */
   untracked?: () => Promise<readonly string[] | null>
+  /**
+   * The tracked symlinks, workspace-relative, from the run's enumeration
+   * (its index OIDs spell one `120000:`); null or absent spawns `git ls-files
+   * -s` here. A changed or untracked link is a changed path already.
+   */
+  links?: () => Promise<readonly string[] | null>
 }
 
 export interface FingerprintClaims {
@@ -253,6 +259,16 @@ export async function affectedChanges(
   const changed = [...diffed.paths, ...untracked.filter((s) => !isInstalledPath(s))].filter(
     (s) => s !== LOCKFILE_NAME,
   )
+  // A symlinked input keys the content behind it (cache/linked-inputs.ts),
+  // and the diff names that content's path, never the link's: a link whose
+  // target changed is a changed path itself.
+  changed.push(
+    ...(await linkedChanges(
+      args.workspaceRoot,
+      (await args.links?.().catch(() => null)) ?? (await trackedLinks(args.workspaceRoot)),
+      changed,
+    )),
+  )
   // The nested repositories git reports as one path: a gitlink, or an
   // untracked embedded repository (`dir/`, the only path git prints so).
   const nested = new Set(diffed.gitlinks)
@@ -503,6 +519,69 @@ async function bytesOrNull(file: string): Promise<Uint8Array | null> {
   return (await f.exists()) ? await f.bytes() : null
 }
 
+/** The symlinks the index lists, workspace-relative. */
+async function trackedLinks(workspaceRoot: string): Promise<string[]> {
+  const out: string[] = []
+  for (const record of await gitPaths(workspaceRoot, ['ls-files', '-s', '-z'])) {
+    if (record.startsWith('120000 ')) out.push(record.slice(record.indexOf('\t') + 1))
+  }
+  return out
+}
+
+/**
+ * The links in `links` whose target changed: a file `changed` names, or a
+ * directory holding one. A target git cannot diff is changed on every run:
+ * one outside the workspace, or git-ignored (or ignored files under a linked
+ * directory), since the key reads it whatever git says. A dangling link
+ * reads nothing; retargeting it is a change to the link itself.
+ */
+async function linkedChanges(
+  workspaceRoot: string,
+  links: readonly string[],
+  changed: readonly string[],
+): Promise<string[]> {
+  if (links.length === 0) return []
+  const realRoot = await realpath(workspaceRoot).catch(() => workspaceRoot)
+  const out: string[] = []
+  const inside: Array<{ link: string; target: string; dir: boolean }> = []
+  for (const link of links) {
+    let real: string
+    let dir: boolean
+    try {
+      real = await realpath(path.join(workspaceRoot, link))
+      dir = (await stat(real)).isDirectory()
+    } catch {
+      continue
+    }
+    const rel = path.relative(realRoot, real)
+    if (rel.startsWith('..') || path.isAbsolute(rel)) out.push(link)
+    else inside.push({ link, target: rel.split(path.sep).join('/'), dir })
+  }
+  if (inside.length === 0) return out
+  const named = inside.map((l) => l.target).filter((t) => t !== '')
+  const ignored = await gitPaths(workspaceRoot, [
+    'ls-files',
+    '--others',
+    '--ignored',
+    '--exclude-standard',
+    '--directory',
+    '-z',
+    '--',
+    ...(named.length === inside.length ? named : ['.']),
+  ])
+  const changedSet = new Set(changed)
+  const under = (p: string, dir: string): boolean => dir === '' || p.startsWith(`${dir}/`)
+  for (const { link, target, dir } of inside) {
+    const unseen = ignored.some((i) => {
+      const at = i.replace(/\/$/, '')
+      return at === target || under(target, at) || (dir && under(at, target))
+    })
+    const hit = dir ? changed.some((c) => under(c, target)) : changedSet.has(target)
+    if (unseen || hit) out.push(link)
+  }
+  return out
+}
+
 /** Run a NUL-separated path-listing git command from the workspace root. */
 async function gitPaths(workspaceRoot: string, cmd: string[]): Promise<string[]> {
   const proc = spawnGit([...cmd], workspaceRoot)

package/src/workspace/config-imports.ts

@@ -1,7 +1,7 @@
 // The third `changed file → project` channel for `--affected`.
 //
 // Directory containment answers "which project owns this file", and
-// `cache.inputs.workspaceFiles` answers "which project declared it". Neither
+// `inputs.workspaceFiles` answers "which project declared it". Neither
 // can see the one remaining way a file reaches a task: a project's
 // `vx.config.*` IMPORTS it. Resolved-config hashing folds the imported values
 // into the cache key (architecture principle #4), so editing such a file