@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/run/board/run-board-fit.ts

@@ -4,18 +4,18 @@ import { run_board_labels } from './run-board-labels'
 
 // A live `run:board` frame kept within the terminal. A frame taller than the pane scrolls the
 // alternate screen as it is written, and the header — the lines that say whether the run moves and
-// how far it is — is what scrolls off. So the parts below it give way instead, least wanted first:
-// the footer, the legend, the oldest notes until three are left, the finished rows, the rest of the
-// notes, the reviewers thanked above the legend, the rows not yet started, the parked rows and, last,
-// the running rows — what a person keeps the board open to see. Each stage stops once the
-// frame fits, a cut row is counted on its section's `more N` line, and the order a row is drawn in
+// how far it is — is what scrolls off. So the parts below it give way instead, least wanted first and
+// in the order the frame draws them from the bottom (joshuafolkken/kit#4099): the footer, the legend,
+// the rows under the notes — the finished, the 🔗 waiting, the not yet started — the notes from the
+// oldest, the reviewers thanked above the legend, the parked rows and, last, the rows waiting on a person's decision
+// and the running rows — what a person keeps the board open to see. Each stage stops once the
+// frame fits, a cut row is counted on the plan's `more N` line — or on its folding section's own last
+// line while that section keeps a row (joshuafolkken/kit#4042) — and the order a row is drawn in
 // never changes. A line wider than the pane wraps, so every line is counted by the rows it takes on
 // screen, not as one.
 
 const { WORDS } = run_board_labels
 const INDENT = '  '
