@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/run/board/run-board-render-tail.ts

@@ -1,28 +1,37 @@
 import { styleText } from 'node:util'
-import { backlog_budget } from '#scripts/backlog/backlog-budget'
+import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import type { PrChecks } from '#scripts/run/event/run-event-checks'
+import { run_board_earlier } from './run-board-earlier'
 import { run_board_header, type BoardHeader } from './run-board-header'
 import { run_board_labels, type TextColor } from './run-board-labels'
-import type { BoardRow } from './run-board-layout'
+import { run_board_layout, type BoardRow } from './run-board-layout'
 import { run_board_now, type TimedLine } from './run-board-now'
 import type { Phase } from './run-board-phase'
 import { run_board_render_checks } from './run-board-render-checks'
-
-// The end of a running row (joshuafolkken/kit#3769): how long the child has stood at the phase its row
-// leads with, then the kind and the age of the newest thing it did. Both are the row's own `MM:SS`, the
-// minutes never carried into hours (`61:05`). The phase's time is right-aligned to the widest any
-// running row draws, so a three-digit `125:30` and a `00:40` end in one column and the age after them
-// starts in one column whichever row it is on — where the phase track before them grew with every
-// round. A settled or a waiting row draws neither.
-
-const { NOW_ICONS, elapsed_of } = run_board_labels
+import { run_board_render_waits } from './run-board-render-waits'
+
+// The end of a running row (joshuafolkken/kit#3769, #4043, #4292): the kind and the age of the newest
+// thing the child did, the board's own length (`1°01′05″`), right-aligned to the widest any running
+// row draws, so a `2°05′30″` and a `40″` end in one column. The phase's icon and how long the child has
+// stood at it lead the row (`run-board-render-lead.ts`), so the event that entered the phase is not
+// drawn again here. A settled or a waiting row draws none. A lane held in the core budget draws the
+// check it holds in the newest activity's place (#4052), its reason and time leading the row.
+
+const { PHASE_ICONS, span_of } = run_board_labels
+const { is_live } = run_board_earlier
+const { check_of, held_of } = run_board_render_waits
 // A phase past twice its usual time is drawn as long, past three times as alarming.
 const LONG_FACTOR = 2
 const ALARM_FACTOR = 3
 // The least a usual time counts as: the ledger's median for a stage of seconds (preflight, sync,
 // report) is near zero, and scaled as it is it would draw a healthy few-second stage as alarming.
 const USUAL_FLOOR_MINUTES = 2
-const USUAL_FLOOR_MS = USUAL_FLOOR_MINUTES * backlog_budget.MS_PER_MINUTE
+const USUAL_FLOOR_MS = USUAL_FLOOR_MINUTES * MS_PER_MINUTE
+
+interface TimedActivity {
+	icon: string
+	since_ms: number
+}
 
 function phase_color(elapsed_ms: number, usual_ms: number | undefined): TextColor | undefined {
 	if (usual_ms === undefined) return undefined
@@ -45,32 +54,40 @@ function current_of(row: BoardRow): { phase: Phase; since_ms: number } | undefin
 	return phase === undefined || phase_ms === undefined ? undefined : { phase, since_ms: phase_ms }
 }
 
