@joshuafolkken/kit 1.1514.0 → 1.1784.0

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

@@ -0,0 +1,109 @@
+import type { LaneStateRecord } from '#scripts/lane/lane-state'
+import type { RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_board_status, type ItemStatus } from './run-board-status'
+
+// What each open lane is doing on `run:board`, read from its lane state record (joshuafolkken/kit#4269)
+// rather than guessed from the run's span, the `.env` mtime or the `ps` state.
+//
+// **Whose lane it is is the record's**: a lane is this run's when the run that launched it started
+// when this run did, whatever the stream says, so a cut, a resume or an ending an earlier run's child
+// writes inside this run's span never makes it this run's. **What it is doing is the record's too** —
+// running or paused — and its time counts from the record's newest launch. The phase and the newest
+// activity are the stream's, folded from the lane's newest launch on. A lane with no record is not
+// guessed at: it is drawn unknown.
+
+interface BoardLanes {
+	// This run's lanes, by issue, with what each is doing.
+	own: ReadonlyMap<number, ItemStatus>
+	// An earlier run's lanes, likewise — drawn apart, never counted as this run's.
+	earlier: ReadonlyMap<number, ItemStatus>
+	// The open lanes with no record.
+	unknown: ReadonlyArray<string>
+}
+
+const NO_LANES: BoardLanes = { own: new Map(), earlier: new Map(), unknown: [] }
+
+// The record states a lane holds a child in; an `open` lane has launched none yet, an `ended` one is
+// done with its child, and neither draws a row of its own.
+const HELD_STATES: ReadonlySet<string> = new Set(['running', 'paused'])
+
+function time_of(at: string | undefined): number | undefined {
+	return at === undefined ? undefined : Date.parse(at)
+}
+
+// A record the one-off migration wrote (joshuafolkken/kit#4268) names no run, so its launch is placed against this run's start.
+function is_own(record: LaneStateRecord, started_ms: number): boolean {
+	if (record.run === undefined) return (time_of(record.launched_at) ?? NaN) >= started_ms
+
+	return time_of(record.run.started_at) === started_ms
+}
+
+// What the record says of the lane: running, or paused since the record last changed, by the command
+// that paused it.
+function recorded(record: LaneStateRecord, folded: ItemStatus | undefined): ItemStatus {
+	const started_ms = time_of(record.launched_at) ?? folded?.started_ms
+	const lane = `lane ${record.issue}`
+
+	if (record.state === 'paused') {
+		const ended_ms = time_of(record.changed_at)
+
+		return { ...folded, state: 'paused', started_ms, ended_ms, lane, paused_by: record.changed_by }
+	}
+
+	return { ...folded, state: 'running', started_ms, lane }
+}
+
+// The lane's status: its events from the record's newest launch on, folded over the record's running
+// child, so a cut or a stage line whose launch rolled off the stream carries it on. An ending among
+// them stands; otherwise the record's state does.
+function status_of(events: ReadonlyArray<RunEvent>, record: LaneStateRecord): ItemStatus {
+	const issue = Number(record.issue)
+	const launched_ms = time_of(record.launched_at)
+	const launched = run_board_status.since_launch(events, record.issue, launched_ms)
+	const seed: ReadonlyMap<number, ItemStatus> = new Map([
+		[issue, { state: 'running', started_ms: launched_ms }],
+	])
+	const folded = run_board_status.fold_events(launched, seed).get(issue)
+
+	return folded === undefined || folded.state === 'running' ? recorded(record, folded) : folded
+}
+
+interface LaneRead {
+	// The whole stream, not the run's span: an earlier run's lane launched before the span began.
+	events: ReadonlyArray<RunEvent>
+	lanes: ReadonlyArray<string>
+	records: ReadonlyMap<string, LaneStateRecord>
+	started_ms: number
+}
+
+function place(read: LaneRead, lane: string, sorted: BoardLanes): BoardLanes {
+	const record = read.records.get(lane)
+
+	if (record === undefined) return { ...sorted, unknown: [...sorted.unknown, lane] }
+	if (!HELD_STATES.has(record.state)) return sorted
+
+	const entry = [Number(lane), status_of(read.events, record)] as const
+
+	return is_own(record, read.started_ms)
+		? { ...sorted, own: new Map([...sorted.own, entry]) }
+		: { ...sorted, earlier: new Map([...sorted.earlier, entry]) }
+}
+
+// Each open lane sorted by its record into this run's, an earlier run's or unknown.
+function lanes_of(read: LaneRead): BoardLanes {
+	let sorted = NO_LANES
+
+	for (const lane of read.lanes) sorted = place(read, lane, sorted)
+
+	return sorted
+}
+
+// An earlier run's lane is drawn only while it holds a place under the limit.
+function earlier_occupied(occupied: ReadonlyArray<string>, sorted: BoardLanes): Array<string> {
+	return occupied.filter((issue) => sorted.earlier.has(Number(issue)))
+}
+
+const run_board_lane_state = { NO_LANES, earlier_occupied, lanes_of }
+
+export { run_board_lane_state }
+export type { BoardLanes, LaneRead }

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