-// The newest notes kept until the finished rows are gone; the older ones give way before them.
-const NOTES_KEPT = 3
 
 interface TerminalSize {
 	rows: number
@@ -23,7 +23,7 @@ interface TerminalSize {
 }
 
 // The stage an issue row gives way in, the earlier first.
-type YieldStage = 'finished' | 'pending' | 'parked' | 'running'
+type YieldStage = 'finished' | 'waiting' | 'pending' | 'parked' | 'decision' | 'running'
 
 // When a row's stage gives it way: the oldest first, a row with no time before every timed one.
 interface RowYield {
@@ -37,46 +37,102 @@ interface PlanLine {
 	row: RowYield | undefined
 }
 
-// A plan section drops its heading once none of its rows is left.
-interface PlanSection {
+// A section a person folds and unfolds with one key on a live board (`run-board-fold.ts`).
+type SectionKey = 'lanes' | 'processes' | 'findings' | 'queued' | 'waiting' | 'done'
+
+// What a foldable part's rule is labeled, and whether a person folded it to its heading alone.
+interface Foldable {
+	label?: string | undefined
+	is_folded?: boolean | undefined
+}
+
+// A plan section drops its heading once none of its rows is left — unless it folds: then its cut rows
+// are counted on its own last line, drawn by `fold`, rather than on the plan's `more N`. A folded one
+// is its heading alone.
+interface PlanSection extends Foldable {
 	head: ReadonlyArray<string>
 	lines: ReadonlyArray<PlanLine>
+	fold?: ((cut: ReadonlyArray<PlanLine>) => string) | undefined
+	key?: SectionKey | undefined
 }
 
 // The newest notes shown, and how many older ones are already past the section's limit.
-interface NotesPart {
+interface NotesPart extends Foldable {
 	head: ReadonlyArray<string>
 	lines: ReadonlyArray<string>
 	hidden: number
 }
 
-// A frame in its parts, top to bottom: the header above stays.
+// A part drawn after `plan` whose lines a group's parts are, `is_detail`, and give way all at once;
+// `summary` is what its folded heading says.
+interface DetailPart extends Foldable {
+	head: ReadonlyArray<string>
+	lines: ReadonlyArray<{ text: string; is_detail: boolean }>
+	summary?: string | undefined
+}
+
+// A frame in its parts, top to bottom: the header above stays. The plan's sections are drawn around
+// the notes: `plan` above them, `below` under them; `processes` between the plan and the notes.
 interface FrameParts {
 	above: ReadonlyArray<string>
 	plan: ReadonlyArray<PlanSection>
+	processes?: DetailPart | undefined
 	notes: NotesPart
+	below?: ReadonlyArray<PlanSection> | undefined
 	// The reviewers thanked, drawn right above the legend; none where nobody is.
 	thanks?: ReadonlyArray<string> | undefined
 	legend: ReadonlyArray<string>
 	footer: ReadonlyArray<string>
 }
 
-// One thing that gives way: a part as a whole, one note (the oldest shown), or one issue row.
-type Yielder = 'thanks' | 'footer' | 'legend' | 'note' | PlanLine
+// One thing that gives way: a part as a whole, the processes' details, one note (the oldest shown),
+// or one issue row.
+type Yielder = 'thanks' | 'footer' | 'legend' | 'details' | 'note' | PlanLine
 
 interface Cut {
 	thanks: boolean
 	footer: boolean
 	legend: boolean
+	details: boolean
 	notes: number
 	rows: ReadonlySet<PlanLine>
 }
 
-const NO_CUT: Cut = { thanks: false, footer: false, legend: false, notes: 0, rows: new Set() }
+const NO_CUT: Cut = {
+	thanks: false,
+	footer: false,
+	legend: false,
+	details: false,
+	notes: 0,
+	rows: new Set(),
+}
+
+// A line of printable ASCII alone takes a column a character, so `string-width` is spared it.
+const PRINTABLE_ASCII = /^[ -~]*$/u
+
+// The widths measured so far. A fit weighs a frame for every cut of its order, each repeating most of
+// the last one's lines, and the next redraw draws nearly the same lines and cells again, so each is
+// measured once (joshuafolkken/kit#5185). Let go whole once it holds `WIDTHS_KEPT`, so a long-running
+// board does not keep every line it stopped drawing.
+const WIDTHS_KEPT = 10_000
+const widths = new Map<string, number>()
+
+function measured(plain: string): number {
+	return PRINTABLE_ASCII.test(plain) ? plain.length : string_width(plain)
+}
 
 // The columns a line takes on screen: its color escapes take none, an emoji two.
 function width_of(line: string): number {
-	return string_width(stripVTControlCharacters(line))
+	const known = widths.get(line)
+
+	if (known !== undefined) return known
+	if (widths.size >= WIDTHS_KEPT) widths.clear()
+
+	const width = measured(stripVTControlCharacters(line))
+
+	widths.set(line, width)
+
+	return width
 }
 
 function height_of(line: string, columns: number): number {
@@ -92,25 +148,50 @@ function more_lines(hidden: number): Array<string> {
 }
 
 // A section that ends on an epic whose children were all cut ends on its last row instead.
-function section_lines(section: PlanSection, cut: ReadonlySet<PlanLine>): Array<string> {
+function kept_lines(section: PlanSection, cut: ReadonlySet<PlanLine>): Array<string> {
 	const kept = section.lines.filter((line) => !cut.has(line))
 	const last = kept.findLastIndex((line) => line.row !== undefined)
 
-	if (last === -1) return []
+	return kept.slice(0, last + 1).map((line) => line.text)
+}
 
-	return [...section.head, ...kept.slice(0, last + 1).map((line) => line.text)]
+// A folding section counts its own cut rows while any of its rows is left; with none left it goes,
+// and the plan's `more N` counts them.
+function is_folding(section: PlanSection, cut: ReadonlySet<PlanLine>): boolean {
+	return section.fold !== undefined && kept_lines(section, cut).length > 0
 }
 
-// The plan's cut rows are counted on one line at its end, under a blank when no section is left.
-function plan_lines(plan: ReadonlyArray<PlanSection>, cut: ReadonlySet<PlanLine>): Array<string> {
-	const drawn = plan.flatMap((section) => section_lines(section, cut))
-	const lead = drawn.length === 0 && cut.size > 0 ? [''] : []
+// The fold line a folding section ends on while any of its rows is cut.
+function fold_lines(section: PlanSection, cut: ReadonlySet<PlanLine>): Array<string> {
+	const gone = section.lines.filter((line) => cut.has(line))
+
+	if (!is_folding(section, cut) || gone.length === 0) return []
 
-	return [...lead, ...drawn, ...more_lines(cut.size)]
+	return [section.fold?.(gone) ?? '']
+}
+
+function section_lines(section: PlanSection, cut: ReadonlySet<PlanLine>): Array<string> {
+	if (section.is_folded === true) return [...section.head]
+
+	const kept = kept_lines(section, cut)
+
+	if (kept.length === 0) return []
+
+	return [...section.head, ...kept, ...fold_lines(section, cut)]
+}
+
+// The cut rows no folding section counts.
+function unfolded(plan: ReadonlyArray<PlanSection>, cut: ReadonlySet<PlanLine>): number {
+	const folding = plan.filter((section) => is_folding(section, cut))
+	const folded = new Set(folding.flatMap((section) => section.lines))
+
+	return [...cut].filter((line) => !folded.has(line)).length
 }
 
 // The notes give way from the oldest shown; with none left the section goes, heading and all.
 function notes_lines(notes: NotesPart, cut: number): Array<string> {
+	if (notes.is_folded === true) return [...notes.head]
+
 	const kept = notes.lines.slice(0, notes.lines.length - cut)
 
 	if (kept.length === 0) return []
@@ -118,11 +199,45 @@ function notes_lines(notes: NotesPart, cut: number): Array<string> {
 	return [...notes.head, ...kept, ...more_lines(notes.hidden + cut)]
 }
 
+function sections_lines(
+	sections: ReadonlyArray<PlanSection>,
+	cut: ReadonlySet<PlanLine>,
+): Array<string> {
+	return sections.flatMap((section) => section_lines(section, cut))
+}
+
+// The processes under their heading, the groups alone once their details are cut.
+function detail_lines(part: DetailPart | undefined, is_cut: boolean): Array<string> {
+	if (part === undefined) return []
+
+	const kept = part.lines.filter((line) => !is_cut || !line.is_detail)
+
+	return [...part.head, ...kept.map((line) => line.text)]
+}
+
+// The plan's sections around the notes, its cut rows counted on one line after its last drawn section —
+// under `below` while any of it is drawn, else above the processes and the notes, never under the
+// notes' own `more` — and under a blank when no section is left above it.
+function body_lines(parts: FrameParts, cut: Cut): Array<string> {
+	const below = parts.below ?? []
+	const [plan, notes, under] = [
+		sections_lines(parts.plan, cut.rows),
+		[...detail_lines(parts.processes, cut.details), ...notes_lines(parts.notes, cut.notes)],
+		sections_lines(below, cut.rows),
+	]
+	const more = more_lines(unfolded([...parts.plan, ...below], cut.rows))
+
+	if (under.length > 0) return [...plan, ...notes, ...under, ...more]
+
+	const lead = plan.length === 0 && more.length > 0 ? [''] : []
+
+	return [...lead, ...plan, ...more, ...notes]
+}
+
 function compose(parts: FrameParts, cut: Cut): Array<string> {
 	return [
 		...parts.above,
-		...plan_lines(parts.plan, cut.rows),
-		...notes_lines(parts.notes, cut.notes),
+		...body_lines(parts, cut),
 		...(cut.thanks ? [] : (parts.thanks ?? [])),
 		...(cut.legend ? [] : parts.legend),
 		...(cut.footer ? [] : parts.footer),
@@ -154,25 +269,39 @@ function yielding(rows: ReadonlyArray<Indexed>, stage: YieldStage): Array<PlanLi
 		.map((entry) => entry.line)
 }
 
-// Everything that gives way, in the order it does.
-function order_of(parts: FrameParts): Array<Yielder> {
-	const rows = parts.plan
+// The stages in the order their rows give way.
+const STAGES: ReadonlyArray<YieldStage> = [
+	'finished',
+	'waiting',
+	'pending',
+	'parked',
+	'decision',
+	'running',
+]
+
+// The issue rows of some sections, in the order they give way.
+function rows_yielding(sections: ReadonlyArray<PlanSection>): Array<PlanLine> {
+	const rows = sections
 		.flatMap((section) => section.lines)
 		.map((line, index) => ({ line, index }))
 		.filter((entry) => entry.line.row !== undefined)
+
+	return STAGES.flatMap((stage) => yielding(rows, stage))
+}
+
+// Everything that gives way, in the order it does: the rows drawn under the notes before them, the
+// processes' details before the notes, the rows above them after the thanks.
+function order_of(parts: FrameParts): Array<Yielder> {
 	const notes = parts.notes.lines.map((): Yielder => 'note')
-	const surplus = Math.max(0, notes.length - NOTES_KEPT)
 
 	return [
 		'footer',
 		'legend',
-		...notes.slice(0, surplus),
-		...yielding(rows, 'finished'),
-		...notes.slice(surplus),
+		...rows_yielding(parts.below ?? []),
+		'details',
+		...notes,
 		'thanks',
-		...yielding(rows, 'pending'),
-		...yielding(rows, 'parked'),
-		...yielding(rows, 'running'),
+		...rows_yielding(parts.plan),
 	]
 }
 
@@ -188,6 +317,7 @@ function cut_of(order: ReadonlyArray<Yielder>, count: number): Cut {
 		thanks: gone.includes('thanks'),
 		footer: gone.includes('footer'),
 		legend: gone.includes('legend'),
+		details: gone.includes('details'),
 		notes: gone.filter((item) => item === 'note').length,
 		rows: new Set(gone.filter((item) => is_line(item))),
 	}
@@ -227,4 +357,14 @@ function fit(parts: FrameParts, size: TerminalSize): Array<string> {
 const run_board_fit = { fit, height_of, whole, width_of }
 
 export { run_board_fit }
-export type { FrameParts, NotesPart, PlanLine, PlanSection, RowYield, TerminalSize, YieldStage }
+export type {
+	DetailPart,
+	FrameParts,
+	NotesPart,
+	PlanLine,
+	PlanSection,
+	RowYield,
+	SectionKey,
+	TerminalSize,
+	YieldStage,
+}

package/scripts/run/board/run-board-fold.ts

@@ -0,0 +1,123 @@
+import {
+	run_board_fit,
+	type DetailPart,
+	type FrameParts,
+	type NotesPart,
+	type PlanSection,
+	type SectionKey,
+	type TerminalSize,
+} from './run-board-fit'
+import { run_board_render_section } from './run-board-render-section'
+
+// A live `run:board`'s sections folded and unfolded by one key each (joshuafolkken/kit#4172): every
+// section starts unfolded, and what a person folds holds until the board closes — it is never saved.
+// A folded section is its heading alone, led by ▸ and saying what it holds, and the rows it gave up go
+// to the other sections before `run-board-fit.ts` cuts anything; an unfolded one's heading is led by ▾.
+
+const { folded_head, open_head } = run_board_render_section
+const SECTION_KEYS: ReadonlyMap<string, SectionKey> = new Map([
+	['l', 'lanes'],
+	['p', 'processes'],
+	['f', 'findings'],
+	['q', 'queued'],
+	['w', 'waiting'],
+	['d', 'done'],
+])
+const ALL_KEY = 'a'
+const SECTIONS: ReadonlyArray<SectionKey> = [...SECTION_KEYS.values()]
+const KEYS_LINE = ` ${[...SECTION_KEYS.keys()].join(' ')}: fold · ${ALL_KEY}: all · Ctrl-C: quit`
+
+// The live terminal a frame is kept within, the footer the frame ends on and gives way first, and the
+// sections a person folded; none for a frame that is not redrawn in place, which is drawn as it was.
+interface FrameBounds {
+	size?: TerminalSize | undefined
+	footer?: ReadonlyArray<string> | undefined
+	folded?: ReadonlySet<SectionKey> | undefined
+}
+
+interface Headed {
+	head: ReadonlyArray<string>
+	is_folded?: boolean | undefined
+}
+
+function flipped(folded: ReadonlySet<SectionKey>, section: SectionKey): ReadonlySet<SectionKey> {
+	const rest = [...folded].filter((key) => key !== section)
+
+	return new Set(folded.has(section) ? rest : [...rest, section])
+}
+
+// What a key leaves folded: `a` folds every section, or unfolds them all once every one is folded; a key
+// that names no section leaves it as it was.
+function toggled(folded: ReadonlySet<SectionKey>, key: string): ReadonlySet<SectionKey> {
+	if (key === ALL_KEY) return new Set(folded.size === SECTIONS.length ? [] : SECTIONS)
+
+	const section = SECTION_KEYS.get(key)
+
+	return section === undefined ? folded : flipped(folded, section)
+}
+
+// A part's heading: ▾ while it is open, its one ▸ line saying `summary` once it is folded.
+function headed<Part extends Headed>(part: Part, label: string, summary: string | undefined): Part {
+	if (summary === undefined) return { ...part, head: open_head(part.head, label) }
+
+	return { ...part, head: folded_head(label, summary), is_folded: true }
+}
+
+// A folded section counts its rows.
+function fold_section(section: PlanSection, folded: ReadonlySet<SectionKey>): PlanSection {
+	const { key, label } = section
+
+	if (key === undefined || label === undefined) return section
+	if (!folded.has(key)) return headed(section, label, undefined)
+
+	const count = section.lines.filter((line) => line.row !== undefined).length
+
+	return { ...headed(section, label, String(count)), lines: [] }
+}
+
+// The findings count every one there is, the ones past the section's limit too; with none there is no
+// section to fold.
+function fold_notes(notes: NotesPart, folded: ReadonlySet<SectionKey>): NotesPart {
+	const { label } = notes
+
+	if (label === undefined || notes.lines.length === 0) return notes
+	if (!folded.has('findings')) return headed(notes, label, undefined)
+
+	const count = String(notes.lines.length + notes.hidden)
+
+	return { ...headed(notes, label, count), lines: [], hidden: 0 }
+}
+
+// The processes say each group's totals.
+function fold_processes(
+	part: DetailPart | undefined,
+	folded: ReadonlySet<SectionKey>,
+): DetailPart | undefined {
+	if (part?.label === undefined) return part
+	if (!folded.has('processes')) return headed(part, part.label, undefined)
+
+	return { ...headed(part, part.label, part.summary ?? ''), lines: [] }
+}
+
+function fold_parts(parts: FrameParts, folded: ReadonlySet<SectionKey>): FrameParts {
+	return {
+		...parts,
+		plan: parts.plan.map((section) => fold_section(section, folded)),
+		below: parts.below?.map((section) => fold_section(section, folded)),
+		processes: fold_processes(parts.processes, folded),
+		notes: fold_notes(parts.notes, folded),
+	}
+}
+
+// A live frame is kept within its terminal, folded as a person folded it; any other is drawn whole.
+function bounded(parts: FrameParts, bounds: FrameBounds): Array<string> {
+	const { size, folded } = bounds
+	const shown = folded === undefined ? parts : fold_parts(parts, folded)
+
+	return size === undefined ? run_board_fit.whole(shown) : run_board_fit.fit(shown, size)
+}
+
+const run_board_fold = { KEYS_LINE, bounded, fold_parts, toggled }
+
+export { run_board_fold }
+export type { FrameBounds }

package/scripts/run/board/run-board-found.ts

@@ -0,0 +1,134 @@
+import { process_identity } from '#scripts/josh/process-identity'
+import { lane_process_table, type TableRead } from '#scripts/lane/lane-process-table'
+import { run_event_filed } from '#scripts/run/event/run-event-filed'
+import {
+	run_event_overrun,
+	type Longest,
+	type OverrunNote,
+} from '#scripts/run/event/run-event-overrun'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+
+// What a done row says after its time (joshuafolkken/kit#4772, joshuafolkken/kit#4818): the Issues
+// filed during its child's work, its lane's net minutes and what its overrun investigation came to —
+// read off the stream's `filed` events and the overrun notes (`run-event-overrun.ts`). The child's own
+// filings and the investigation's are kept apart by the event's recorded mark (joshuafolkken/kit#4880).
+
+interface Found {
+	// Each filing of the child's own session as `header.link` takes it: `4768`, or `owner/repo#12` for
+	// one filed elsewhere. An event with no overrun mark is the child's.
+	filed: ReadonlyArray<string>
+	// Each filing of the lane's overrun investigation, read off its mark (joshuafolkken/kit#4880).
+	overrun_filed: ReadonlyArray<string>
+	// The lane's net minutes, from the notes; `undefined` where none said them.
+	minutes: number | undefined
+	// The child's latest overrun note.
+	overrun: OverrunNote | undefined
+	// The longest stage the overrun's start note carried (joshuafolkken/kit#4995), kept past its end note.
+	longest: Longest | undefined
+	// The latest note is the investigation's start and its session is alive; `undefined` where its start
+	// token could not be read, so neither its life nor its death is known.
+	is_investigating: boolean | undefined
+}
+
+// By the child's number.
+type FoundOf = ReadonlyMap<number, Found>
+
+// Whether the process a start note names — its pid and start token — is still there, one this reader
+// may not signal included, `undefined` where the note carries no start token; injected, so a test never
+// probes one.
+type IsLive = (pid: number, start: string | undefined) => boolean | undefined
+
+const KIND = run_event_stream.EVENT_KIND
+const NONE: Found = {
+	filed: [],
+	overrun_filed: [],
+	minutes: undefined,
+	overrun: undefined,
+	longest: undefined,
+	is_investigating: false,
+}
+
+// The child a filing was found during, the reference the board draws, and whether the overrun filed it.
+type FiledEntry = readonly [number, string, boolean]
+
+function filed_entry(event: RunEvent): ReadonlyArray<FiledEntry> {
+	const filed = event.kind === KIND.FILED ? run_event_filed.parse(event.text) : undefined
+
+	if (filed?.found_during === undefined) return []
+
+	return [
+		[Number(filed.found_during), filed.reference.replace(/^#/u, ''), filed.is_overrun === true],
+	]
+}
+
+function with_filed(known: Found, reference: string, is_overrun: boolean): Found {
+	if (is_overrun) return { ...known, overrun_filed: [...known.overrun_filed, reference] }
+
+	return { ...known, filed: [...known.filed, reference] }
+}
+
+function overrun_note(event: RunEvent): OverrunNote | undefined {
+	return event.kind === KIND.NOTE ? run_event_overrun.parse(event.text) : undefined
+}
+
+// The minutes a note carries, else the ones an earlier note did: an end note carries none.
+function minutes_of(note: OverrunNote, known: number | undefined): number | undefined {
+	return 'minutes' in note ? (note.minutes ?? known) : known
+}
+
+// A session that died before its end note turns no spinner, nor does a later process given its pid.
+function noted(found: Found, note: OverrunNote, is_live: IsLive): Found {
+	return {
+		...found,
+		minutes: minutes_of(note, found.minutes),
+		overrun: note,
+		longest: note.kind === 'started' ? note.longest : found.longest,
+		is_investigating: note.kind === 'started' ? is_live(note.pid, note.start) : false,
+	}
+}
+
+function add_filed(found: Map<number, Found>, events: ReadonlyArray<RunEvent>): void {
+	const entries = events.flatMap((event) => filed_entry(event))
+
+	for (const [issue, reference, is_overrun] of entries) {
+		found.set(issue, with_filed(found.get(issue) ?? NONE, reference, is_overrun))
+	}
+}
+
+// Each child's latest overrun note decides what its row says.
+function add_overrun(
+	found: Map<number, Found>,
+	events: ReadonlyArray<RunEvent>,
+	is_live: IsLive,
+): void {
+	const notes = events.flatMap((event) => overrun_note(event) ?? [])
+
+	for (const note of notes) {
+		found.set(note.issue, noted(found.get(note.issue) ?? NONE, note, is_live))
+	}
+}
+
+function found_of(events: ReadonlyArray<RunEvent>, is_live: IsLive): FoundOf {
+	const found = new Map<number, Found>()
+
+	add_filed(found, events)
+	add_overrun(found, events, is_live)
+
+	return found
+}
+
+// The board's own probe, each start time answered from the read's own `ps` snapshot, so neither the
+// read nor a redraw runs a `ps` of its own per note (joshuafolkken/kit#4263). The pid alone reads a
+// later process given that pid as the session, so the start token decides; a note without one — a
+// platform that could not read it — is known dead only once its pid is gone.
+async function live_in(table: TableRead | undefined): Promise<IsLive> {
+	const rows = table === undefined ? undefined : await table()
+	const read = lane_process_table.start_reader(rows ?? [])
+
+	return (pid, start) => process_identity.is_present_process(pid, start, read)
+}
+
+const run_board_found = { found_of, live_in }
+
+export { run_board_found }
+export type { Found, FoundOf, IsLive }

package/scripts/run/board/run-board-fresh.ts

@@ -1,5 +1,5 @@
 import { styleText } from 'node:util'
-import { run_progress } from '#scripts/run/progress/run-progress'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 
 // **The one place a freshly updated part of `run:board` is emphasized** — the header's `💓` and third
 // line, an issue row's phase, start and end (joshuafolkken/kit#3784). The emphasis fades in three
@@ -17,7 +17,7 @@ interface FreshFrame {
 	spinner: string | undefined
 }
 
-const STAGE_MS = run_progress.MS_PER_SECOND
+const STAGE_MS = MS_PER_SECOND
 const FADING: ReadonlyArray<FreshStage> = ['inverse', 'bold-color', 'bold']
 const FORMATS: Readonly<Record<Exclude<FreshStage, 'none'>, TextFormat>> = {
 	inverse: 'inverse',

package/scripts/run/board/run-board-gather-live.ts

@@ -0,0 +1,29 @@
+import { setTimeout as sleep } from 'node:timers/promises'
+import { core_budget } from '#scripts/gate/core-budget'
+import { machine_capacity } from '#scripts/gate/machine-capacity'
+import { lane_process_table } from '#scripts/lane/lane-process-table'
+import type { GatherPorts } from './run-board-gather'
+import { run_board_read } from './run-board-read'
+import { run_board_usage_read } from './run-board-usage-read'
+
+// The live reads off this machine, shared by the live board's worker thread
+// (`run-board-gather-worker.ts`) and the single frame that reads where it draws.
+
+function ports_of(is_live: boolean): GatherPorts {
+	return {
+		read_table: lane_process_table.read_table,
+		read_local: run_board_read.read_local,
+		read_machine: machine_capacity.read_sample,
+		read_waits: () => core_budget.budget_waits(),
+		read_usage: run_board_usage_read.usage_reader(),
+		is_live,
+		now: () => Date.now(),
+		sleep: async (ms) => {
+			await sleep(ms)
+		},
+	}
+}
+
+const run_board_gather_live = { ports_of }
+
+export { run_board_gather_live }