@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/scripts/lint/eslint-daemon-calls.ts

@@ -0,0 +1,83 @@
+import { appendFileSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { atomic_write } from '#scripts/lib/atomic-write'
+
+// Which caller fed the checkout's `eslint_d` how many files (joshuafolkken/kit#7245). The daemon's
+// footprint grows with every file it lints over its life rather than with one call's size, since its
+// large heap lets V8 put off collecting (measured on joshuafolkken/kit#7245). So each line carries
+// the running total of the daemon it reached, and a new daemon starts the file afresh.
+
+const CALLS_RECORD = '.eslint_d-calls'
+const LINE_SEPARATOR = '\n'
+// `eslint_d` writes `<token> <port> <pid> <hash>` as the daemon's record.
+const DAEMON_RECORD_PID = /^\S+ \S+ (?<pid>\d+)/u
+const LAST_LINE = /total=(?<total>\d+) pid=(?<pid>\d+)$/u
+
+const DAEMON_CALLER = {
+	EDIT_HOOK: 'edit-hook',
+	WARM: 'warm',
+	PRE_COMMIT: 'pre-commit',
+	LINT_RELATED: 'lint:related',
+} as const
+
+interface DaemonCall {
+	caller: (typeof DAEMON_CALLER)[keyof typeof DAEMON_CALLER]
+	files: number
+}
+
+function pid_of(daemon_record = ''): string | undefined {
+	return DAEMON_RECORD_PID.exec(daemon_record)?.groups?.['pid']
+}
+
+function read_text(file: string): string {
+	try {
+		return readFileSync(file, 'utf8')
+	} catch {
+		return ''
+	}
+}
+
+// The total the record's last line names for `pid`, or nothing when it names another daemon.
+function previous_total(text: string, pid: string): number | undefined {
+	const groups = LAST_LINE.exec(text.trimEnd())?.groups
+	if (groups?.['pid'] !== pid) return undefined
+
+	return Number(groups['total'])
+}
+
+function line_of(call: DaemonCall, total: number, pid: string, now: Date): string {
+	const { caller, files } = call
+
+	return `${now.toISOString()} caller=${caller} files=${String(files)} total=${String(total)} pid=${pid}${LINE_SEPARATOR}`
+}
+
+// Best-effort, like the daemon's own record: a lost line costs one call's attribution, and two
+// callers that read the same last line before either appends both carry its total forward, so the
+// later total misses the other call's files. A measurement record tolerates either loss.
+function write_line(file: string, line: string, is_new_daemon: boolean): void {
+	try {
+		if (is_new_daemon) atomic_write.replace_file(file, line)
+		else appendFileSync(file, line)
+	} catch {
+		// The next call writes its own line.
+	}
+}
+
+function record(
+	directory: string,
+	daemon_record: string | undefined,
+	call: DaemonCall,
+	now: Date = new Date(),
+): void {
+	const pid = pid_of(daemon_record)
+	if (pid === undefined) return
+	const file = path.join(directory, CALLS_RECORD)
+	const previous = previous_total(read_text(file), pid)
+
+	write_line(file, line_of(call, (previous ?? 0) + call.files, pid, now), previous === undefined)
+}
+
+const eslint_daemon_calls = { pid_of, record, CALLS_RECORD, DAEMON_CALLER }
+
+export type { DaemonCall }
+export { eslint_daemon_calls }

package/scripts/lint/eslint-daemon.ts

@@ -3,16 +3,21 @@ import { lstatSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { untyped_environment } from '#eslint/untyped-environment.js'
 import { resolve_package_bin } from '#scripts/build/local-bin'
 import { toolchain_inputs } from '#scripts/gate/toolchain-inputs'
 import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
 import { atomic_write } from '#scripts/lib/atomic-write'
-import { buffered_process, type BufferedProcessResult } from '#scripts/lib/buffered-process'
+import type { BufferedProcessResult } from '#scripts/lib/buffered-process'
 import { execa } from 'execa'
+import { eslint_daemon_calls, type DaemonCall } from './eslint-daemon-calls'
 import { eslint_daemon_sources } from './eslint-daemon-sources'
+import { eslint_heap } from './eslint-heap'
 
 // One warm eslint per checkout, reached by every eslint run that is not the gate's whole tree: the
-// `PostToolUse` edit hook, `josh lint:related` and the pre-commit hook (joshuafolkken/kit#4358).
+// `PostToolUse` edit hook, `josh lint:related` and the pre-commit hook (joshuafolkken/kit#4358). It
+// lints without a type program, so no checkout keeps one resident; typed findings are the gate's,
+// whose lint runs cold (joshuafolkken/kit#6768).
 // `eslint_d` forwards the argument list to the project's own `eslint/lib/cli.js` → `execute`, run in
 // the forwarding process's cwd, so the report, the exit code and the cache file are eslint's own:
 // measured on this repository, a CLI run and a daemon run over the same files wrote byte-identical
@@ -20,6 +25,8 @@ import { eslint_daemon_sources } from './eslint-daemon-sources'
 
 const ESLINT_DAEMON = 'eslint_d'
 const DAEMON_STOP = 'stop'
+// How long a stop may hold the edit hook before it is given up (joshuafolkken/kit#7246).
+const STOP_TIMEOUT_MS = 10_000
 // The pnpm argument list every eslint caller here already builds. The daemon takes what follows it.
 const PNPM_EXEC = 'exec'
 const ESLINT_BIN = 'eslint'
@@ -49,6 +56,25 @@ interface DaemonOutcome {
 	output: string
 }
 
+// What a warm run did with the daemon, as `josh lint:related`'s timing line names it
+// (joshuafolkken/kit#5712): a stale one is stopped before the run, a failed start falls back cold.
+const DAEMON_STATE = {
+	REUSED: 'daemon reused',
+	RESTARTED: 'daemon restarted',
+	STARTED: 'daemon started',
+	COLD_FALLBACK: 'daemon unreachable, cold process',
+} as const
+
+type DaemonState = (typeof DAEMON_STATE)[keyof typeof DAEMON_STATE]
+
+interface WarmOutcome extends DaemonOutcome {
+	daemon: DaemonState
+}
+
+interface WarmRunResult extends BufferedProcessResult {
+	daemon: DaemonState
+}
+
 interface DaemonRecord {
 	// The running daemon's own record, or nothing when none runs.
 	daemon: string | undefined
@@ -59,6 +85,8 @@ interface DaemonRecord {
 interface DaemonRunOptions {
 	project_root: string
 	timeout_ms?: number
+	// Who asked and over how many files, recorded beside the daemon (`eslint-daemon-calls.ts`).
+	call?: DaemonCall | undefined
 }
 
 // `eslint_d` keys its one daemon on the record beside the eslint it resolves, so a project that
@@ -165,6 +193,13 @@ function is_stale(record: DaemonRecord, current: string): boolean {
 	return record.recorded !== record_text(record.daemon, current)
 }
 
+// What a run found, by the same reading that decides whether it stops the daemon first.
+function state_of(record: DaemonRecord, current: string): DaemonState {
+	if (record.daemon === undefined) return DAEMON_STATE.STARTED
+
+	return is_stale(record, current) ? DAEMON_STATE.RESTARTED : DAEMON_STATE.REUSED
+}
+
 // Best-effort, like the daemon's own record: one that could not be written restarts the daemon once
 // more on the next run.
 function remember(project_root: string, current: string): void {
@@ -214,8 +249,32 @@ function remember_after_edit(
 	else if (edited !== undefined) remember_read(project_root, after, edited)
 }
 
+// The call as the daemon that answered it saw it. A borrowed install's daemon belongs to the lending
+// checkout, whose lint volume this call is not.
+function record_call(project_root: string, call: DaemonCall | undefined): void {
+	const directory = eslint_directory(project_root)
+	if (call === undefined || directory === undefined || is_borrowed_install(project_root)) return
+
+	eslint_daemon_calls.record(directory, read_text(path.join(directory, DAEMON_RECORD)), call)
+}
+
 // `cwd` decides which eslint installation and which flat config answer, and `ESLINT_D_MISS=fail`
-// refuses the bundled eslint the daemon would otherwise fall back to.
+// refuses the bundled eslint the daemon would otherwise fall back to. The daemon keeps the environment
+// it started under, so the heap and the untyped switch set here hold for its whole life
+// (`eslint/untyped-environment.js`). Every path that may start it — this one and the edit hook —
+// launches with these, so whichever starts it first, the daemon gets the same heap.
+function launch_environment(): NodeJS.ProcessEnv {
+	return {
+		NODE_OPTIONS: eslint_heap.with_heap(process.env['NODE_OPTIONS']),
+		ESLINT_D_MISS: 'fail',
+		...untyped_environment.environment(),
+	}
+}
+
+function daemon_environment(): NodeJS.ProcessEnv {
+	return { ...eslint_heap.environment(), ...launch_environment() }
+}
+
 async function spawn_daemon(
 	cli: string,
 	cli_arguments: ReadonlyArray<string>,
@@ -225,7 +284,7 @@ async function spawn_daemon(
 		reject: false,
 		all: true,
 		cwd: options.project_root,
-		env: { ...buffered_process.child_environment(), ESLINT_D_MISS: 'fail' },
+		env: daemon_environment(),
 		extendEnv: false,
 		...(options.timeout_ms !== undefined && { timeout: options.timeout_ms }),
 	})
@@ -245,16 +304,32 @@ async function run_current(
 	cli: string,
 	eslint_arguments: ReadonlyArray<string>,
 	options: DaemonRunOptions,
-): Promise<DaemonOutcome | undefined> {
+): Promise<WarmOutcome | undefined> {
 	const { project_root } = options
 	const current = fingerprint(project_root)
-	if (is_stale(read_record(project_root), current)) await spawn_daemon(cli, [DAEMON_STOP], options)
+	const daemon = state_of(read_record(project_root), current)
+	if (daemon === DAEMON_STATE.RESTARTED) await spawn_daemon(cli, [DAEMON_STOP], options)
 
 	const outcome = await spawn_daemon(cli, eslint_arguments, options)
 	if (is_start_failure(outcome)) return undefined
 	remember(project_root, current)
+	record_call(project_root, options.call)
+
+	return { ...outcome, daemon }
+}
 
-	return outcome
+// Stops this checkout's daemon so the next run starts a fresh one; whether it stopped. No cli
+// resolves for a borrowed install, whose daemon belongs to the lending checkout. A stop that fails
+// or never answers within the bound reports false, so the caller warms no second daemon.
+async function stop(project_root: string): Promise<boolean> {
+	const cli = resolve_daemon_cli(project_root)
+	if (cli === undefined) return false
+	const outcome = await spawn_daemon(cli, [DAEMON_STOP], {
+		project_root,
+		timeout_ms: STOP_TIMEOUT_MS,
+	})
+
+	return outcome.exit_code === 0
 }
 
 // The run through the warm daemon, or nothing when there is no daemon to reach or it failed to
@@ -262,7 +337,7 @@ async function run_current(
 async function run(
 	pnpm_arguments: ReadonlyArray<string>,
 	options: DaemonRunOptions,
-): Promise<DaemonOutcome | undefined> {
+): Promise<WarmOutcome | undefined> {
 	const eslint_arguments = eslint_arguments_of(pnpm_arguments)
 	if (eslint_arguments === undefined) return undefined
 	const cli = resolve_daemon_cli(options.project_root)
@@ -272,17 +347,26 @@ async function run(
 }
 
 // The warm run from the current directory, read as a buffered child's result, or the cold
-// `pnpm exec eslint` when the daemon cannot answer — the one fallback `josh lint:related` and the
+// eslint (`eslint_heap.run_cold`) when the daemon cannot answer — the one fallback `josh lint:related` and the
 // pre-commit hook both take.
-async function run_or_cold(pnpm_arguments: ReadonlyArray<string>): Promise<BufferedProcessResult> {
+async function run_or_cold(
+	pnpm_arguments: ReadonlyArray<string>,
+	call?: DaemonCall,
+): Promise<WarmRunResult> {
 	const started_at = performance.now()
-	const outcome = await run(pnpm_arguments, { project_root: process.cwd() })
-	if (outcome === undefined) return await buffered_process.run_buffered_process(pnpm_arguments)
+	const outcome = await run(pnpm_arguments, { project_root: process.cwd(), call })
+
+	if (outcome === undefined) {
+		const cold = await eslint_heap.run_cold(pnpm_arguments)
+
+		return { ...cold, daemon: DAEMON_STATE.COLD_FALLBACK }
+	}
 
 	return {
 		output: outcome.output,
 		exit_code: outcome.exit_code,
 		elapsed_ms: performance.now() - started_at,
+		daemon: outcome.daemon,
 	}
 }
 
@@ -291,14 +375,18 @@ const eslint_daemon = {
 	fingerprint,
 	is_config_input,
 	is_stale,
+	launch_environment,
 	read_record,
+	record_call,
 	record_text,
 	remember_after_edit,
 	resolve_daemon_cli,
 	run,
 	run_or_cold,
+	stop,
 	ESLINT_DAEMON,
 }
 
-export type { DaemonOutcome, DaemonRecord }
+export type { DaemonCall } from './eslint-daemon-calls'
+export type { DaemonOutcome, DaemonRecord, DaemonState }
 export { eslint_daemon }

package/scripts/lint/eslint-heap.ts

@@ -0,0 +1,50 @@
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { core_weights } from '#scripts/gate/core-weights'
+import { find_package_directory } from '#scripts/josh/package-directory'
+import { buffered_process, type BufferedProcessResult } from '#scripts/lib/buffered-process'
+
+// ESLint takes its heap from here in `josh lint`, `josh format` and the refactor scan: the cold
+// eslint (`run_cold`), direct launches and the eslint_d forwarder, whose launcher hands its
+// environment on to the daemon. CI sets nothing of its own; its `josh gate` / `josh lint` arrive
+// here too. The size is the core budget's (`core-weights.ts`), which reserves it for each lint.
+const { ESLINT_HEAP_MIB } = core_weights
+
+// Node reads the flag with `-` or `_` between words (`node --help`), and either spelling set by the
+// person wins: their limit is a deliberate choice, this one only a floor for the default.
+const HEAP_FLAG = /--max[-_]old[-_]space[-_]size\b/u
+const NODE_OPTIONS = 'NODE_OPTIONS'
+const MODULE_DIRECTORY = path.dirname(fileURLToPath(import.meta.url))
+const MEMORY_PATH = path.join(
+	find_package_directory(MODULE_DIRECTORY),
+	'scripts/lint/eslint-memory.js',
+)
+const MEMORY_IMPORT = `--import=${pathToFileURL(MEMORY_PATH).href}`
+
+function with_heap(given_options: string | undefined): string {
+	const current = given_options?.trim() ?? ''
+	if (HEAP_FLAG.test(current)) return current
+	const heap = `--max-old-space-size=${String(ESLINT_HEAP_MIB)}`
+
+	return current === '' ? heap : `${current} ${heap}`
+}
+
+// The buffered child's environment, its other `NODE_OPTIONS` kept.
+function environment(): NodeJS.ProcessEnv {
+	const child = buffered_process.child_environment()
+
+	return { ...child, [NODE_OPTIONS]: with_heap(child[NODE_OPTIONS]) }
+}
+
+// A `pnpm exec eslint` list as a buffered child under this heap, launched without pnpm.
+async function run_cold(pnpm_arguments: ReadonlyArray<string>): Promise<BufferedProcessResult> {
+	const child = environment()
+
+	return await buffered_process.run_buffered_direct(pnpm_arguments, {
+		environment: { ...child, [NODE_OPTIONS]: `${child[NODE_OPTIONS] ?? ''} ${MEMORY_IMPORT}` },
+	})
+}
+
+const eslint_heap = { environment, run_cold, with_heap }
+
+export { ESLINT_HEAP_MIB, eslint_heap }

package/scripts/lint/eslint-memory.js

@@ -0,0 +1,45 @@
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+const KIB_PER_MIB = 1024
+const ESLINT_CLI = /[/\\]eslint[/\\]bin[/\\]eslint\.js$/u
+const OBSERVED = 'JOSH_ESLINT_MEMORY_CHILD'
+const BYTES_PER_MIB = KIB_PER_MIB * KIB_PER_MIB
+
+function peak_mib(report, platform) {
+	const line = report.split('\n').find((entry) => entry.includes('maximum resident set size')) ?? ''
+	if (platform === 'darwin') return Number(line.trim().split(/\s+/u, 1)[0]) / BYTES_PER_MIB
+
+	return Number(/^JOSH_ESLINT_RSS=(?<rss>\d+)$/mu.exec(report)?.groups?.rss) / KIB_PER_MIB
+}
+
+// time owns wait4's peak RSS even when V8 aborts before Node can run exit handlers.
+function observe() {
+	const directory = mkdtempSync(path.join(tmpdir(), 'eslint-memory-'))
+	const report_file = path.join(directory, 'usage')
+	const flags = process.platform === 'darwin' ? ['-l'] : ['-f', 'JOSH_ESLINT_RSS=%M']
+	const command = [process.execPath, ...process.execArgv, ...process.argv.slice(1)]
+
+	try {
+		const result = spawnSync('/usr/bin/time', [...flags, '-o', report_file, ...command], {
+			stdio: 'inherit',
+			env: { ...process.env, [OBSERVED]: '1' },
+		})
+
+		const peak = peak_mib(readFileSync(report_file, 'utf8'), process.platform)
+
+		process.stderr.write(`ESLint peak RSS: ${peak.toFixed(1)} MiB\n`)
+
+		return result.status ?? 1
+	} finally {
+		rmSync(directory, { recursive: true, force: true })
+	}
+}
+
+if (ESLINT_CLI.test(process.argv[1] ?? '') && process.env[OBSERVED] !== '1') process.exit(observe())
+
+const eslint_memory = { peak_mib }
+
+export { eslint_memory }

package/scripts/lint/eslint-trim.ts

@@ -0,0 +1,44 @@
+import {
+	run_board_usage_rusage,
+	type RusageReader,
+} from '#scripts/run/board/run-board-usage-rusage'
+import { eslint_daemon } from './eslint-daemon'
+import { eslint_daemon_calls } from './eslint-daemon-calls'
+import { eslint_warm } from './eslint-warm'
+
+// Restarts a checkout's eslint daemon once its footprint outgrows a fresh one (joshuafolkken/kit#7246).
+// The footprint grows with the files the daemon has linted over its life (#7245) and stays until the
+// lane closes. An idle timeout would not do: the daemon is warmed at `lane:open` and the first edit
+// comes after the plan and the reading, often past any short timeout, which would leave that edit cold.
+// **The restart is the warm-up's**, detached, so no edit waits for a cold daemon (#4720).
+//
+// The limit is about twice a daemon fresh from the warm-up, and under what a resident one reached
+// (both recorded on #7246), so restarts stay rare.
+const FOOTPRINT_LIMIT_MB = 600
+const BYTES_PER_KB = 1024
+const BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB
+
+function default_reader(): RusageReader | undefined {
+	return run_board_usage_rusage.rusage_reader(process.platform, run_board_usage_rusage.load_builtin)
+}
+
+function is_heavy(project_root: string, reader: RusageReader | undefined): boolean {
+	const pid = eslint_daemon_calls.pid_of(eslint_daemon.read_record(project_root).daemon)
+	if (pid === undefined || reader === undefined) return false
+	const footprint_bytes = reader(Number(pid))?.footprint_bytes ?? 0
+
+	return footprint_bytes > FOOTPRINT_LIMIT_MB * BYTES_PER_MB
+}
+
+// Whether the daemon was stopped and its replacement's warm-up started. Off macOS, or before Node
+// reads a footprint, nothing is measured and nothing restarts.
+async function trim(project_root: string, reader = default_reader()): Promise<boolean> {
+	if (!is_heavy(project_root, reader) || !(await eslint_daemon.stop(project_root))) return false
+	eslint_warm.start(project_root)
+
+	return true
+}
+
+const eslint_trim = { trim, BYTES_PER_MB, FOOTPRINT_LIMIT_MB }
+
+export { eslint_trim }

package/scripts/lint/eslint-warm.ts

@@ -4,18 +4,20 @@ import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
 import { resolve_tsx_runner } from '#scripts/josh/josh-logic'
 import { LINT_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { eslint_daemon } from './eslint-daemon'
+import { eslint_daemon_calls } from './eslint-daemon-calls'
 
 // Warms a fresh checkout's eslint daemon before its first edit (joshuafolkken/kit#4720). A cold
 // daemon took 5–8 s on the first edit hook's lint and 0.1–1.3 s once warm; `eslint_d start` alone
 // warms nothing — its first lint still took 8 s — because the cost is eslint loading the config, the
-// plugins and the type program, which only a lint of a typed source pays.
+// plugins and the TypeScript parser, which only a lint of a TypeScript source pays. The daemon holds
+// no type program (joshuafolkken/kit#6768), so that is all the warm-up loads.
 //
 // **The lint goes through `eslint_daemon.run` rather than the bare daemon**, so the daemon it starts
 // is recorded with its fingerprint: an unrecorded one is stale to `josh lint:related` and the
 // pre-commit hook, which would stop and cold-start it on their first run.
 
 const WARM_CLI = fileURLToPath(new URL('eslint-warm-cli.ts', import.meta.url))
-// One typed source the type program covers; a declaration file can be ignored by the flat config.
+// One TypeScript source; a declaration file can be ignored by the flat config.
 const TYPED_SOURCES: ReadonlyArray<string> = ['ls-files', '--', '*.ts', ':!*.d.ts']
 // A project with no TypeScript still loads its config and plugins through this.
 const FALLBACK_TARGET = 'eslint.config.js'
@@ -34,6 +36,7 @@ async function warm(project_root: string): Promise<void> {
 	await eslint_daemon.run(['exec', 'eslint', warm_target(project_root)], {
 		project_root,
 		timeout_ms: LINT_TIMEOUT_MS,
+		call: { caller: eslint_daemon_calls.DAEMON_CALLER.WARM, files: 1 },
 	})
 }
 

package/scripts/lint/format.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { direct_launch } from '#scripts/build/local-bin'
 import { project_checks } from '#scripts/gate/project-checks'
 import {
 	ESLINT_CACHE_FILE,
@@ -9,15 +10,39 @@ import {
 import { composite_arguments, USAGE_ERROR_EXIT_CODE } from '#scripts/josh/josh-composite-arguments'
 import { execa } from 'execa'
 import { eslint_cache_dependencies } from './eslint-cache-dependencies'
+import { eslint_heap } from './eslint-heap'
+import { lint_shard } from './lint-shard'
 
 const COMMAND_NAME = 'format'
 const ARGV_OFFSET = 2
 const FAIL_EXIT_CODE = 1
-const PRETTIER_WRITE_ARGS = ['exec', 'prettier', '--write', '.', ...PRETTIER_CACHE_FLAGS] as const
+
+function prettier_write_args_of(targets: ReadonlyArray<string>): ReadonlyArray<string> {
+	return ['exec', 'prettier', '--write', ...targets, ...PRETTIER_CACHE_FLAGS]
+}
+
+const PRETTIER_WRITE_ARGS = prettier_write_args_of([lint_shard.WHOLE_TREE])
+
+// The whole tree as this project formats it (`project_checks.prettier_targets`).
+function prettier_write_args(directory: string): ReadonlyArray<string> {
+	return prettier_write_args_of(project_checks.prettier_targets(directory, [lint_shard.WHOLE_TREE]))
+}
+
 const ESLINT_FIX_ARGS = ['exec', 'eslint', '.', '--fix', ...ESLINT_CACHE_FLAGS] as const
 
-async function run_step(args: ReadonlyArray<string>, directory: string): Promise<number> {
-	const result = await execa('pnpm', args, { cwd: directory, stdio: 'inherit', reject: false })
+async function run_step(
+	check: string,
+	args: ReadonlyArray<string>,
+	directory: string,
+): Promise<number> {
+	const environment = check === 'eslint' ? { env: eslint_heap.environment(), extendEnv: false } : {}
+	const launch = direct_launch(directory, args)
+	const result = await execa(launch.file, [...launch.args], {
+		cwd: directory,
+		stdio: 'inherit',
+		reject: false,
+		...environment,
+	})
 
 	return result.exitCode ?? FAIL_EXIT_CODE
 }
@@ -31,7 +56,7 @@ async function run_unless_skipped(
 	args: ReadonlyArray<string>,
 	directory: string,
 ): Promise<number> {
-	if (reason === undefined) return await run_step(args, directory)
+	if (reason === undefined) return await run_step(check, args, directory)
 	console.info(project_checks.skip_notice(check, reason))
 
 	return 0
@@ -42,7 +67,7 @@ async function run_format(directory: string): Promise<number> {
 	const prettier_exit_code = await run_unless_skipped(
 		'prettier',
 		prettier_reason,
-		PRETTIER_WRITE_ARGS,
+		prettier_write_args(directory),
 		directory,
 	)
 	if (prettier_exit_code !== 0) return prettier_exit_code