@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/gate/check-inputs.ts

@@ -1,85 +1,24 @@
 import path from 'node:path'
-import { lint_related_scope } from '#scripts/lint/lint-related-scope'
-import { gate_plan } from './gate-plan'
-
-// Which paths each gate check reads, so a gate re-run reuses a check none of whose inputs moved
-// (`check-reuse.ts`). **A check with no scope here always runs**: `cspell` reads every
-// text file, the unit suite reads documents and fixtures as well as code, `behavior` reads a transcript
-// outside the tree and `metrics` reads whatever it measures. Naming a scope for any of them would be a
-// guess, and a wrong guess is a check reported green without having run.
-//
-// **The scopes over-approximate, never under**: a path in doubt is an input. `check` and `exports`
-// read source modules and the JSON they import. `lint` is prettier plus eslint, so its inputs are those
-// sources plus every file prettier formats — the extensions `lint:related` already selects, less what
-// prettier's own ignore files leave out (`.claude/**/*.md`). Prettier answers that itself through
-// `getFileInfo`, so the two ignore files stay the single source.
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { test_related } from '#scripts/test/test-related'
+import {
+	verification_inputs,
+	type InputDeclaration,
+	type PrettierIgnored,
+} from './verification-inputs'
+
+// The file-level answer of a check's declaration (`verification-inputs.ts`): whether any of the paths
+// that moved is one the check reads, so a gate re-run reuses a check none of whose inputs moved
+// (`check-reuse.ts`). It lives apart from the declarations because following imports reads the
+// test-read map (`test-related.ts`), whose own since-green narrowing reads the declarations.
 //
