@joshuafolkken/kit 1.1514.0 → 1.1784.0

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

@@ -0,0 +1,54 @@
+import { process_identity } from '#scripts/josh/process-identity'
+import { lane_process_table, type TableRead } from '#scripts/lane/lane-process-table'
+import type { CarryRead } from '#scripts/run/carry/run-carry'
+import { run_wake } from '#scripts/run/wake/run-wake'
+import type { ProcessRoots } from './run-board-process-groups'
+
+// The run's own processes the 💻 section names: the supervisor from its wake stamp and the parent
+// session from the run's record. A pid whose start no longer matches is another process now, so it is
+// dropped; one recorded without a start is kept.
+
+type SameProcess = (pid: number | undefined, start: string | undefined) => boolean | undefined
+
+function root_of(
+	pid: number | undefined,
+	start: string | undefined,
+	is_same: SameProcess,
+): number | undefined {
+	return is_same(pid, start) === false ? undefined : pid
+}
+
+function supervisor_of(repository: string, is_same: SameProcess): number | undefined {
+	const wake = run_wake.read_wake(run_wake.wake_path(repository))
+
+	return wake === undefined ? undefined : root_of(wake.pid, wake.process_start, is_same)
+}
+
+function parent_of(read: CarryRead, is_same: SameProcess): number | undefined {
+	if (read.kind !== 'carried') return undefined
+
+	return root_of(read.carry.owner_pid, read.carry.owner_start, is_same)
+}
+
+function roots_of(
+	repository: string,
+	read: CarryRead,
+	is_same: SameProcess = process_identity.is_same_process,
+): ProcessRoots {
+	return { supervisor: supervisor_of(repository, is_same), parent: parent_of(read, is_same) }
+}
+
+// `is_same_process` with each start time answered from the redraw's own `ps` snapshot, so the board's
+// read runs no `ps` of its own per pid (joshuafolkken/kit#4263). Without a snapshot no start is known,
+// and a recorded start reads as "cannot tell".
+async function same_in(table: TableRead | undefined): Promise<SameProcess> {
+	const rows = table === undefined ? undefined : await table()
+	const read = lane_process_table.start_reader(rows ?? [])
+
+	return (pid, start) => process_identity.is_same_process(pid, start, read)
+}
+
+const run_board_roots = { roots_of, same_in }
+
+export { run_board_roots }
+export type { SameProcess }

package/scripts/run/board/run-board-row-yield.ts

@@ -5,16 +5,19 @@ import type { ItemState } from './run-board-status'
 // When an issue row gives way to a short pane (`run-board-fit.ts`): the stage its state yields in,
 // and how old it is within that stage.
 
-// The stage each state's row gives way in when the pane is short.
+// The stage each state's row gives way in when the pane is short. A row waiting on a person's decision
+// stays as long as a running one (joshuafolkken/kit#4099).
 const YIELD_STAGES: Readonly<Record<ItemState, YieldStage>> = {
 	merged: 'finished',
 	done: 'finished',
 	withdrawn: 'finished',
 	waiting: 'pending',
-	human: 'pending',
+	human: 'decision',
 	parked: 'parked',
 	stopped: 'parked',
+	unknown: 'parked',
 	running: 'running',
+	paused: 'running',
 }
 
 // A running row is as old as its start; a settled one as its end, or its start where it has none.
@@ -24,8 +27,10 @@ function aged_ms(row: BoardRow): number | undefined {
 	return row.state === 'running' ? started : (row.status?.ended_ms ?? started)
 }
 