-// The phase column's width: the widest phase time any running row draws in this frame, and `MM:SS`'s
-// at the least, so a row with none still blanks a column's width.
-function phase_width(header: BoardHeader): number {
-	const spans = (header.layout?.active ?? []).map((row) => {
-		const current = row.state === 'running' ? current_of(row) : undefined
+// A column's width: the widest span `age_of` gives any running row or earlier run's lane in this
+// frame, and `0″`'s at the least, so a row with none still blanks a column's width.
+function column_width(header: BoardHeader, age_of: (row: BoardRow) => number | undefined): number {
+	const rows = run_board_layout.lane_rows(header.layout ?? run_board_layout.EMPTY_LAYOUT, [])
+	const spans = rows.map((row) => {
+		const age = is_live(row) ? age_of(row) : undefined
 
-		return current === undefined ? 0 : elapsed_of(header.now_ms - current.since_ms).length
+		return age === undefined ? 0 : span_of(age).length
 	})
 
-	return Math.max(elapsed_of(0).length, ...spans)
+	return Math.max(span_of(0).length, ...spans)
 }
 
-// How long the child has stood at its phase, colored against the phase's usual time; blanks where no
-// event said when it got there, so the age after it still starts in its column.
-function phase_part(row: BoardRow, header: BoardHeader): string {
-	const current = current_of(row)
-	const width = phase_width(header)
+// How long the child has stood at its phase, right-aligned to `width` and colored against the phase's
+// usual time; blanks where no event said when it got there, so what follows still starts in its column.
+function phase_time(row: BoardRow, header: BoardHeader, width: number): string {
+	const current = is_live(row) ? current_of(row) : undefined
 
 	if (current === undefined) return ' '.repeat(width)
 
 	const elapsed = header.now_ms - current.since_ms
-	const text = elapsed_of(elapsed).padStart(width)
+	const text = span_of(elapsed).padStart(width)
 
 	return tinted(text, phase_color(elapsed, header.usual?.get(current.phase)))
 }
 
+// The icon of the phase a running row's end draws, `undefined` where it draws blanks — named by the
+// legend, since a held row leads with 🚧 instead.
+function phase_icon(row: BoardRow): string | undefined {
+	const current = is_live(row) ? current_of(row) : undefined
+
+	return current === undefined ? undefined : PHASE_ICONS[current.phase]
+}
+
 // The newer of the child's newest operation and its newest event, read as the header's third line
 // reads it, so the two never disagree on what is newest.
 function newest_of(row: BoardRow, header: BoardHeader): TimedLine | undefined {
@@ -81,48 +98,98 @@ function newest_of(row: BoardRow, header: BoardHeader): TimedLine | undefined {
 	})
 }
 
-// The newest activity as its kind's icon and its age, aged as the `💓` is.
-function activity_part(row: BoardRow, header: BoardHeader): string | undefined {
+// The newest activity with when it happened, `undefined` where nothing said when.
+function newest_timed(row: BoardRow, header: BoardHeader): TimedActivity | undefined {
 	const newest = newest_of(row, header)
+	const since_ms = newest?.since_ms
 
-	if (newest?.since_ms === undefined) return undefined
-
-	const age = header.now_ms - newest.since_ms
+	return newest === undefined || since_ms === undefined
+		? undefined
+		: { icon: newest.icon, since_ms }
+}
 
-	return run_board_header.aged(`${newest.icon} ${elapsed_of(age)}`, age)
+// A running row whose lane no core-budget wait holds.
+function is_free(row: BoardRow, header: BoardHeader): boolean {
+	return is_live(row) && held_of(row, header) === undefined
 }
 
 // A row in followup with its pull request's checks on the stream (joshuafolkken/kit#3770), whose end
-// draws them in place of its newest activity.
+// draws them in place of its newest activity — unless its lane is held, whose wait is drawn instead.
 function checks_of(row: BoardRow, header: BoardHeader): PrChecks | undefined {
-	if (row.state !== 'running' || current_of(row)?.phase !== 'followup') return undefined
+	if (!is_free(row, header) || current_of(row)?.phase !== 'followup') return undefined
 
 	return header.activity.pr_checks?.get(row.number)
 }
 
-// A running row's end, nothing for any other.
-function tail_of(row: BoardRow, header: BoardHeader): Array<string | undefined> {
-	if (row.state !== 'running') return []
+// The event that entered the row's phase, whose time the phase part already draws.
+function is_phase_event(newest: TimedActivity, row: BoardRow): boolean {
+	return newest.since_ms === current_of(row)?.since_ms
+}
 
-	const checks = checks_of(row, header)
-	const last =
-		checks === undefined ? activity_part(row, header) : run_board_render_checks.checks_part(checks)
+// The newest activity a running row's end draws: none where the row draws its checks or its wait in
+// its place, nor where it is the event that entered the phase.
+function drawn_activity(row: BoardRow, header: BoardHeader): TimedActivity | undefined {
+	if (!is_free(row, header) || checks_of(row, header) !== undefined) return undefined
 
-	return [phase_part(row, header), last]
+	const newest = newest_timed(row, header)
+
+	if (newest === undefined || is_phase_event(newest, row)) return undefined
+
+	return newest
 }
 
-// Whether a row draws its pull request's checks, so the legend names them.
-function is_checks_drawn(row: BoardRow, header: BoardHeader): boolean {
-	return checks_of(row, header) !== undefined
+function activity_age(row: BoardRow, header: BoardHeader): number | undefined {
+	const newest = drawn_activity(row, header)
+
+	return newest === undefined ? undefined : header.now_ms - newest.since_ms
 }
 
-// Whether a row draws the operation's icon, so the legend names it.
-function is_operation_drawn(row: BoardRow, header: BoardHeader): boolean {
-	if (row.state !== 'running' || is_checks_drawn(row, header)) return false
+// The newest activity as its kind's icon and its age, aged as the `💓` is; nothing where the row draws
+// none.
+function activity_part(row: BoardRow, header: BoardHeader): string {
+	const newest = drawn_activity(row, header)
+
+	if (newest === undefined) return ''
 
-	return newest_of(row, header)?.icon === NOW_ICONS.operation
+	const width = column_width(header, (other) => activity_age(other, header))
+	const age = header.now_ms - newest.since_ms
+
+	return run_board_header.aged(`${newest.icon} ${span_of(age).padStart(width)}`, age)
+}
+
+// Whether a row ends on a tail: a running row and an earlier run's lane only.
+function is_tailed(row: BoardRow): boolean {
+	return is_live(row)
 }
 
-const run_board_render_tail = { is_checks_drawn, is_operation_drawn, tail_of }
+// A running row's end — the check its held lane waits to run, its pull request's checks in followup,
+// or its newest activity — and nothing for any other row.
+function tail_of(row: BoardRow, header: BoardHeader): Array<string> {
+	if (!is_tailed(row)) return []
+
+	const held = held_of(row, header)
+
+	if (held !== undefined) return [check_of(held)]
+
+	const checks = checks_of(row, header)
+
+	if (checks !== undefined) return [run_board_render_checks.checks_part(checks)]
+
+	return [activity_part(row, header)]
+}
+
+// The icon a row's end draws for its newest activity, so the legend names it — none where the row
+// draws its checks, its wait or the phase's own event in its place.
+function activity_icon(row: BoardRow, header: BoardHeader): string | undefined {
+	return drawn_activity(row, header)?.icon
+}
+
+const run_board_render_tail = {
+	activity_icon,
+	checks_of,
+	phase_icon,
+	phase_time,
+	tail_of,
+}
 
 export { run_board_render_tail }

package/scripts/run/board/run-board-render-time.ts

@@ -0,0 +1,56 @@
+import { run_board_earlier } from './run-board-earlier'
+import type { BoardHeader } from './run-board-header'
+import { run_board_labels } from './run-board-labels'
+import { run_board_lane_time } from './run-board-lane-time'
+import { run_board_layout, type BoardRow } from './run-board-layout'
+import type { ItemStatus } from './run-board-status'
+
+// A row's time column on `run:board`: how long it has run, and how wide the column is drawn.
+
+const { span_of } = run_board_labels
+
+// A running row — an earlier run's lane too — runs until now; a settled one until its recorded end. A
+// child settled from the open listing has none, so it draws no time rather than one that keeps counting.
+function end_of(row: BoardRow, now_ms: number): number | undefined {
+	return run_board_earlier.is_live(row) ? now_ms : row.status?.ended_ms
+}
+
+// The time the event that settled the row recorded (joshuafolkken/kit#4481): a settled row draws it
+// rather than counting again, so it keeps its time when its launch lies outside the run's span.
+function recorded_ms(row: BoardRow): number | undefined {
+	return run_board_earlier.is_live(row) ? undefined : row.status?.elapsed_ms
+}
+
+// How long a row has run on a lane, up to its end. A row whose launch rolled off the stream has no
+// span, so it runs from its lane record's launch.
+function counted_ms(status: ItemStatus | undefined, ended: number | undefined): number | undefined {
+	if (ended === undefined || status?.started_ms === undefined) return undefined
+
+	return run_board_lane_time.elapsed_of(status.spans ?? [], status.started_ms, ended)
+}
+
+// How long a row has run: a running one until now, a settled one until its end.
+function elapsed_ms(row: BoardRow, now_ms: number): number | undefined {
+	return recorded_ms(row) ?? counted_ms(row.status, end_of(row, now_ms))
+}
+
+function time_of(row: BoardRow, now_ms: number): string | undefined {
+	const elapsed = elapsed_ms(row, now_ms)
+
+	return elapsed === undefined ? undefined : span_of(elapsed)
+}
+
+// The time column's width: the widest time any active row or earlier run's lane draws in this frame.
+function time_width(header: BoardHeader): number {
+	const rows = run_board_layout.lane_rows(header.layout ?? run_board_layout.EMPTY_LAYOUT, [])
+	const times = rows.map((row) => time_of(row, header.now_ms) ?? '')
+
+	return Math.max(0, ...times.map((time) => time.length))
+}
+
+const run_board_render_time = {
+	time_of,
+	time_width,
+}
+
+export { run_board_render_time }

package/scripts/run/board/run-board-render-title.ts

@@ -1,10 +1,9 @@
 import { run_board_fit } from './run-board-fit'
-import { run_board_labels } from './run-board-labels'
 import type { BoardRow } from './run-board-layout'
 
 // A row's title and the reason it makes room for — pure. A title is cut to the title column; a row
-// that says why it waits keeps saying it on a narrow pane, its title giving up the columns the line
-// runs over, where every other row wraps.
+// that says why it waits, or draws a tail, keeps its line on a narrow pane, its title giving up the
+// columns the line runs over down to a floor and its reason the rest; past the floor it wraps.
 
 // The columns a terminal row gives its title: a longer one is cut to an ellipsis.
 const TITLE_LIMIT = 48
@@ -12,47 +11,141 @@ const TITLE_LIMIT = 48
 const TITLE_FLOOR = 8
 const ELLIPSIS = '…'
 
+// What a row gives up to stay on one line: the columns its title is cut to, and the columns cut off
+// its reason's end.
+interface RowCut {
+	title_limit: number
+	reason_cut: number
+}
+
+const WHOLE: RowCut = { title_limit: TITLE_LIMIT, reason_cut: 0 }
+
 // A title cut to the title column, so every time after it starts in one column.
 function title_of(title = '', limit = TITLE_LIMIT): string {
 	return title.length > limit ? `${title.slice(0, limit - 1)}${ELLIPSIS}` : title
 }
 
-// Why a waiting row waits, after its blockers; a lane's stage with how long the lane has stood at it.
-function reason_text(row: BoardRow, now_ms: number): string | undefined {
-	const { reason } = row
+const GRAPHEMES = new Intl.Segmenter()
+
+// The text cut to `columns` terminal columns — a wide character takes two — ending on an ellipsis.
+function columns_cut(text: string, columns: number): string {
+	let kept = ''
+
+	for (const { segment } of GRAPHEMES.segment(text)) {
+		if (run_board_fit.width_of(`${kept}${segment}${ELLIPSIS}`) > columns) break
+		kept += segment
+	}
+
+	return `${kept}${ELLIPSIS}`
+}
+
+// The row's reason as it follows the title — what a waiting row waits on there, or why a parked or
+// withdrawn row ended — with `cut` columns given up at its end, which then ends on an ellipsis; at
+// least the ellipsis is left.
+function reason_text(row: BoardRow, cut = 0): string | undefined {
+	const text = row.reason?.tail
 
-	if (reason?.since_ms === undefined) return reason?.text
+	if (text === undefined || cut === 0) return text
 
-	return `${reason.text} ${run_board_labels.stage_span_of(now_ms - reason.since_ms)}`
+	return columns_cut(text, Math.max(1, run_board_fit.width_of(text) - cut))
 }
 
-// The columns a line runs past the pane, for a row that says why it waits; none for any other row, and
-// none for a frame that is not kept within a pane.
-function overrun_of(text: string, row: BoardRow, columns: number | undefined): number {
-	if (columns === undefined || row.reason === undefined) return 0
+// The columns a line runs past the pane, for a row whose end it keeps; none for any other row, and none
+// for a frame that is not kept within a pane.
+function overrun_of(text: string, is_kept: boolean, columns: number | undefined): number {
+	if (columns === undefined || !is_kept) return 0
 
 	return Math.max(0, run_board_fit.width_of(text) - columns)
 }
 
-// The title column once it has given up `overrun` columns, never under the floor: the blanks a short
-// title is padded with go first, so a title that fits keeps whole.
-function narrowed_limit(overrun: number): number {
-	return Math.max(TITLE_FLOOR, TITLE_LIMIT - overrun)
+// How a row is fitted: whether it keeps its whole line — a row that draws a tail, a held check among
+// it (joshuafolkken/kit#4052) — the columns its title cell leads its title with, a ✚ on a row the run
+// filed, its head as drawn, kept on one line where the row's head is too wide to assume it fits — a
+// lane row's, with its cells (joshuafolkken/kit#3769) — and the columns its section's rows give up
+// together, so their titles end in one column.
+interface RowFit {
+	is_line_kept?: boolean
+	lead?: number
+	head?: (cut: RowCut) => string
+	is_head_kept?: boolean
+	shared?: number | undefined
 }
 
-// A row's line as `draw` draws it at a title limit: at the title column's, or at a narrower one where
-// that line would run past the pane and the row has a reason to keep.
+// The columns a row's head runs past the pane at its whole title; none where it is not kept.
+function head_overrun(fit: RowFit, columns: number | undefined): number {
+	if (fit.head === undefined || fit.is_head_kept !== true) return 0
+
+	return overrun_of(fit.head(WHOLE), true, columns)
+}
+
+// The columns the row's title cell takes as drawn: a waiting row's title is not padded, every other
+// row's is padded to the title column.
+function drawn_width(row: BoardRow, lead: number): number {
+	const title = (row.title?.length ?? 0) + lead
+
+	return row.state === 'waiting' ? Math.min(TITLE_LIMIT, title) : TITLE_LIMIT
+}
+
+// The row's title once it has given up `overrun` columns, never under the floor.
+function narrowed_limit(row: BoardRow, overrun: number, lead: number): number {
+	return Math.max(TITLE_FLOOR, drawn_width(row, lead) - overrun)
+}
+
+// A row's line at a narrowed title with its whole reason, or with the reason's end cut by the columns
+// that line still runs past the pane.
+function reason_fitted(
+	row: BoardRow,
+	columns: number | undefined,
+	title_limit: number,
+	draw: (cut: RowCut) => string,
+): string {
+	const text = draw({ title_limit, reason_cut: 0 })
+	const reason_cut = overrun_of(text, row.reason !== undefined, columns)
+
+	return reason_cut === 0 ? text : draw({ title_limit, reason_cut })
+}
+
+// The columns a row's line runs past the pane at its whole title, where the row has a reason or a
+// whole line to keep, or its kept head does.
+function row_overrun(
+	row: BoardRow,
+	columns: number | undefined,
+	draw: (cut: RowCut) => string,
+	fit: RowFit = {},
+): number {
+	const line = overrun_of(
+		draw(WHOLE),
+		fit.is_line_kept === true || row.reason !== undefined,
+		columns,
+	)
+
+	return Math.max(line, head_overrun(fit, columns))
+}
+
+// A row's line as `draw` draws it: whole, or — where it or its section runs past the pane — with its
+// title narrowed first and its reason cut after.
 function fitted(
 	row: BoardRow,
 	columns: number | undefined,
-	draw: (title_limit: number) => string,
+	draw: (cut: RowCut) => string,
+	fit: RowFit = {},
 ): string {
-	const text = draw(TITLE_LIMIT)
-	const overrun = overrun_of(text, row, columns)
+	const overrun = Math.max(row_overrun(row, columns, draw, fit), fit.shared ?? 0)
+
+	if (overrun === 0) return draw(WHOLE)
 
-	return overrun === 0 ? text : draw(narrowed_limit(overrun))
+	return reason_fitted(row, columns, narrowed_limit(row, overrun, fit.lead ?? 0), draw)
 }
 
-const run_board_render_title = { ELLIPSIS, TITLE_LIMIT, fitted, reason_text, title_of }
+const run_board_render_title = {
+	ELLIPSIS,
+	TITLE_LIMIT,
+	WHOLE,
+	columns_cut,
+	fitted,
+	reason_text,
+	row_overrun,
+	title_of,
+}
 
-export { run_board_render_title }
+export { run_board_render_title, type RowCut, type RowFit }

package/scripts/run/board/run-board-render-waits.ts

@@ -0,0 +1,125 @@
+import type { BudgetWait, WaitReason } from '#scripts/gate/core-wait'
+import { run_board_fit } from './run-board-fit'
+import type { BoardHeader } from './run-board-header'
+import { run_board_labels } from './run-board-labels'
+import { run_board_layout, type BoardRow } from './run-board-layout'
+
+// The claims waiting in the machine-wide core budget (joshuafolkken/kit#3943, #4052): a lane held back
+// by memory pressure otherwise reads the same as one that is stuck. A lane's wait is drawn on its own
+// row — 🚧 in place of its phase icon, and why, how long and which check in place of its newest
+// activity — so a wait coming and going moves no line. A wait no running row owns — the main
+// checkout's, another repository's — is one line right before the legend, which gives way with it,
+// so nothing is added under the header.
+
+const { HEADER_ICONS, WORDS, minute_span_of, span_of } = run_board_labels
+// 🚧 rather than ⏳, which a waiting row already draws, or 🚦, the gate stage's; an emoji a terminal
+// draws two columns wide.
+const BUDGET_ICON = '🚧'
+const INDENT = '  '
+const MAIN_CHECKOUT = 'main'
+const UNNAMED_CHECK = 'step'
+const RELATED_SUFFIX = ':related'
+// Why a claim waits, as the header draws the gauge it waits on.
+const REASON_ICONS: Readonly<Record<WaitReason, string>> = {
+	cores: HEADER_ICONS.cpu,
+	cpu: HEADER_ICONS.cpu,
+	memory: HEADER_ICONS.memory,
+	pressure: HEADER_ICONS.memory,
+}
+const REASON_WORDS: ReadonlyArray<readonly [string, string]> = [
+	[HEADER_ICONS.memory, WORDS.memory],
+	[HEADER_ICONS.cpu, WORDS.cores],
+]
+
+// The check's short name: the command's last word without `:related` (`gate lint` → `lint`).
+function check_of(wait: BudgetWait): string {
+	const word = wait.command?.split(' ').at(-1)
+
+	return word === undefined || word === '' ? UNNAMED_CHECK : word.replace(RELATED_SUFFIX, '')
+}
+
+// How long, to the minute where the seconds would not fit `room` (`10′05″` → `11′`).
+function held_span(wait: BudgetWait, room: number): string {
+	const span = span_of(wait.waited_ms)
+
+	return run_board_fit.width_of(span) <= room ? span : minute_span_of(wait.waited_ms)
+}
+
+// Why and how long, the two filling `width` columns with the time right-aligned (joshuafolkken/kit#4292).
+function held_time(wait: BudgetWait, width: number): string {
+	const lead = `${REASON_ICONS[wait.reason]} `
+	const room = width - run_board_fit.width_of(lead)
+
+	return `${lead}${held_span(wait, room).padStart(room)}`
+}
+
+// Why, how long and which check.
+function held_text(wait: BudgetWait): string {
+	return `${REASON_ICONS[wait.reason]} ${span_of(wait.waited_ms)} ${check_of(wait)}`
+}
+
+function is_lane_row(row: BoardRow, wait: BudgetWait): boolean {
+	return row.state === 'running' && String(row.number) === wait.lane
+}
+
+// The longest wait a running row's lane is held in, if any: a row draws one, the others of its lane
+// none.
+function held_of(row: BoardRow, header: BoardHeader): BudgetWait | undefined {
+	const waits = (header.budget_waits ?? []).filter((wait) => is_lane_row(row, wait))
+
+	return waits.toSorted((left, right) => right.waited_ms - left.waited_ms).at(0)
+}
+
+function place_text(wait: BudgetWait, link: (reference: string) => string): string {
+	if (wait.elsewhere !== undefined) return wait.elsewhere
+
+	return wait.lane === undefined ? MAIN_CHECKOUT : link(wait.lane)
+}
+
+function rows_of(header: BoardHeader): Array<BoardRow> {
+	return header.layout === undefined ? [] : run_board_layout.rows_of(header.layout)
+}
+
+// The waits no running row owns.
+function stray_of(header: BoardHeader): Array<BudgetWait> {
+	const rows = rows_of(header)
+
+	return (header.budget_waits ?? []).filter((wait) => rows.every((row) => !is_lane_row(row, wait)))
+}
+
+// The waits the frame draws: each held row's and every one no row owns.
+function drawn_of(header: BoardHeader): Array<BudgetWait> {
+	const held = rows_of(header).flatMap((row) => held_of(row, header) ?? [])
+
+	return [...held, ...stray_of(header)]
+}
+
+// One line for each wait no running row draws, nothing while none waits.
+function stray_lines(header: BoardHeader): Array<string> {
+	return stray_of(header).map(
+		(wait) => `${INDENT}${BUDGET_ICON} ${held_text(wait)} ${place_text(wait, header.link)}`,
+	)
+}
+
+// 🚧 and the reasons the frame draws, nothing while it draws no wait.
+function legend_of(header: BoardHeader): Array<string> {
+	const waits = drawn_of(header)
+
+	if (waits.length === 0) return []
+
+	const icons = new Set(waits.map((wait) => REASON_ICONS[wait.reason]))
+	const reasons = REASON_WORDS.filter(([icon]) => icons.has(icon))
+
+	return [`${BUDGET_ICON} ${WORDS.held_check}`, ...reasons.map(([icon, word]) => `${icon} ${word}`)]
+}
+
+const run_board_render_waits = {
+	BUDGET_ICON,
+	check_of,
+	held_of,
+	held_time,
+	legend_of,
+	stray_lines,
+}
+
+export { run_board_render_waits }