@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/lane/lane-ledger.ts

@@ -1,170 +1,15 @@
-import { closeSync, constants, openSync, writeSync } from 'node:fs'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { json_value } from '#scripts/lib/json-value'
 import { stamped_memo } from '#scripts/lib/stamped-memo'
-import { run_carry } from '#scripts/run/carry/run-carry'
-import {
-	lane_ledger_schema,
-	type CoreWaitRecord,
-	type GateRecord,
-	type HeldRecord,
-	type LedgerEntry,
-	type OverlapRecord,
-	type RoundTwoRecord,
-	type StageRecord,
-	type StopRecord,
-	type TestRelatedRecord,
-	type UnitFileRecord,
-} from './lane-ledger-schema'
-
-// The measurement ledger the lane limit is tuned against: one JSON line per
-// lane merge, per finished `josh gate`, per machine-load sample, per lane dispatch, per finished
-// `josh ship` stage, per stopped `josh ship`, per round-2 decision, per core-budget wait and per
-// `josh test:related` run, read back by `josh lane:stats`. Each line's shape is `lane-ledger-schema.ts`.
-//
-// **Its own file rather than the run's event stream.** The stream is capped at 500 events and is
-// rewritten whole on every append, which is right for "where is the run" and wrong for a measurement
-// that spans days of one-a-minute load samples. This file is only ever appended to, so concurrent lanes
-// never lose each other's lines to a read-modify-write race.
-//
-// **Keyed on the common git directory, the event stream's key**, so a lane child's gate, the parent's
-// merge and the sampler all land in one ledger per repository. It sits in the temp root beside every
-// other josh record; a reboot clears it, which is why `docs/maintainers/lane-limit-measurement.md`
-// closes a period with `josh lane:stats` before one.
-
-const LEDGER_PREFIX = 'josh-lane-ledger-'
-const LEDGER_SUFFIX = '.jsonl'
-const LINE_SEPARATOR = '\n'
-// `followup`'s wait for CI — a stage of a lane's run that no `josh ship` stage is the whole of.
-const CI_WAIT_STAGE = 'ci-wait'
-// The part of `followup`'s waits CodeRabbit spent running or rate-limited, and the rate-limited part
-// alone (joshuafolkken/kit#4574).
-const CODERABBIT_WAIT_STAGE = 'coderabbit-wait'
-const CODERABBIT_RATE_LIMIT_STAGE = 'coderabbit-rate-limit'
-// A detached `josh ship`'s fast checks in the agent's own turn — not a resumable ship stage, since the
-// supervised gate runs them again (joshuafolkken/kit#4382).
-const PRE_DETACH_STAGE = 'pre-detach'
-const LEDGER_FILE_MODE = 0o600
-// The flags `detached-launch.ts` appends its log with, for the same deterministic shared-temp path.
-const { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants
-// eslint-disable-next-line no-bitwise -- POSIX open flags are a bit field; `||` here would be a bug
-const APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW
-
-const { KIND, entry_schema } = lane_ledger_schema
-
-function target_of(repository: string): string {
-	return stamp_file.stamp_path(LEDGER_PREFIX, repository, LEDGER_SUFFIX)
-}
-
-// The ledger of the repository this checkout belongs to, or `undefined` outside one. `git rev-parse`
-// rejects outside a repository, and `josh gate` resolves this before it runs a check, so the rejection
-// is read as "no ledger" rather than allowed to fail the gate it would only have measured.
-//
-// **A test run has no ledger either.** The writers sit on paths dozens of suites exercise — a ship
-// stage, a dispatch, a `followup` — and one suite that forgot to mock this module would append its
-// fixture durations to the real measurement; a test that writes passes its own path instead.
-async function target(): Promise<string | undefined> {
-	if (process.env['VITEST'] !== undefined) return undefined
-
-	try {
-		const repository = await run_carry.repository_directory()
-
-		return repository === undefined ? undefined : target_of(repository)
-	} catch {
-		return undefined
-	}
-}
-
-// **Append, never rewrite** — `O_APPEND` keeps each short line whole across concurrent writers, and
-// `O_NOFOLLOW` plus `stamp_file`'s ownership test keep a planted link or another account's file from
-// receiving it. Any JSON-lines log takes it — the durable review stop log too (joshuafolkken/kit#4519).
-function append(path: string, entry: object): void {
-	const descriptor = openSync(path, APPEND_FLAGS, LEDGER_FILE_MODE)
-
-	try {
-		if (stamp_file.is_own_regular_file(path)) {
-			writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`)
-		}
-	} finally {
-		closeSync(descriptor)
-	}
-}
+import { lane_ledger_schema, type LedgerEntry } from './lane-ledger-schema'
+import { lane_ledger_write } from './lane-ledger-write'
 
-// Best-effort: a measurement must never fail the gate or the merge it measures, so every error — no
-// repository, an unwritable temp root — is dropped.
-async function record(entry: LedgerEntry, path?: string): Promise<void> {
-	try {
-		const destination = path ?? (await target())
+// The measurement ledger read back: every line `lane-ledger-write.ts` appended, for `josh lane:stats`,
+// `lane:breakdown`, `run:board` and the other measurements. The writers import that leaf, never this
+// module, so a change to the reading reaches only the suites that read (joshuafolkken/kit#5202).
 
-		if (destination !== undefined) append(destination, entry)
-	} catch {
-		// Reporting is best-effort: a failed append is dropped rather than raised into the caller's work.
-	}
-}
-
-function now_iso(): string {
-	return new Date().toISOString()
-}
-
-// One finished `josh gate`, whether it passed or not — a failing gate cost the lane its time as well.
-async function record_gate(path: string, gate: GateRecord): Promise<void> {
-	await record({ kind: KIND.GATE, at: now_iso(), ...gate }, path)
-}
-
-async function record_merge(issue: number): Promise<void> {
-	await record({ kind: KIND.MERGE, at: now_iso(), issue })
-}
-
-async function record_dispatch(issue: number, path?: string): Promise<void> {
-	await record({ kind: KIND.DISPATCH, at: now_iso(), issue }, path)
-}
-
-async function record_stage(stage: StageRecord, path?: string): Promise<void> {
-	await record({ kind: KIND.STAGE, at: now_iso(), ...stage }, path)
-}
-
-async function record_stop(stop: StopRecord, path?: string): Promise<void> {
-	await record({ kind: KIND.STOP, at: now_iso(), ...stop }, path)
-}
-
-async function record_overlap(overlap: OverlapRecord, path?: string): Promise<void> {
-	await record({ kind: KIND.OVERLAP, at: now_iso(), ...overlap }, path)
-}
-
-// `waiting` is written only when the offer named issues, so a hold that waited on none stays one short line.
-async function record_held(held: HeldRecord, path?: string): Promise<void> {
-	const waiting = held.waiting ?? []
-	const named = waiting.length > 0 ? { waiting: [...waiting] } : {}
-
-	await record({ kind: KIND.HELD, at: now_iso(), reason: held.reason, ...named }, path)
-}
-
-async function record_released(path?: string): Promise<void> {
-	await record({ kind: KIND.RELEASED, at: now_iso() }, path)
-}
-
-async function record_offerable(is_offerable: boolean, path?: string): Promise<void> {
-	await record({ kind: KIND.OFFERABLE, at: now_iso(), is_offerable }, path)
-}
-
-async function record_round_two(round_two: RoundTwoRecord, path?: string): Promise<void> {
-	await record({ kind: KIND.ROUND_TWO, at: now_iso(), ...round_two }, path)
-}
-
-async function record_core_wait(wait: CoreWaitRecord, path?: string): Promise<void> {
-	await record({ kind: KIND.CORE_WAIT, at: now_iso(), ...wait }, path)
-}
-
-async function record_unit_files(
-	files: ReadonlyArray<UnitFileRecord>,
-	path?: string,
-): Promise<void> {
-	await record({ kind: KIND.UNIT_FILES, at: now_iso(), files: [...files] }, path)
-}
-
-async function record_test_related(run: TestRelatedRecord, path?: string): Promise<void> {
-	await record({ kind: KIND.TEST_RELATED, at: now_iso(), ...run }, path)
-}
+const { entry_schema } = lane_ledger_schema
+const { LINE_SEPARATOR } = lane_ledger_write
 
 function parse_line(line: string): LedgerEntry | undefined {
 	return entry_schema.safeParse(json_value.parse_or_undefined(line)).data
@@ -194,28 +39,28 @@ function read_entries(path: string): ReadonlyArray<LedgerEntry> {
 	return parsed_ledgers.of(path, stamped_memo.file_stamp(path), () => parse_entries(path))
 }
 
+// The names a reader looks entries up by and the ledger it reads, the writer's own.
+const {
+	CI_WAIT_STAGE,
+	CODERABBIT_RATE_LIMIT_STAGE,
+	CODERABBIT_RETRIGGER_STAGE,
+	CODERABBIT_WAIT_STAGE,
+	KIND,
+	PRE_DETACH_STAGE,
+	ROUND_ONE_REUSED,
+	target,
+	target_of,
+} = lane_ledger_write
+
 const lane_ledger = {
 	CI_WAIT_STAGE,
 	CODERABBIT_RATE_LIMIT_STAGE,
+	CODERABBIT_RETRIGGER_STAGE,
 	CODERABBIT_WAIT_STAGE,
 	KIND,
 	PRE_DETACH_STAGE,
-	append,
+	ROUND_ONE_REUSED,
 	read_entries,
-	record,
-	record_core_wait,
-	record_dispatch,
-	record_gate,
-	record_held,
-	record_released,
-	record_merge,
-	record_overlap,
-	record_offerable,
-	record_round_two,
-	record_stage,
-	record_stop,
-	record_test_related,
-	record_unit_files,
 	target,
 	target_of,
 }
@@ -227,19 +72,28 @@ export type {
 	GateCheckRecord,
 	GateEntry,
 	HeldEntry,
+	LaneStateChangeEntry,
 	LedgerEntry,
 	LoadEntry,
 	MergeEntry,
 	OfferableEntry,
 	OverlapEntry,
 	OverlapRecord,
+	PushMissEntry,
+	RoundOneEntry,
 	RoundTwoEntry,
+	ShipLapEntry,
+	SplitFiledEntry,
+	SplitNoticeEntry,
 	StageEntry,
 	StopEntry,
 	StopRecord,
+	TestPinnedEntry,
+	TestPinnedRecord,
 	TestRelatedEntry,
 	TestRelatedRecord,
 	UnitFileRecord,
 	UnitFilesEntry,
+	UnplannedNoticeEntry,
 } from './lane-ledger-schema'
 export { lane_ledger }

package/scripts/lane/lane-load.ts

@@ -1,7 +1,7 @@
 import { loadavg } from 'node:os'
 import { machine_capacity } from '#scripts/gate/machine-capacity'
 import { lane_await } from './lane-await'
-import type { LoadEntry } from './lane-ledger'
+import type { LoadEntry } from './lane-ledger-schema'
 import { lane_process_load } from './lane-process-load'
 import { lane_registry, type LaneInfo } from './lane-registry'
 

package/scripts/lane/lane-measure-cli.ts

@@ -2,27 +2,21 @@
 import { setInterval as every } from 'node:timers/promises'
 import { fileURLToPath } from 'node:url'
 import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
-import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
-import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { lane_capacity } from './lane-capacity'
-import { lane_check_stats } from './lane-check-stats'
-import { lane_core_wait_stats } from './lane-core-wait-stats'
-import { lane_gap_stats } from './lane-gap-stats'
-import { lane_held_stats } from './lane-held-stats'
-import { lane_ledger } from './lane-ledger'
-import { lane_process_stats } from './lane-process-stats'
-import { lane_round_two_stats } from './lane-round-two-stats'
+import { lane_net_read } from './lane-net-read'
 import { lane_sampler, type MeasureContext } from './lane-sampler'
-import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats, type StatsWindow } from './lane-stats'
-import { lane_stop_stats } from './lane-stop-stats'
-import { lane_test_related_stats } from './lane-test-related-stats'
-import type { ToolCall } from './lane-transcript-calls'
+import { lane_stats_tables, type PeriodRecords } from './lane-stats-tables'
 import { lane_transcript_stats } from './lane-transcript-stats'
+import { lane_value } from './lane-value'
+import { lane_value_cell, type CellAddress } from './lane-value-cell'
 
-// `josh lane:sample` / `josh lane:stats` — the lane-limit measurement.
+// `josh lane:sample` / `josh lane:stats` — the lane-limit measurement; `josh lane:value` and
+// `josh lane:net` print one measurement each.
 //
 // `lane:sample` appends one machine-load sample to the ledger, or one every `--every <seconds>` until it
 // is stopped; `lane:stats` reduces a period of the ledger to the one table row #3347 records per lane
@@ -36,13 +30,28 @@ const ARGV_OFFSET = 2
 const FAILURE_EXIT_CODE = 1
 const SAMPLE_VERB = 'sample'
 const STATS_VERB = 'stats'
+const VALUE_VERB = 'value'
+const NET_VERB = 'net'
+// `lane:value cell` reads one `lane:stats` table cell rather than a named metric (joshuafolkken/kit#5144).
+const CELL_METRIC = 'cell'
+// A value keeps two decimals: seconds, minutes and per-lane counts read at that grain.
+const VALUE_DIGITS = 2
 const USAGE = [
 	'Usage: josh lane:sample [--every <seconds>]',
 	'       josh lane:stats --period <days> [--limit <lane-limit>]',
+	`       josh lane:value <${lane_value.NAMES.join('|')}> --since <instant>`,
+	`       josh lane:value ${CELL_METRIC} --table <title> --row <label> --column <header> --since <instant>`,
+	'       josh lane:net <issue>',
 ].join('\n')
 
 const SAMPLE_OPTIONS = { every: { type: 'string' } } as const
 const STATS_OPTIONS = { period: { type: 'string' }, limit: { type: 'string' } } as const
+const VALUE_OPTIONS = {
+	since: { type: 'string' },
+	table: { type: 'string' },
+	row: { type: 'string' },
+	column: { type: 'string' },
+} as const
 
 function refuse(): number {
 	console.error(USAGE)
@@ -104,21 +113,6 @@ async function limit_label(given: string | undefined): Promise<string> {
 	return choice.kind === 'limit' ? String(choice.limit) : lane_stats.MISSING
 }
 
-async function read_ledger(
-	context: MeasureContext,
-): Promise<ReturnType<typeof lane_ledger.read_entries>> {
-	const path = context.ledger_path ?? (await lane_ledger.target())
-
-	return path === undefined ? [] : lane_ledger.read_entries(path)
-}
-
-// The run's event stream, read for the parks that end a stop's wait.
-async function read_events(context: MeasureContext): Promise<ReadonlyArray<RunEvent>> {
-	if (context.events_path !== undefined) return run_event_stream.read_events(context.events_path)
-
-	return await run_event_stream_emit.all_events()
-}
-
 // Every lane's transcript directory under this checkout's lane root, read from a lane or the main checkout.
 function transcript_directories(context: MeasureContext): ReadonlyArray<string> {
 	if (context.transcript_directories !== undefined) return context.transcript_directories
@@ -128,27 +122,16 @@ function transcript_directories(context: MeasureContext): ReadonlyArray<string>
 	return cost_transcript.lane_transcript_directories(main_cwd, cost_transcript.home_directory())
 }
 
-interface PeriodRecords {
-	entries: ReturnType<typeof lane_ledger.read_entries>
-	events: ReadonlyArray<RunEvent>
-	calls: ReadonlyArray<ToolCall>
-}
-
-// The tables under the period's row, in the order `lane:stats` prints them.
-function tables_of({ entries, events, calls }: PeriodRecords, window: StatsWindow): Array<string> {
-	return [
-		lane_stage_stats.table(entries, window),
-		lane_stop_stats.table(entries, window, events),
-		lane_gap_stats.table(entries, window, events),
-		lane_round_two_stats.table(entries, window),
-		lane_held_stats.table(entries, window),
-		lane_core_wait_stats.table(entries, window),
-		lane_process_stats.table(entries, window),
-		lane_check_stats.table(entries, window),
-		lane_test_related_stats.table(entries, window),
-		lane_test_related_stats.trigger_table(entries, window),
-		lane_transcript_stats.table(calls, window),
-	]
+// The whole ledger, every run event and the window's lane calls — what the `lane:stats` tables read.
+async function period_records(
+	context: MeasureContext,
+	window: StatsWindow,
+): Promise<PeriodRecords> {
+	return {
+		entries: await lane_net_read.read_ledger(context),
+		events: await lane_net_read.read_events(context),
+		calls: lane_transcript_stats.read_calls(transcript_directories(context), window),
+	}
 }
 
 async function stats_command(
@@ -162,25 +145,159 @@ async function stats_command(
 
 	const window = lane_stats.window_of(period_days, context.now_ms ?? Date.now())
 	const label = { limit: await limit_label(values.limit), period_days }
-	const entries = await read_ledger(context)
-	const row = lane_stats.row(entries, window, label)
+	const records = await period_records(context, window)
+	const row = lane_stats.row(records.entries, window, label)
+	const tables = lane_stats_tables.tables_of(records, window)
+
+	console.info([`${lane_stats.header()}\n${row}`, ...tables].join('\n\n'))
+
+	return 0
+}
+
+interface ValueRequest {
+	metric: string
+	since_ms: number
+	address?: CellAddress
+}
+
+interface AddressFlags {
+	table?: string | undefined
+	row?: string | undefined
+	column?: string | undefined
+}
+
+function since_of(text = ''): number | undefined {
+	const since_ms = Date.parse(text)
+
+	return Number.isNaN(since_ms) ? undefined : since_ms
+}
+
+function is_known(name: string): boolean {
+	return name === CELL_METRIC || lane_value.is_metric(name)
+}
+
+function metric_of(positionals: ReadonlyArray<string>): string | undefined {
+	const [name] = positionals
+
+	return name !== undefined && positionals.length === 1 && is_known(name) ? name : undefined
+}
+
+function address_of({ table, row, column }: AddressFlags): CellAddress | undefined {
+	return table === undefined || row === undefined || column === undefined
+		? undefined
+		: { table, row, column }
+}
+
+function request_of(
+	metric: string | undefined,
+	since_ms: number | undefined,
+): ValueRequest | undefined {
+	return metric === undefined || since_ms === undefined ? undefined : { metric, since_ms }
+}
+
+// One known metric and a readable `--since` instant — `cell` with its whole address — or `undefined`
+// for a refusal.
+function value_request(rest: ReadonlyArray<string>): ValueRequest | undefined {
+	const parsed = cli_flags.arguments_of(rest, VALUE_OPTIONS)
+
+	if (parsed === undefined) return undefined
+
+	const request = request_of(metric_of(parsed.positionals), since_of(parsed.values.since))
+
+	if (request?.metric !== CELL_METRIC) return request
+
+	const address = address_of(parsed.values)
+
+	return address === undefined ? undefined : { ...request, address }
+}
+
+// The value alone on its line, so a measurement declaration reads it as the output's last line; a
+// period with no sample prints nothing there and fails, which the drive reads as unreadable.
+function print_value(request: ValueRequest, measured: number | undefined): number {
+	if (measured === undefined) {
+		const since = new Date(request.since_ms).toISOString()
+
+		const missing = request.address === undefined ? 'no sample' : 'no single numeric cell'
+
+		console.error(`josh lane:value ${request.metric}: ${missing} since ${since}`)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	console.info(measured.toFixed(VALUE_DIGITS))
+
+	return 0
+}
+
+// The addressed cell of the tables `lane:stats` would print for `window`.
+async function cell_value(
+	address: CellAddress,
+	window: StatsWindow,
+	context: MeasureContext,
+): Promise<number | undefined> {
+	const tables = lane_stats_tables.tables_of(await period_records(context, window), window)
+
+	return lane_value_cell.value(tables, address)
+}
+
+async function value_command(
+	rest: ReadonlyArray<string>,
+	context: MeasureContext,
+): Promise<number> {
+	const request = value_request(rest)
+
+	if (request === undefined) return refuse()
+
+	const window = { since_ms: request.since_ms, until_ms: context.now_ms ?? Date.now() }
+
+	if (request.address !== undefined) {
+		return print_value(request, await cell_value(request.address, window, context))
+	}
+
 	const records = {
-		entries,
-		events: await read_events(context),
+		entries: await lane_net_read.read_ledger(context),
 		calls: lane_transcript_stats.read_calls(transcript_directories(context), window),
 	}
 
-	console.info([`${lane_stats.header()}\n${row}`, ...tables_of(records, window)].join('\n\n'))
+	return print_value(request, lane_value.value(request.metric, records, window))
+}
+
+// The lane's net minutes, whole, alone on the line a causing-lane declaration copies
+// (`lane-net-time.ts`); a lane the ledger holds no dispatch and merge of fails.
+async function net_command(rest: ReadonlyArray<string>, context: MeasureContext): Promise<number> {
+	const [issue = ''] = rest
+
+	if (rest.length !== 1 || !issue_number_shape.is_issue_number(issue)) return refuse()
+
+	const net = await lane_net_read.net_minutes_of(Number(issue), context)
+
+	if (net === undefined) {
+		console.error(
+			`josh lane:net ${issue}: the ledger holds no dispatch and merge of ${session_cite.issue(issue)}`,
+		)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	console.info(String(net))
 
 	return 0
 }
 
-async function run(argv: ReadonlyArray<string>, context: MeasureContext = {}): Promise<number> {
-	const [verb, ...rest] = argv
+type VerbCommand = (rest: ReadonlyArray<string>, context: MeasureContext) => Promise<number>
+
+const VERBS: Readonly<Record<string, VerbCommand>> = {
+	[SAMPLE_VERB]: sample_command,
+	[STATS_VERB]: stats_command,
+	[VALUE_VERB]: value_command,
+	[NET_VERB]: net_command,
+}
 
-	if (verb === SAMPLE_VERB) return await sample_command(rest, context)
+async function run(argv: ReadonlyArray<string>, context: MeasureContext = {}): Promise<number> {
+	const [verb = '', ...rest] = argv
+	const command = Object.hasOwn(VERBS, verb) ? VERBS[verb] : undefined
 
-	return verb === STATS_VERB ? await stats_command(rest, context) : refuse()
+	return command === undefined ? refuse() : await command(rest, context)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {

package/scripts/lane/lane-net-read.ts

@@ -0,0 +1,44 @@
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { lane_ledger } from './lane-ledger'
+import { lane_net_time } from './lane-net-time'
+import type { MeasureContext } from './lane-sampler'
+
+// The ledger and the event stream the lane measurements read, and the one lane's net minutes read from
+// them — `josh lane:net` and the causing-lane line `josh issue:file --found-during` prints
+// (joshuafolkken/kit#5225) share it.
+
+type ReadContext = Pick<MeasureContext, 'ledger_path' | 'events_path'>
+
+async function read_ledger(
+	context: ReadContext,
+): Promise<ReturnType<typeof lane_ledger.read_entries>> {
+	const path = context.ledger_path ?? (await lane_ledger.target())
+
+	return path === undefined ? [] : lane_ledger.read_entries(path)
+}
+
+// The run's event stream, read for the parks that end a stop's wait.
+async function read_events(context: ReadContext): Promise<ReadonlyArray<RunEvent>> {
+	if (context.events_path !== undefined) return run_event_stream.read_events(context.events_path)
+
+	return await run_event_stream_emit.all_events()
+}
+
+// The lane's net minutes, whole; `undefined` when the ledger holds no dispatch and merge of it.
+async function net_minutes_of(
+	issue: number,
+	context: ReadContext = {},
+): Promise<number | undefined> {
+	const events = await read_events(context)
+
+	return lane_net_time.net_minutes(await read_ledger(context), events, issue)
+}
+
+const lane_net_read = {
+	net_minutes_of,
+	read_events,
+	read_ledger,
+}
+
+export { lane_net_read }