@joshuafolkken/kit 1.1514.0 → 1.1784.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,42 +37,75 @@ 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(),
+}
 
 // The columns a line takes on screen: its color escapes take none, an emoji two.
 function width_of(line: string): number {
@@ -92,25 +125,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)
+}
+
+// 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 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 [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.slice(0, last + 1).map((line) => line.text)]
+	return [...section.head, ...kept, ...fold_lines(section, cut)]
 }
 
-// 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 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 [...lead, ...drawn, ...more_lines(cut.size)]
+	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 +176,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 +246,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 +294,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 +334,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-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 }

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

@@ -0,0 +1,189 @@
+import { isDeepStrictEqual } from 'node:util'
+import { Worker } from 'node:worker_threads'
+import {
+	run_board_gather,
+	type Gatherer,
+	type GatherPorts,
+	type GatherRead,
+	type GatherState,
+} from './run-board-gather'
+import type { LocalRead } from './run-board-read'
+
+// The live board's side of its worker thread (`run-board-gather-worker.ts`): the worker takes the
+// reads off this machine and hands each round over; a redraw draws the last one it handed, so no read
+// stops the board's spinner. A round that throws is handed over as failed, and the worker reads again
+// next round; a worker that dies is said on the board, and started again on the next redraw — there is
+// no other place the reads are taken.
+
+const WORKER_URL = new URL('run-board-gather-worker.ts', import.meta.url)
+const EMPTY_READ = run_board_gather.read_of(run_board_gather.FRESH_GATHER)
+
+// The run's read as the worker hands it over. A stream read again unchanged is not handed over — the
+// board keeps its own array, so the folds it keyed on that array are not folded again.
+interface LocalPost {
+	value: LocalRead | undefined
+	is_same_events?: boolean | undefined
+}
+
+// One round as the worker hands it over: the run's read only when it was read again, so the board
+// does not copy the whole stream every second.
+interface GatherPost {
+	read: Omit<GatherRead, 'local'>
+	local?: LocalPost | undefined
+}
+
+// A round whose reads threw, handed over with why; the worker reads again next round.
+interface FailedPost {
+	failed: string
+}
+
+// The part of a worker the board listens to.
+interface GatherWorker {
+	on: (event: 'message' | 'error' | 'exit', listener: (value: unknown) => void) => unknown
+	unref: () => void
+}
+
+type Spawn = () => GatherWorker
+
+interface Thread {
+	worker: GatherWorker | undefined
+	latest: GatherRead | undefined
+	waiting: Array<(read: GatherRead) => void>
+}
+
+function local_post(before: LocalRead | undefined, after: LocalRead | undefined): LocalPost {
+	if (before === undefined || after === undefined) return { value: after }
+	if (!isDeepStrictEqual(before.events, after.events)) return { value: after }
+
+	return { value: { ...after, events: [] }, is_same_events: true }
+}
+
+function post_of(before: GatherState, after: GatherState): GatherPost {
+	const { local, ...read } = run_board_gather.read_of(after)
+	const is_reread = after.read_ms !== before.read_ms
+
+	return { read, local: is_reread ? local_post(before.local, local) : undefined }
+}
+
+function is_post(value: unknown): value is GatherPost {
+	return typeof value === 'object' && value !== null && 'read' in value
+}
+
+// What a failure is said as: the first line of its message.
+function reason_of(error: unknown): string {
+	const message = error instanceof Error ? error.message : String(error)
+
+	return message.split('\n', 1)[0] ?? ''
+}
+
+function failed_of(error: unknown): FailedPost {
+	return { failed: reason_of(error) }
+}
+
+// One round on the worker: the reads handed over, or why they threw — the state kept for the next.
+async function gather_round(
+	state: GatherState,
+	ports: GatherPorts,
+	post: (value: GatherPost | FailedPost) => void,
+): Promise<GatherState> {
+	try {
+		const next = await run_board_gather.gather(state, ports, 'background')
+
+		post(post_of(state, next))
+
+		return next
+	} catch (error) {
+		post(failed_of(error))
+
+		return state
+	}
+}
+
+function is_failed(value: unknown): value is FailedPost {
+	return typeof value === 'object' && value !== null && 'failed' in value
+}
+
+function settle(thread: Thread, read: GatherRead): void {
+	thread.latest = read
+
+	for (const resolve of thread.waiting.splice(0)) resolve(read)
+}
+
+function local_of(thread: Thread, post: LocalPost): LocalRead | undefined {
+	const { value, is_same_events } = post
+	const kept = thread.latest?.local
+
+	if (is_same_events !== true || value === undefined || kept === undefined) return value
+
+	return { ...value, events: kept.events }
+}
+
+function receive(thread: Thread, post: GatherPost): void {
+	const local = post.local === undefined ? thread.latest?.local : local_of(thread, post.local)
+
+	settle(thread, { ...post.read, local, read_failed_ms: undefined, read_error: undefined })
+}
+
+// A failed read keeps the last round on screen, said failed and why until the next answers.
+function said_failed(thread: Thread, reason: string, now: () => number): void {
+	settle(thread, { ...(thread.latest ?? EMPTY_READ), read_failed_ms: now(), read_error: reason })
+}
+
+// A worker that threw or exited is started again on the next redraw.
+function fail(thread: Thread, worker: GatherWorker, reason: string, now: () => number): void {
+	if (thread.worker !== worker) return
+
+	thread.worker = undefined
+	said_failed(thread, reason, now)
+}
+
+function listen(thread: Thread, worker: GatherWorker, now: () => number): void {
+	worker.on('message', (value) => {
+		if (is_post(value)) receive(thread, value)
+		else if (is_failed(value)) said_failed(thread, value.failed, now)
+	})
+	worker.on('error', (error) => {
+		fail(thread, worker, reason_of(error), now)
+	})
+	worker.on('exit', (code) => {
+		fail(thread, worker, `exit ${String(code)}`, now)
+	})
+}
+
+function start(thread: Thread, spawn: Spawn, now: () => number): GatherWorker {
+	const worker = spawn()
+
+	listen(thread, worker, now)
+	// The board's own loop keeps the process; the worker never holds it open past the board.
+	worker.unref()
+
+	return worker
+}
+
+async function latest_of(thread: Thread): Promise<GatherRead> {
+	if (thread.latest !== undefined) return thread.latest
+
+	return await new Promise((resolve) => {
+		thread.waiting.push(resolve)
+	})
+}
+
+function spawn_worker(): GatherWorker {
+	return new Worker(WORKER_URL)
+}
+
+// The first redraw waits for the worker's first round; every later one draws the last round handed.
+function worker_gatherer(spawn: Spawn = spawn_worker, now: () => number = Date.now): Gatherer {
+	const thread: Thread = { worker: undefined, latest: undefined, waiting: [] }
+
+	return async () => {
+		thread.worker ??= start(thread, spawn, now)
+
+		return await latest_of(thread)
+	}
+}
+
+const run_board_gather_thread = { WORKER_URL, gather_round, post_of, worker_gatherer }
+
+export { run_board_gather_thread }
+export type { FailedPost, GatherPost, GatherWorker }