-function yield_of(row: BoardRow): RowYield {
-	return { stage: YIELD_STAGES[row.state], at_ms: aged_ms(row) }
+// The stage is the state's, unless the row's section gives it way as one — the 🔗 waiting rows before
+// the findings.
+function yield_of(row: BoardRow, stage: YieldStage = YIELD_STAGES[row.state]): RowYield {
+	return { stage, at_ms: aged_ms(row) }
 }
 
 const run_board_row_yield = { yield_of }

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

@@ -71,17 +71,6 @@ function names(event: RunEvent, issue: number): boolean {
 	return Number(run_event_scope.issue_named(event)) === issue
 }
 
-// A lane the stream saw no launch for is not yet this run's child when the run says it is still
-// setting up: it has launched nothing at all, so any lane here is an earlier run's, or it is opening
-// this very lane. A stream with no stage on it says neither, and the lane is read as before.
-function is_lane_pending(events: ReadonlyArray<RunEvent>, issue: number): boolean {
-	const stages = events.filter((event) => is_setup(event))
-
-	if (stages.length === 0) return false
-
-	return !has_launched(events) || stages.some((stage) => names(stage, issue))
-}
-
 // A stage of one lane's launch, as its event wrote it, and when the lane entered it.
 interface LaneStage {
 	text: string
@@ -115,7 +104,7 @@ function lane_stage(events: ReadonlyArray<RunEvent>, issue: number): LaneStage |
 	return { text: step.text, at_ms: Date.parse(step.at) }
 }
 
-const run_board_setup = { is_lane_pending, lane_stage, read }
+const run_board_setup = { lane_stage, read }
 
 export { run_board_setup }
 export type { LaneStage, SetupRead }

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

@@ -0,0 +1,111 @@
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { z } from 'zod'
+import type { ClosedIssue } from './run-board-closed'
+
+// The last GitHub reads a `run:board` drew — the titles, the labels and the children read closed — kept
+// in one file per checkout, so a board opened again draws them at once rather than nameless until its
+// first read lands. A snapshot holds for the run it was written in; a board on another run discards it.
+// The board never stops on it: a snapshot that is missing, unreadable or malformed is no snapshot, and a
+// write that fails is dropped.
+
+const SNAPSHOT_PREFIX = 'josh-run-board-snapshot-'
+
+// The titles and labels the board names each issue's row by.
+interface Known {
+	titles: ReadonlyMap<number, string>
+	labels: ReadonlyMap<number, ReadonlyArray<string>>
+}
+
+interface Snapshot extends Known {
+	run_started_ms: number
+	closed: ReadonlyMap<number, ClosedIssue>
+}
+
+// Where a board keeps its snapshot; a board with none keeps nothing.
+interface SnapshotStore {
+	load: () => Snapshot | undefined
+	save: (snapshot: Snapshot) => void
+}
+
+const NO_KNOWN: Known = { titles: new Map(), labels: new Map() }
+
+const label_names_schema = z.array(z.string())
+
+// A close time JSON dropped is read back as unknown.
+const closed_issue_schema = z
+	.object({
+		title: z.string(),
+		labels: label_names_schema,
+		closed_ms: z.number().optional(),
+		is_merged: z.boolean(),
+		is_not_planned: z.boolean(),
+	})
+	.transform((view): ClosedIssue => ({ ...view, closed_ms: view.closed_ms }))
+
+const title_entry_schema = z.tuple([z.number(), z.string()])
+const label_entry_schema = z.tuple([z.number(), label_names_schema])
+const closed_entry_schema = z.tuple([z.number(), closed_issue_schema])
+
+const snapshot_schema = z.object({
+	run_started_ms: z.number(),
+	titles: z.array(title_entry_schema),
+	labels: z.array(label_entry_schema),
+	closed: z.array(closed_entry_schema),
+})
+
+function snapshot_of(text: string): Snapshot | undefined {
+	try {
+		const parsed = snapshot_schema.safeParse(JSON.parse(text))
+
+		if (!parsed.success) return undefined
+
+		const { run_started_ms, titles, labels, closed } = parsed.data
+
+		return {
+			run_started_ms,
+			titles: new Map(titles),
+			labels: new Map(labels),
+			closed: new Map(closed),
+		}
+	} catch {
+		return undefined
+	}
+}
+
+function load(target: string): Snapshot | undefined {
+	const text = stamp_file.read_stamp_text(target)
+
+	return text === undefined ? undefined : snapshot_of(text)
+}
+
+function save(target: string, snapshot: Snapshot): void {
+	const payload = {
+		run_started_ms: snapshot.run_started_ms,
+		titles: [...snapshot.titles],
+		labels: [...snapshot.labels],
+		closed: [...snapshot.closed],
+	}
+
+	try {
+		stamp_file.replace_stamp(target, payload)
+	} catch {
+		// The next landed read writes it again.
+	}
+}
+
+function file_store(
+	target: string = stamp_file.stamp_path(SNAPSHOT_PREFIX, PROJECT_ROOT),
+): SnapshotStore {
+	return {
+		load: () => load(target),
+		save: (snapshot) => {
+			save(target, snapshot)
+		},
+	}
+}
+
+const run_board_snapshot = { NO_KNOWN, file_store }
+
+export { run_board_snapshot }
+export type { Known, Snapshot, SnapshotStore }

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

@@ -1,5 +1,5 @@
 import { stripVTControlCharacters } from 'node:util'
-import { run_progress } from '#scripts/run/progress/run-progress'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import string_width from 'string-width'
 import { run_board_fit, type TerminalSize } from './run-board-fit'
 import { run_board_labels } from './run-board-labels'
@@ -14,7 +14,7 @@ import type { BoardPorts } from './run-board-state'
 
 // A private-use character one column wide, as a spinner frame is, so the frame is fitted the same.
 const SPOT = '\u{E000}'
-const REDRAW_MS = run_progress.MS_PER_SECOND
+const REDRAW_MS = MS_PER_SECOND
 const CSI = '\u{1B}['
 const RESET = `${CSI}0m`
 // eslint-disable-next-line no-control-regex -- the color escapes a spot keeps are control characters

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

@@ -1,33 +1,29 @@
 import type { NamedPlan } from '#scripts/backlog/backlog-plan'
-import type { BudgetWait } from '#scripts/gate/core-wait'
-import type { MachineSample } from '#scripts/gate/machine-capacity'
 import type { ClosedAnswer, ClosedIssue } from './run-board-closed'
 import type { Fetch } from './run-board-fetch'
-import type { TerminalSize } from './run-board-fit'
+import type { SectionKey, TerminalSize } from './run-board-fit'
+import type { Gatherer, GatherRead } from './run-board-gather'
 import type { BoardForm } from './run-board-header'
-import { run_board_idle, type IdleSince } from './run-board-idle'
+import { run_board_idle } from './run-board-idle'
+import type { KeyInput } from './run-board-keys'
 import type { BoardPlan } from './run-board-layout'
 import type { Link } from './run-board-link'
-import type { MachineGauges, MachineMark } from './run-board-machine'
-import type { LocalRead } from './run-board-read'
+import { run_board_snapshot, type Known, type SnapshotStore } from './run-board-snapshot'
 import type { Spot } from './run-board-spin'
 import type { Thanks } from './run-board-thanks-csv'
-import type { LaneUsages, UsageMark } from './run-board-usage'
 
 // What a `run:board` redraw reads through and folds forward, shared by the
 // redraw (`run-board-tick.ts`) and its GitHub reads (`run-board-github.ts`).
 
 interface BoardPorts {
 	read_plan: (scope: NamedPlan) => Promise<BoardPlan | undefined>
-	// `undefined` when no run has started here.
-	read_local: () => Promise<LocalRead | undefined>
-	read_machine: () => Promise<MachineSample>
-	// The claims waiting in the core budget, read on the machine's second; none where it is not given.
-	read_waits?: (() => Array<BudgetWait>) | undefined
-	// Every process and its lane, the last reading's lanes reused (`run-board-usage-read.ts`).
-	read_usage: (before: UsageMark | undefined) => Promise<UsageMark | undefined>
+	// The reads off this machine a redraw draws from (`run-board-gather.ts`): a live board's come from
+	// a worker thread, so no read stops its spinner.
+	gather: Gatherer
 	// The issues that answered as closed, and whether every issue answered (`run-board-closed.ts`).
 	read_closed: (issues: ReadonlyArray<number>) => Promise<ClosedAnswer>
+	// Where the last GitHub reads are kept between boards (`run-board-snapshot.ts`); none keeps nothing.
+	snapshot?: SnapshotStore | undefined
 	now: () => number
 	write: (frame: string) => void
 	// Wraps an issue number in a hyperlink where the terminal opens one, and leaves it plain elsewhere.
@@ -39,6 +35,10 @@ interface BoardPorts {
 	size?: (() => TerminalSize) | undefined
 	// The lines a live frame ends on, the first to give way to a short pane.
 	footer?: ReadonlyArray<string> | undefined
+	// The keyboard a live board folds its sections from (`run-board-keys.ts`); none where nobody types.
+	keys?: KeyInput | undefined
+	// The sections a person folded, read at every redraw; none where the frame folds nothing.
+	folded?: (() => ReadonlySet<SectionKey>) | undefined
 	form: BoardForm
 	// Records that a progress report was just given, as `run:progress --mark` does, so the next scheduled
 	// one waits a full interval from here.
@@ -56,15 +56,13 @@ interface BoardPorts {
 // drawing.
 type Pace = 'background' | 'settled'
 
-interface BoardState {
-	// The last local read, drawn until the next is due; `undefined` when no run had started.
-	local: LocalRead | undefined
-	read_ms: number | undefined
-	// When each lane the reads found idle was first read so (`run-board-idle.ts`).
-	idle_since: IdleSince
+// The last reads off this machine, then what the board folds over them.
+interface BoardState extends GatherRead {
 	// The start of the run the plan state was built for, so a run that begins draws nothing of the last.
 	run_started_ms: number | undefined
 	plan: BoardPlan | undefined
+	// The titles and labels drawn before this board's first plan lands — the last board's snapshot.
+	known: Known
 	// The plan read in flight, `undefined` once it has been folded in.
 	plan_fetch: Fetch<BoardPlan | undefined> | undefined
 	attempted_ms: number | undefined
@@ -75,20 +73,12 @@ interface BoardState {
 	closed: ReadonlyMap<number, ClosedIssue>
 	closed_fetch: Fetch<ClosedAnswer> | undefined
 	closed_attempted_ms: number | undefined
+	// The children the last closed read asked about — a child not among them is asked without waiting.
+	closed_asked: ReadonlySet<number>
 	// The last ask every child answered, open or closed; a failed read leaves it where it was.
 	closed_answered_ms: number | undefined
-	// The last machine sample, which the next one is compared against, and the gauges drawn from them.
-	machine: MachineMark | undefined
-	gauges: MachineGauges | undefined
-	// The redraw the last sample was taken on, which the next sample is due a second after.
-	sampled_ms: number | undefined
 	// Where the last frame drew its spinners, turned between redraws.
 	spots: ReadonlyArray<Spot>
-	// The last process reading, which the next one is compared against, and each lane's usage drawn from
-	// them.
-	usage: UsageMark | undefined
-	usages: LaneUsages | undefined
-	budget_waits: ReadonlyArray<BudgetWait>
 	// The reviewers drawn above the legend, the read of them in flight, and when it was last launched.
 	thanks: Thanks
 	thanks_fetch: Fetch<Thanks> | undefined
@@ -101,6 +91,7 @@ const FRESH_STATE: BoardState = {
 	idle_since: run_board_idle.NO_IDLE,
 	run_started_ms: undefined,
 	plan: undefined,
+	known: run_board_snapshot.NO_KNOWN,
 	plan_fetch: undefined,
 	attempted_ms: undefined,
 	fetched_ms: undefined,
@@ -109,12 +100,10 @@ const FRESH_STATE: BoardState = {
 	closed: new Map(),
 	closed_fetch: undefined,
 	closed_attempted_ms: undefined,
+	closed_asked: new Set(),
 	closed_answered_ms: undefined,
-	machine: undefined,
 	gauges: undefined,
-	sampled_ms: undefined,
 	spots: [],
-	usage: undefined,
 	usages: undefined,
 	budget_waits: [],
 	thanks: [],