-// **A configuration file is an input of every scoped check**: a manifest or lock file moves the
-// installed toolchain, and an ignore or editor file moves what prettier reads.
-
-const SOURCE_EXTENSIONS: ReadonlySet<string> = new Set([
-	'.ts',
-	'.tsx',
-	'.mts',
-	'.cts',
-	'.js',
-	'.jsx',
-	'.mjs',
-	'.cjs',
-	'.svelte',
-	'.vue',
-	'.json',
-	'.jsonc',
-])
-
-const GIT_IGNORE = '.gitignore'
-const PRETTIER_IGNORE = '.prettierignore'
-const PRETTIER_IGNORE_FILES = [GIT_IGNORE, PRETTIER_IGNORE] as const
-
-const CONFIG_FILES: ReadonlySet<string> = new Set([
-	'package.json',
-	'pnpm-lock.yaml',
-	'pnpm-workspace.yaml',
-	'package-lock.json',
-	'yarn.lock',
-	'bun.lock',
-	'bun.lockb',
-	'.npmrc',
-	'.editorconfig',
-	...PRETTIER_IGNORE_FILES,
-])
-
-const PRETTIER_CONFIG_PREFIX = '.prettierrc'
-
-// Whether prettier would leave `relative` out; `false` when prettier cannot be asked, which keeps the
-// path an input.
-type PrettierIgnored = (relative: string) => Promise<boolean>
-
-type InputTest = (relative: string, is_ignored: PrettierIgnored) => Promise<boolean>
-
-function is_config(relative: string): boolean {
-	const name = path.basename(relative)
-
-	return CONFIG_FILES.has(name) || name.startsWith(PRETTIER_CONFIG_PREFIX)
-}
-
-function is_source(relative: string): boolean {
-	return SOURCE_EXTENSIONS.has(path.extname(relative))
-}
-
-async function is_lint_input(relative: string, is_ignored: PrettierIgnored): Promise<boolean> {
-	if (is_source(relative)) return true
-	if (!lint_related_scope.is_lintable(relative)) return false
-
-	return !(await is_ignored(relative))
-}
-
-async function is_source_input(relative: string): Promise<boolean> {
-	return is_source(relative)
-}
+// **The unit step's inputs are the test-read map's, not a guess** (joshuafolkken/kit#4314): it is
+// reusable only when `josh test:related` would run no test for what moved — every moved file one no
+// recorded test reads. No map, or one recorded on a tree git can no longer diff against, reaches every
+// test, so the step runs.
 
 function prettier_ignored(root: string): PrettierIgnored {
-	const ignore_path = PRETTIER_IGNORE_FILES.map((name) => path.join(root, name))
+	const ignore_path = verification_inputs.PRETTIER_IGNORE_FILES.map((name) => path.join(root, name))
 
 	return async function is_ignored(relative: string): Promise<boolean> {
 		try {
@@ -95,35 +34,40 @@ function prettier_ignored(root: string): PrettierIgnored {
 	}
 }
 
-const SCOPES: ReadonlyMap<string, InputTest> = new Map([
-	[gate_plan.LINT_LABEL, is_lint_input],
-	[gate_plan.TYPE_CHECK_LABEL, is_source_input],
-	[gate_plan.EXPORTS_LABEL, is_source_input],
-])
+async function reads_any(
+	declaration: InputDeclaration,
+	paths: ReadonlyArray<string>,
+	is_ignored: PrettierIgnored,
+	root: string,
+): Promise<boolean> {
+	if (declaration.reads === 'recorded') return await test_related.reaches_tests(root, paths)
+
+	const { is_input } = declaration
 
-function is_scoped(label: string): boolean {
-	return SCOPES.has(label)
+	if (is_input === undefined) return true
+
+	const answers = await Promise.all(
+		paths.map(async (relative) => await is_input(relative, is_ignored)),
+	)
+
+	return answers.includes(true)
 }
 
-// Whether any of `paths` (repository-root relative) is an input of the check `label`. An unscoped
+// Whether any of `paths` (repository-root relative) is an input of the check `label`. An undeclared
 // check answers `true` for every set of paths, so the only way to reuse it is never.
 async function touches_inputs(
 	label: string,
 	paths: ReadonlyArray<string>,
 	is_ignored: PrettierIgnored,
+	root: string = PROJECT_ROOT,
 ): Promise<boolean> {
-	const scope = SCOPES.get(label)
+	const declaration = verification_inputs.declaration_of(label)
 
-	if (scope === undefined || paths.some((relative) => is_config(relative))) return true
+	if (declaration === undefined || verification_inputs.configures(label, paths)) return true
 
-	const answers = await Promise.all(
-		paths.map(async (relative) => await scope(relative, is_ignored)),
-	)
-
-	return answers.includes(true)
+	return await reads_any(declaration, paths, is_ignored, root)
 }
 
-const check_inputs = { is_scoped, prettier_ignored, touches_inputs }
+const check_inputs = { prettier_ignored, touches_inputs }
 
-export type { PrettierIgnored }
 export { check_inputs }

package/scripts/gate/check-related-pinned.ts

@@ -0,0 +1,43 @@
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { run_review_pinned_accepted } from '#scripts/run/review/run-review-pinned-accepted'
+import { run_review_pinned_join } from '#scripts/run/review/run-review-pinned-join'
+import { test_pinned_logic } from '#scripts/test/test-pinned-logic'
+import type { PinnedSummary } from '#scripts/test/test-pinned-record'
+
+// **`check:related` prints the `josh test:pinned` verdict it finds already reached on this tree**
+// (joshuafolkken/kit#4971): read only by the ship's pre-detach, it stopped the first `josh ship` on
+// unpinned places, and the ship ran its preflight and pre-detach again once the reason was added.
+// **A check this run started is waited on** (joshuafolkken/kit#4987): one still probing when the four
+// checks ended printed nothing, and the ship stopped on it again. One it did not start is read as it
+// stands, and one on another tree prints nothing here.
+
+const SHIP_HINT =
+	'Pin each unpinned place above with a test that turns red without it, or give the first ship its reason: `pnpm josh ship "<title> #<N>" --review … --unpinned-ok "<reason>"`.'
+// The wait's bound keeps the four checks plus it under a foreground Bash call's 600-second cap, so the
+// verdict line is never cut off; a check past it is left running for the ship's pre-detach.
+const WAIT_MS = 240_000
+
+async function reached(root: string, is_started: boolean): Promise<PinnedSummary | undefined> {
+	if (is_started) return await run_review_pinned_join.settled_on_tree(root, WAIT_MS)
+
+	return await run_review_pinned_join.finished_on_tree(root)
+}
+
+// The unpinned places the ship's pre-detach would stop on, with the `--unpinned-ok` form;
+// `undefined` when no answer is reached on this tree or it stops nothing.
+async function notice(
+	root: string = PROJECT_ROOT,
+	is_started = false,
+): Promise<string | undefined> {
+	const summary = await reached(root, is_started)
+	if (summary === undefined) return undefined
+	const verdict = await run_review_pinned_accepted.judge(summary, undefined)
+
+	if (verdict.kind !== 'stop') return undefined
+
+	return test_pinned_logic.report_text(summary, `${SHIP_HINT}\n`).trimEnd()
+}
+
+const check_related_pinned = { SHIP_HINT, WAIT_MS, notice }
+
+export { check_related_pinned }

package/scripts/gate/check-related-reuse.ts

@@ -0,0 +1,64 @@
+import type { CheckResult } from './check-related'
+import { check_reuse, type CheckRecords } from './check-reuse'
+import { gate_labels } from './gate-labels'
+import type { GateStepResult } from './gate-report'
+import { gate_tree, type GateTree } from './gate-tree'
+import { scoped_green } from './scoped-green'
+
+// **`check:related` runs only the checks whose green record no longer holds** (joshuafolkken/kit#5156):
+// a re-run after fixing one failure ran the three that had passed over again, minutes of a hub-file
+// `test:related` among them. No record is new here. `lint:related` and `test:related` write their own
+// scoped records (`scoped-green.ts`); the type check and cspell read and write the gate's per-check
+// records under the gate's labels (`check-reuse.ts`), so a green from either end serves the other. A
+// failed check writes no record, so it runs again.
+
+const GATE_LABELS: ReadonlyMap<string, string> = new Map([
+	[gate_labels.TYPE_CHECK_TARGET, gate_labels.TYPE_CHECK_LABEL],
+	[gate_labels.SPELL_CHECK_TARGET, gate_labels.SPELL_CHECK_LABEL],
+])
+
+const UNREAD_TREE: GateTree = { files: {}, base: undefined }
+
+function gate_label(command: string): string {
+	return GATE_LABELS.get(command) ?? ''
+}
+
+// The commands of `commands` whose green record still describes `tree`.
+async function reusable(
+	commands: ReadonlyArray<string>,
+	tree: GateTree,
+	records: CheckRecords = check_reuse.DEFAULT_RECORDS,
+): Promise<ReadonlySet<string>> {
+	const scoped = new Set(scoped_green.green_scripts(tree.files, tree.base))
+	const gate = await check_reuse.reusable_checks([...GATE_LABELS.values()], tree, records)
+
+	return new Set(commands.filter((command) => scoped.has(command) || gate.has(gate_label(command))))
+}
+
+function gate_results(results: ReadonlyArray<CheckResult>): Array<GateStepResult> {
+	return results
+		.filter((result) => GATE_LABELS.has(result.command))
+		.map((result) => ({ ...result, label: gate_label(result.command), elapsed_ms: 0 }))
+}
+
+// Records the green type check and cspell against `tree`, the tree read before they started.
+async function record(
+	results: ReadonlyArray<CheckResult>,
+	tree: GateTree,
+	records: CheckRecords = check_reuse.DEFAULT_RECORDS,
+): Promise<void> {
+	await check_reuse.record_green_checks(gate_results(results), tree, records)
+}
+
+// A tree git could not read is one with no answer, so nothing is reused and every check runs.
+async function read_tree(): Promise<GateTree> {
+	try {
+		return await gate_tree.read_gate_tree()
+	} catch {
+		return UNREAD_TREE
+	}
+}
+
+const check_related_reuse = { UNREAD_TREE, read_tree, record, reusable }
+
+export { check_related_reuse }

package/scripts/gate/check-related-section.ts

@@ -0,0 +1,57 @@
+// **Each check prints only its last lines; its whole output is in the log** (joshuafolkken/kit#5204).
+// A `test:related` over hundreds of files printed past 140 KB, past the tool result's size limit, and
+// the run typed the same `check:related` again behind a `grep` only to read the verdict. The end of a
+// section is where a check's own verdict and its failures land, so a passed check keeps its last 5
+// lines and a failed one its last 40; `--full` prints the whole output as before.
+
+const PASSED_TAIL_LINES = 5
+const FAILED_TAIL_LINES = 40
+const FULL_FLAG = '--full'
+
+interface CheckResult {
+	command: string
+	exit_code: number
+	output: string
+}
+
+function result_status(result: CheckResult): string {
+	return result.exit_code === 0 ? 'passed' : `failed (${String(result.exit_code)})`
+}
+
+function tail_lines(result: CheckResult): ReadonlyArray<string> {
+	const lines = result.output.trimEnd().split('\n')
+	const count = result.exit_code === 0 ? PASSED_TAIL_LINES : FAILED_TAIL_LINES
+	const dropped = lines.length - count
+
+	if (dropped <= 0) return lines
+
+	return [`… ${String(dropped)} earlier line(s) in the log`, ...lines.slice(-count)]
+}
+
+function section_body(result: CheckResult, is_full: boolean): string {
+	if (is_full) return result.output.endsWith('\n') ? result.output : `${result.output}\n`
+
+	return `${tail_lines(result).join('\n')}\n`
+}
+
+function format_section(result: CheckResult, is_full = false): string {
+	const header = `\n=== ${result.command}: ${result_status(result)} ===\n`
+
+	if (result.output.length === 0) return header
+
+	return `${header}${section_body(result, is_full)}`
+}
+
+function is_full_requested(arguments_: ReadonlyArray<string>): boolean {
+	return arguments_.includes(FULL_FLAG)
+}
+
+const check_related_section = {
+	FAILED_TAIL_LINES,
+	format_section,
+	is_full_requested,
+	result_status,
+}
+
+export type { CheckResult }
+export { check_related_section }

package/scripts/gate/check-related-unplanned.ts

@@ -0,0 +1,34 @@
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import { error_text } from '#scripts/lib/error-message'
+import { run_ship_planned, type Unplanned } from '#scripts/run/ship/run-ship-planned'
+
+// **`check:related` prints the ship's `unplanned` answer ahead of the ship** (joshuafolkken/kit#5203):
+// asked only by the ship's preflight, a lane learned of a code file its `lane:plan` record never listed
+// after the review and its fixes, and spent the re-plan and a second ship on it. The judgment is the
+// preflight's own (`run-ship-planned.ts`); this run never stops on it — the preflight still does. Each
+// notice printed is recorded, so `lane:stats` tells a preflight `unplanned` stop that came after one apart.
+
+// A git read that fails here prints nothing rather than the run's verdict lost — the preflight still
+// asks it, and reports an unreadable read as its own precondition.
+async function read_unplanned(): Promise<Unplanned | undefined> {
+	try {
+		return await run_ship_planned.unplanned()
+	} catch (error) {
+		error_text.trace_swallowed('check_related_unplanned.notice', error)
+
+		return undefined
+	}
+}
+
+async function notice(): Promise<string | undefined> {
+	const found = await read_unplanned()
+
+	if (found === undefined) return undefined
+	await lane_ledger_write.record_unplanned_notice({ issue: found.issue, files: [...found.files] })
+
+	return found.text
+}
+
+const check_related_unplanned = { notice }
+
+export { check_related_unplanned }

package/scripts/gate/check-related.ts

@@ -0,0 +1,265 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { lint_related_scope } from '#scripts/lint/lint-related-scope'
+import { review_record_pinned } from '#scripts/review/review-record-pinned'
+import { execa } from 'execa'
+import run_parallel from 'run-parallel'
+import { check_related_pinned } from './check-related-pinned'
+import { check_related_reuse } from './check-related-reuse'
+import { check_related_section, type CheckResult } from './check-related-section'
+import { check_related_unplanned } from './check-related-unplanned'
+import { gate_labels } from './gate-labels'
+import { gate_log } from './gate-log'
+import { metrics_totals } from './metrics-totals'
+import { verification_tail } from './verification-tail'
+
+const COMMAND = 'check:related'
+// One file per checkout beside the gate's own log, overwritten by each run.
+const LOG_PATH = stamp_file.stamp_path(
+	'josh-check-related-log-',
+	PROJECT_ROOT,
+	gate_log.GATE_LOG_SUFFIX,
+)
+const LINT_RELATED = 'lint:related'
+// The verdict `lint:related` itself prints last, under its own label.
+const LINT_PASSED = verification_tail.format_verdict(lint_related_scope.COMMAND_LABEL, [])
+const CHECKS: ReadonlyArray<string> = [
+	LINT_RELATED,
+	'test:related',
+	gate_labels.TYPE_CHECK_TARGET,
+	'cspell:dot',
+]
+const REUSED = 'reused'
+const METRICS_STOP =
+	'`josh ship`\'s pre-detach stops on the metrics notice above unless the branch approval already names the total; settle it first (`pnpm josh metrics --accept --reason "<why>"`); the accept needs no `check:related` re-run, as the notice changed no exit code'
+
+type CheckExecutor = (command: string) => Promise<CheckResult>
+type ProcessRunner = (
+	file: string,
+	args: Array<string>,
+	options: { all: true; reject: false },
+) => Promise<{ all: string | null; exitCode?: number }>
+
+async function run_execa(
+	file: string,
+	args: Array<string>,
+	options: { all: true; reject: false },
+): Promise<{ all: string | null; exitCode?: number }> {
+	return await execa(file, args, options)
+}
+
+function failed_result(command: string, error: unknown): CheckResult {
+	return {
+		command,
+		exit_code: 1,
+		output: error instanceof Error ? error.message : String(error),
+	}
+}
+
+async function execute_check(
+	command: string,
+	run: ProcessRunner = run_execa,
+): Promise<CheckResult> {
+	try {
+		const result = await run('pnpm', ['josh', command], { all: true, reject: false })
+
+		return { command, exit_code: result.exitCode ?? 1, output: result.all ?? '' }
+	} catch (error) {
+		return failed_result(command, error)
+	}
+}
+
+async function start_check(
+	command: string,
+	execute: CheckExecutor,
+	complete: run_parallel.TaskCallback<CheckResult>,
+): Promise<void> {
+	try {
+		const result = await execute(command)
+
+		// eslint-disable-next-line unicorn/no-null -- run-parallel requires null for successful tasks.
+		complete(null, result)
+	} catch (error) {
+		// eslint-disable-next-line unicorn/no-null -- run-parallel requires null for successful tasks.
+		complete(null, failed_result(command, error))
+	}
+}
+
+async function run_checks(
+	execute: CheckExecutor = execute_check,
+	commands: ReadonlyArray<string> = CHECKS,
+): Promise<Array<CheckResult>> {
+	const tasks = commands.map((command): run_parallel.Task<CheckResult> => {
+		return (complete): void => {
+			void start_check(command, execute, complete)
+		}
+	})
+
+	return await new Promise<Array<CheckResult>>((resolve): void => {
+		run_parallel(tasks, (_error, results): void => {
+			resolve(results)
+		})
+	})
+}
+
+function failed_commands(results: ReadonlyArray<CheckResult>): ReadonlyArray<string> {
+	return results.filter((result) => result.exit_code !== 0).map((result) => result.command)
+}
+
+// The verdict is the last line, as every josh check prints it, so a reader of the tail sees every
+// check that failed rather than only the section that finished last (joshuafolkken/kit#4940).
+function checks_line(results: ReadonlyArray<CheckResult>): string {
+	return verification_tail.format_verdict(COMMAND, failed_commands(results))
+}
+
+// Each failed check and the command that reproduces it alone, above the log notice (joshuafolkken/kit#5162).
+function failure_lines(results: ReadonlyArray<CheckResult>): string {
+	const failed = failed_commands(results)
+	if (failed.length === 0) return ''
+
+	const lines = failed.map((command) =>
+		verification_tail.format_rerun(command, `pnpm josh ${command}`),
+	)
+
+	return `${COMMAND} — next:\n${lines.join('\n')}\n`
+}
+
+// Every check's whole output, kept where the console's size limit cannot reach, as `josh gate` keeps its own.
+function write_log(results: ReadonlyArray<CheckResult>, target: string): string | undefined {
+	const entries = results.map((result) => ({
+		header: `${result.command}: ${check_related_section.result_status(result)}`,
+		output: result.output,
+	}))
+
+	return gate_log.write_gate_log(entries, target)
+}
+
+function reused_suffix(reused: ReadonlySet<string>): string {
+	return reused.size === 0 ? '' : ` (reused: ${[...reused].join(', ')})`
+}
+
+// A notice is never a failure, so a passing verdict line alone hid it from a reader of the last lines,
+// and the ship's pre-detach stopped on it (joshuafolkken/kit#4987).
+function verdict_line(
+	results: ReadonlyArray<CheckResult>,
+	has_metrics_notice: boolean,
+	reused: ReadonlySet<string>,
+): string {
+	const line = `${checks_line(results)}${reused_suffix(reused)}`
+
+	return has_metrics_notice ? `${line} — ${METRICS_STOP}` : line
+}
+
+// `josh lint:related` ends its section with the metrics growth notice, which the sections after it
+// bury; it is repeated above the verdict so the tail still carries what stops `josh ship`
+// (joshuafolkken/kit#4939).
+function metrics_notice(results: ReadonlyArray<CheckResult>): string | undefined {
+	const output = results.find((result) => result.command === LINT_RELATED)?.output ?? ''
+	const start = output.indexOf(metrics_totals.NOTICE_HEADING)
+
+	if (start === -1) return undefined
+
+	// The lint's own verdict closes its section; it is not part of the notice.
+	return output.slice(start).replace(LINT_PASSED, '').trimEnd()
+}
+
+function report_reused(reused: ReadonlySet<string>): void {
+	for (const command of reused) {
+		process.stdout.write(`\n=== ${command}: ${REUSED} ===\n`)
+	}
+}
+
+interface ReportOptions {
+	pinned_notice?: string | undefined
+	unplanned_notice?: string | undefined
+	reused?: ReadonlySet<string>
+	log_target?: string
+	is_full?: boolean
+}
+
+function report_notices(notices: ReadonlyArray<string | undefined>): void {
+	for (const notice of notices) {
+		if (notice !== undefined) process.stdout.write(`\n${notice}\n`)
+	}
+}
+
+function report_results(results: ReadonlyArray<CheckResult>, options: ReportOptions = {}): void {
+	const { is_full, log_target = LOG_PATH, pinned_notice, reused = new Set<string>() } = options
+
+	report_reused(reused)
+
+	for (const result of results) {
+		process.stdout.write(check_related_section.format_section(result, is_full))
+	}
+
+	const metrics = metrics_notice(results)
+
+	report_notices([metrics, pinned_notice, options.unplanned_notice])
+
+	const log = { path: write_log(results, log_target) }
+	const verdict = verdict_line(results, metrics !== undefined, reused)
+
+	process.stdout.write(
+		`\n${verification_tail.format_tail({ failures: failure_lines(results), log, verdict })}`,
+	)
+}
+
+function exit_code(results: ReadonlyArray<CheckResult>): number {
+	return results.every((result: CheckResult): boolean => result.exit_code === 0) ? 0 : 1
+}
+
+// **The first check of a round-1 fix starts `josh test:pinned` again on the fixed tree**
+// (joshuafolkken/kit#4948): left to `josh review:record`, the restart came minutes before the ship, and
+// its pre-detach waited out a whole run. Started here, the check runs beside these four; a tree that did
+// not move, or a run outside a lane child, starts nothing. A verdict that check already reached on this
+// tree is printed above the verdict line, waited for when this run started it (`check-related-pinned.ts`).
+// A check whose green record still holds is not run (`check-related-reuse.ts`).
+async function run_all(
+	root?: string,
+	execute: CheckExecutor = execute_check,
+	is_full = false,
+): Promise<number> {
+	const is_started = await review_record_pinned.restart_in_lane(root)
+	const tree = await check_related_reuse.read_tree()
+	const reused = await check_related_reuse.reusable(CHECKS, tree)
+	const results = await run_checks(
+		execute,
+		CHECKS.filter((command) => !reused.has(command)),
+	)
+
+	await check_related_reuse.record(results, tree)
+	report_results(results, {
+		is_full,
+		pinned_notice: await check_related_pinned.notice(root, is_started),
+		unplanned_notice: await check_related_unplanned.notice(),
+		reused,
+	})
+
+	return exit_code(results)
+}
+
+const check_related = {
+	CHECKS,
+	METRICS_STOP,
+	REUSED,
+	execute_check,
+	exit_code,
+	report_results,
+	run_all,
+	run_checks,
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	process.exitCode = await check_related.run_all(
+		undefined,
+		execute_check,
+		check_related_section.is_full_requested(process.argv),
+	)
+}
+
+export type { CheckExecutor }
+export { check_related }
+
+export { type CheckResult } from './check-related-section'