@@ -0,0 +1,122 @@
+import { lane_spans, type IssueAt, type Span } from '#scripts/lane/lane-spans'
+import type { LaneStateRecord } from '#scripts/lane/lane-state'
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+
+// How long a child of the run has spent on a lane: each launch until the event that took it off the
+// lanes, summed, so the gap before a relaunch is not counted and a running row does not jump when it
+// settles (joshuafolkken/kit#4463). The spans are built as `josh lane:stats` builds its gaps
+// (`lane-spans.ts`).
+
+const KIND = run_event_stream.EVENT_KIND
+const LAUNCH_KINDS: ReadonlySet<string> = new Set([KIND.CHILD_LAUNCH, KIND.RESTART])
+// What takes a child off the lanes. A cut or a resume keeps it there, so it ends no span.
+const OFF_LANE_KINDS: ReadonlySet<string> = new Set([
+	KIND.MERGE,
+	KIND.PARK,
+	KIND.WITHDRAW,
+	KIND.OUTAGE,
+	KIND.SPLIT,
+	KIND.STOP,
+])
+
+function moments_of(events: ReadonlyArray<RunEvent>, kinds: ReadonlySet<string>): Array<IssueAt> {
+	return events
+		.filter((event) => kinds.has(event.kind))
+		.map((event) => ({
+			issue: Number(run_event_scope.issue_named(event)),
+			at_ms: Date.parse(event.at),
+		}))
+}
+
+// Each issue's spans on a lane, in launch order.
+function spans_of(events: ReadonlyArray<RunEvent>): ReadonlyMap<number | undefined, Array<Span>> {
+	const launches = moments_of(events, LAUNCH_KINDS)
+	const ends = moments_of(events, OFF_LANE_KINDS)
+	const issues = new Set(launches.map((launch) => launch.issue))
+
+	return new Map(
+		[...issues].map((issue) => {
+			const starts = launches.filter((launch) => launch.issue === issue)
+
+			return [issue, lane_spans.issue_spans({ starts, bounds: starts, ends })]
+		}),
+	)
+}
+
+function span_ms(span: Span, until_ms: number, end_ms: number): number {
+	return Math.max(0, Math.min(span.end_ms ?? until_ms, end_ms) - span.from_ms)
+}
+
+// The time `spans` ran up to the row's end: a span nothing took off the lanes runs until the next
+// launch, the last one until `end_ms` — now, a pause, or the issue's close.
+function in_lane_ms(spans: ReadonlyArray<Span>, end_ms: number): number {
+	return spans.reduce(
+		(total, span, index) => total + span_ms(span, spans[index + 1]?.from_ms ?? end_ms, end_ms),
+		0,
+	)
+}
+
+// The time a child ran on a lane up to `ended_ms`: its spans summed, or from `started_ms` where its
+// launch rolled off the stream and left none.
+function elapsed_of(spans: ReadonlyArray<Span>, started_ms: number, ended_ms: number): number {
+	return spans.length === 0 ? ended_ms - started_ms : in_lane_ms(spans, ended_ms)
+}
+
+interface EndingRead {
+	// The whole stream, not a run's span: the launch may predate the run now drawing the board.
+	events: ReadonlyArray<RunEvent>
+	issue: number
+	record: LaneStateRecord | undefined
+	ended_ms: number
+}
+
+// When the lane record says the child last launched; a record with no launch has none.
+function launched_ms(record: LaneStateRecord | undefined): number | undefined {
+	const launched_at = record?.launched_at
+
+	return launched_at === undefined ? undefined : Date.parse(launched_at)
+}
+
+// Where the board's count of an open lane begins: the start of the run that last launched it, whose span
+// holds every launch the running row sums (`run-board-status.ts` → `with_spans`). A record the one-off
+// migration wrote names no run, so it counts from its newest launch.
+function counted_from(run: LaneStateRecord['run'], started_ms: number): number {
+	return run === undefined ? started_ms : Date.parse(run.started_at)
+}
+
+function is_ended(spans: ReadonlyArray<Span>): boolean {
+	return spans.at(-1)?.end_ms !== undefined
+}
+
+/**
+ * The time an ending records for its child (joshuafolkken/kit#4481): computed once as it is written,
+ * from the spans the run that last launched it holds — what the board sums for an open lane
+ * (`run-board-lane-state.ts`), so the row keeps the time it drew while running. A child with no
+ * recorded launch, or whose newest span already ended, is not on a lane this ending takes it off, so it
+ * records none.
+ */
+function ending_elapsed(read: EndingRead): number | undefined {
+	const started_ms = launched_ms(read.record)
+
+	if (started_ms === undefined) return undefined
+
+	const from_ms = counted_from(read.record?.run, started_ms)
+	const spans = (spans_of(read.events).get(read.issue) ?? []).filter(
+		(span) => span.from_ms >= from_ms,
+	)
+
+	return is_ended(spans) ? undefined : elapsed_of(spans, started_ms, read.ended_ms)
+}
+
+const run_board_lane_time = {
+	LAUNCH_KINDS,
+	OFF_LANE_KINDS,
+	elapsed_of,
+	ending_elapsed,
+	in_lane_ms,
+	spans_of,
+}
+
+export { run_board_lane_time }
+export type { EndingRead }