pi-shorthand 0.3.2 → 0.4.0

package/README.md

@@ -30,4 +30,12 @@ sudo apt install bubblewrap
 
 pi-shorthand gives Pi a programming environment instead of a patch format. This makes multi-file and structural edits possible in one call, but does not guarantee that Pi will find it easier or more reliable than its built-in edit tool. Which works better depends on the model and the task.
 
-Programs edit an isolated snapshot, with host files outside the repository kept read-only. By default, a failure keeps completed files and rolls back files involved in failed or interrupted edits; changes are applied only if their destination files have not changed. Progress is reported while a program runs, but no run history is written to disk.
+Programs edit an isolated snapshot, with host files outside the repository kept read-only. By default, a failure keeps completed files and rolls back files involved in failed or interrupted edits; changes are applied only if their destination files have not changed.
+
+## Diagnosing slow calls
+
+Calls taking longer than their configured program timeout (two seconds by default) show a muted timing footer. The timeout limits the editing program, not the entire transaction. Live progress also names the active setup or cleanup step.
+
+The footer separates parent-observed startup/IPC, runner work, and response/exit overhead. Snapshot detail includes inventory, copy, verification, attempt count, entry count, and logical file bytes. Nested measurements overlap and must not be added to their containing phase totals; logical bytes are not measured disk I/O. Formatting and edit execution include separate subprocess-wait and cleanup measurements.
+
+Infrastructure failures retain completed measurements and identify the failed phase. If the runner exits before reporting completion, its execution interval is marked as observed/incomplete. Structured diagnostics are attached to tool result details; source contents and individual filenames are not recorded in diagnostic events.

package/api.d.ts

@@ -8,6 +8,7 @@ declare global {
 	const grep: ShorthandGlobals["grep"];
 	const sg: ShorthandGlobals["sg"];
 	const grit: ShorthandGlobals["grit"];
+	const ts: ShorthandGlobals["ts"];
 }
 
 export type { RewriteResult } from "./prelude.ts";

package/diagnostics.ts

@@ -0,0 +1,142 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export interface DiagnosticSpan {
+	name: string;
+	startMs: number;
+	durationMs?: number;
+	failed?: boolean;
+}
+
+export interface Diagnostics {
+	spans: DiagnosticSpan[];
+	counters: Record<string, number>;
+	phase?: string;
+	failurePhase?: string;
+	runnerMs?: number;
+	startupMs?: number;
+	responseMs?: number;
+	wallMs?: number;
+	incomplete?: boolean;
+}
+
+const context = new AsyncLocalStorage<{
+	startedAt: number;
+	diagnostics: Diagnostics;
+	publish: (diagnostics: Diagnostics) => void;
+	phaseSpan?: DiagnosticSpan;
+}>();
+
+/** Run-local, bounded metadata only: never record source text, filenames or command output. */
+export async function withDiagnostics<T>(
+	operation: () => Promise<T>,
+	publish: (diagnostics: Diagnostics) => void,
+): Promise<{ value: T; diagnostics: Diagnostics }> {
+	const state = {
+		startedAt: performance.now(),
+		diagnostics: { spans: [], counters: {} } as Diagnostics,
+		publish: (diagnostics: Diagnostics) => {
+			try {
+				publish(diagnostics);
+			} catch {
+				/* Diagnostics must not change the operation's outcome. */
+			}
+		},
+	};
+	return context.run(state, async () => {
+		state.publish(state.diagnostics);
+		try {
+			return { value: await operation(), diagnostics: state.diagnostics };
+		} catch (error) {
+			diagnosticFailure();
+			throw error;
+		} finally {
+			const active = context.getStore()!;
+			if (active.phaseSpan)
+				active.phaseSpan.durationMs = Math.round(performance.now() - state.startedAt - active.phaseSpan.startMs);
+			state.diagnostics.runnerMs = Math.round(performance.now() - state.startedAt);
+			state.publish(state.diagnostics);
+		}
+	});
+}
+
+export async function measure<T>(name: string, operation: () => Promise<T>): Promise<T> {
+	const state = context.getStore();
+	if (!state) return operation();
+	const start = performance.now();
+	const span: DiagnosticSpan = { name, startMs: Math.round(start - state.startedAt) };
+	state.diagnostics.spans.push(span);
+	state.publish(state.diagnostics);
+	try {
+		return await operation();
+	} catch (error) {
+		span.failed = true;
+		throw error;
+	} finally {
+		span.durationMs = Math.round(performance.now() - start);
+		state.publish(state.diagnostics);
+	}
+}
+
+export function diagnosticCounter(name: string, value: number, add = false) {
+	const state = context.getStore();
+	if (!state) return;
+	state.diagnostics.counters[name] = value + (add ? (state.diagnostics.counters[name] ?? 0) : 0);
+	state.publish(state.diagnostics);
+}
+
+export function diagnosticPhase(phase: string) {
+	const state = context.getStore();
+	if (!state) return;
+	const now = Math.round(performance.now() - state.startedAt);
+	if (state.phaseSpan) state.phaseSpan.durationMs = now - state.phaseSpan.startMs;
+	state.phaseSpan = { name: phase, startMs: now };
+	state.diagnostics.spans.push(state.phaseSpan);
+	state.diagnostics.phase = phase;
+	state.publish(state.diagnostics);
+}
+
+export function diagnosticFailure() {
+	const state = context.getStore();
+	if (!state || state.diagnostics.failurePhase) return;
+	state.diagnostics.failurePhase = state.diagnostics.phase;
+	if (state.phaseSpan) state.phaseSpan.failed = true;
+}
+
+/** Spans are nested within runner phases; these figures must not be added to the phase total. */
+const duration = (ms: number) => `${ms}ms`;
+
+/** Parent-observed startup includes event delivery; a missing final event means execution is incomplete. */
+export function completeDiagnostics(diagnostics: Diagnostics, wallMs: number, startupMs: number): Diagnostics {
+	diagnostics.wallMs = Math.round(wallMs);
+	diagnostics.startupMs = Math.round(startupMs);
+	if (diagnostics.runnerMs === undefined) {
+		diagnostics.incomplete = true;
+		diagnostics.runnerMs = Math.max(0, diagnostics.wallMs - diagnostics.startupMs);
+	}
+	diagnostics.responseMs = Math.max(0, diagnostics.wallMs - diagnostics.startupMs - diagnostics.runnerMs);
+	return diagnostics;
+}
+
+export function diagnosticLines(diagnostics: Diagnostics): string[] {
+	const lines: string[] = [];
+	if (diagnostics.wallMs !== undefined) {
+		lines.push(
+			`wall ${duration(diagnostics.wallMs)} · runner startup/IPC ${duration(diagnostics.startupMs ?? 0)} · runner${diagnostics.incomplete ? " (observed, incomplete)" : ""} ${duration(diagnostics.runnerMs ?? 0)} · response/exit ${duration(diagnostics.responseMs ?? 0)}`,
+		);
+	}
+	if (diagnostics.spans.length) {
+		lines.push("phase detail (nested measurements overlap):");
+		lines.push(
+			...diagnostics.spans
+				.filter((span) => span.durationMs !== 0)
+				.map(
+					(span) =>
+						`  ${span.name}: ${span.durationMs === undefined ? "incomplete" : duration(span.durationMs)}${span.failed ? " (failed)" : ""}`,
+				),
+		);
+	}
+	const counters = Object.entries(diagnostics.counters);
+	if (counters.length) lines.push(counters.map(([name, value]) => `${name}: ${value}`).join(" · "));
+	if (diagnostics.failurePhase) lines.push(`failed during: ${diagnostics.failurePhase}`);
+	return lines;
+}

package/display.ts

@@ -8,7 +8,8 @@
  */
 
 import { getLanguageFromPath, highlightCode, keyHint, renderDiff, type Theme } from "@earendil-works/pi-coding-agent";
-import type { FileChange, RunResult } from "./runner.ts";
+import type { FileChange, RunResult, RunTimings } from "./runner.ts";
+import { diagnosticLines } from "./diagnostics.ts";
 
 type ToolBackground = "toolSuccessBg" | "toolErrorBg";
 
@@ -21,7 +22,7 @@ const LISTED_FILES = 8; // …showing this many, then "and N more files"
 const EXPANDED_DIFF_LINES = 2000; // even expanded, a diff of hundreds of files stops here
 
 export function callLine(args: { title?: string; timeout?: number; rollback?: string }, theme: Theme): string {
-	const settings = [args.rollback === "all" && "rollback all", args.timeout && `timeout ${args.timeout}s`];
+	const settings = [args.rollback === "all" && "rollback all", args.timeout && `program timeout ${args.timeout}s`];
 	const suffix = settings.filter(Boolean).join(", ");
 	return `${theme.fg("toolTitle", theme.bold("code"))} ${args.title ?? ""}${suffix ? theme.fg("muted", ` (${suffix})`) : ""}`;
 }
@@ -83,14 +84,51 @@ export function resultLines(run: RunResult, expanded: boolean, theme: Theme): st
 	if (output && (expanded || !error)) sections.push(outputLines(output, expanded, run.changes.length > 0, theme));
 	if (notApplied.length > 0) sections.push(notAppliedLines(notApplied, expanded, theme, background));
 	for (const section of sections) lines.push("", ...section);
+	const timing = timingBreakdown(run);
+	if (timing) lines.push("", theme.fg("muted", `timing: ${timing}`));
+	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= run.timeoutMs || run.exitCode !== 0)) {
+		lines.push(...diagnosticLines(run.diagnostics).map((line) => theme.fg("muted", line)));
+	}
 	return lines;
 }
 
+const TIMING_LABELS: Record<keyof RunTimings, string> = {
+	resolveRepositoryMs: "repository",
+	waitForLockMs: "lock wait",
+	workspaceSetupMs: "workspace setup",
+	programMs: "program",
+	scanChangesMs: "change scan",
+	formatMs: "formatter",
+	workspaceCloseMs: "workspace cleanup",
+	checkConflictsMs: "conflict check",
+	applyMs: "apply",
+	renderDiffMs: "diff",
+	unattributedMs: "other",
+};
+
+/** Explain calls exceeding the configured program budget, even when no individual phase does. */
+export function timingBreakdown(run: RunResult): string | undefined {
+	if (!run.timings || (run.diagnostics?.wallMs ?? run.durationMs) < run.timeoutMs) return undefined;
+	const significant = Object.entries(run.timings)
+		.map(([phase, milliseconds]) => ({
+			label: TIMING_LABELS[phase as keyof RunTimings],
+			milliseconds,
+		}))
+		.filter(({ milliseconds }) => milliseconds > 0)
+		.toSorted((a, b) => b.milliseconds - a.milliseconds);
+	if (significant.length === 0) return undefined;
+	return significant.map(({ label, milliseconds }) => `${label} ${formatDuration(milliseconds)}`).join(" · ");
+}
+
+function formatDuration(milliseconds: number): string {
+	return milliseconds < 1_000 ? `${milliseconds}ms` : `${(milliseconds / 1_000).toFixed(1)}s`;
+}
+
 /** e.g. "✓ Applied 3 files · +6 −6 · 0.6s" or "✕ Failed · rolled back all changes · exit 1 · 0.2s" */
 function verdict(run: RunResult, applied: FileChange[], theme: Theme): string {
 	const muted = (text: string) => theme.fg("muted", text);
 	const took = muted(` · ${(run.durationMs / 1000).toFixed(1)}s`);
-	const failure = run.timedOut ? `Timed out after ${run.timeoutMs / 1000}s` : "Failed";
+	const failure = run.timedOut ? `Program timed out after ${run.timeoutMs / 1000}s` : "Failed";
 	const exit = run.timedOut ? "" : muted(` · exit ${run.exitCode}`);
 
 	if (run.conflicts.length > 0) {

package/format.ts

@@ -4,6 +4,14 @@ import { dirname, extname, join, relative, resolve } from "node:path";
 
 type Command = { name: string; executable: string; args: string[]; cwd: string };
 
+/** A conservative filter: configuration and executable discovery still happen inside the sandbox. */
+export function supportsFormatting(file: string): boolean {
+	return (
+		/\.(?:[cm]?[jt]sx?|jsonc?|css|scss|less|html|vue|svelte|mdx?|ya?ml|graphql)$/i.test(file) ||
+		[".py", ".pyi", ".go", ".rs"].includes(extname(file))
+	);
+}
+
 function text(file: string): string {
 	try {
 		return readFileSync(file, "utf8");

package/index.ts

@@ -12,8 +12,25 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type Theme, truncateHead, truncateTail } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { callLine, countLines, fileMetadataSummary, resultLines, unstructuredResultText } from "./display.ts";
+import {
+	callLine,
+	countLines,
+	fileMetadataSummary,
+	resultLines,
+	timingBreakdown,
+	unstructuredResultText,
+} from "./display.ts";
 import type { FileChange, RunOptions, RunResult } from "./runner.ts";
+import { type Diagnostics, completeDiagnostics, diagnosticLines } from "./diagnostics.ts";
+
+class RunnerError extends Error {
+	constructor(
+		message: string,
+		readonly diagnostics: Diagnostics,
+	) {
+		super(message);
+	}
+}
 
 // Runs typically take well under a second. Longer transformations can request more time.
 const DEFAULT_TIMEOUT_SECONDS = 2;
@@ -26,6 +43,8 @@ Common operations:
 - sg.rewrite(pattern, replacement, files?) discovers and rewrites matching code; omit files for the working directory. $X captures one node; $$$X captures a sequence.
 - sg.one(pattern, files?) selects exactly one match; sg.find returns an array. sg.rewrite also accepts a selected match or array without a file scope.
 - A rewrite callback receives a match and returns text, a native node.replace(text) edit, or null to skip. Return native edits to apply them. Pass selected arrays together for independent edits; select again after changing their file.
+- await ts.rename({ file, symbol, to }) renames one resolved TypeScript symbol across the project without changing unrelated names.
+- await ts.renameFile({ from, to }) moves a TypeScript file and updates module paths that resolve to it.
 
 See the shorthand skill for common writes. For extraction, complex rewrites or other languages, read its advanced-refactors.md guide. The default timeout is two seconds; request more for longer programs.`;
 
@@ -72,16 +91,28 @@ export default function (pi: ExtensionAPI) {
 				});
 			}, 500);
 
-			const result = await runWithBun(
-				{
-					cwd: ctx.cwd,
-					program: params.program,
-					timeoutMs: (params.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
-					rollback: params.rollback ?? "file",
-				},
-				signal,
-				(step) => (latest = step),
-			).finally(() => clearInterval(progress));
+			let result: RunResult;
+			try {
+				result = await runWithBun(
+					{
+						cwd: ctx.cwd,
+						program: params.program,
+						timeoutMs: (params.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
+						rollback: params.rollback ?? "file",
+					},
+					signal,
+					(step) => (latest = step),
+				);
+			} catch (error) {
+				if (!(error instanceof RunnerError)) throw error;
+				return {
+					isError: true,
+					content: [{ type: "text" as const, text: [error.message, ...diagnosticLines(error.diagnostics)].join("\n") }],
+					details: { infrastructureError: error.message, diagnostics: error.diagnostics },
+				};
+			} finally {
+				clearInterval(progress);
+			}
 			return {
 				content: [{ type: "text", text: textForModel(result, toolCallId) }],
 				details: result,
@@ -107,6 +138,18 @@ export function renderCodeResult(
 		const progress = (result.details as { progress?: string } | undefined)?.progress;
 		return new Text(theme.fg("muted", progress ? `running… ${progress}` : "running…"), 0, 0);
 	}
+	if (result.details && typeof result.details === "object" && "infrastructureError" in result.details) {
+		const failure = result.details as { infrastructureError: string; diagnostics: Diagnostics };
+		return new Text(
+			[
+				theme.fg("error", failure.infrastructureError),
+				"",
+				...diagnosticLines(failure.diagnostics).map((line) => theme.fg("muted", line)),
+			].join("\n"),
+			0,
+			0,
+		);
+	}
 	const run = result.details as RunResult | undefined;
 	if (!run) return new Text(theme.fg("error", unstructuredResultText(result.content)), 0, 0);
 	return new Text(resultLines(run, expanded, theme).join("\n"), 0, 0);
@@ -122,6 +165,13 @@ export function runWithBun(
 	signal?: AbortSignal,
 	onProgress?: (step: string) => void,
 ): Promise<RunResult> {
+	const startedAt = performance.now();
+	let firstEventAt: number | undefined;
+	let diagnostics: Diagnostics = { spans: [], counters: {} };
+	const finishDiagnostics = () => {
+		const now = performance.now();
+		return completeDiagnostics(diagnostics, now - startedAt, (firstEventAt ?? now) - startedAt);
+	};
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) return reject(new Error("Aborted"));
 		const runner = spawn("bun", [path.join(import.meta.dirname, "runner.ts")], {
@@ -146,14 +196,23 @@ export function runWithBun(
 			progressBuffer = lines.pop() ?? "";
 			for (const line of lines) {
 				try {
-					const event = JSON.parse(line) as { step?: unknown };
+					const event = JSON.parse(line) as { step?: unknown; diagnostics?: Diagnostics };
+					firstEventAt ??= performance.now();
+					if (event.diagnostics) {
+						diagnostics = event.diagnostics;
+						const active = diagnostics.spans.findLast((span) => span.durationMs === undefined);
+						if (active) onProgress?.(active.name);
+					}
 					if (typeof event.step === "string") onProgress?.(event.step);
 				} catch {
 					// Progress is advisory; malformed events do not affect the run.
 				}
 			}
 		});
-		runner.on("error", reject);
+		runner.on("error", (error) => {
+			signal?.removeEventListener("abort", stop);
+			reject(new RunnerError(error.message, finishDiagnostics()));
+		});
 		runner.on("close", (code) => {
 			signal?.removeEventListener("abort", stop);
 			try {
@@ -162,10 +221,24 @@ export function runWithBun(
 				// nothing left
 			}
 			if (code === 0) {
-				const result: RunResult = JSON.parse(stdout);
+				let result: RunResult;
+				try {
+					result = JSON.parse(stdout);
+				} catch {
+					reject(new RunnerError("Runner returned invalid JSON", finishDiagnostics()));
+					return;
+				}
+				diagnostics = result.diagnostics ?? diagnostics;
+				result.diagnostics = finishDiagnostics();
 				if (!signal?.aborted || result.applied.length > 0 || result.cleanupWarnings.length > 0) resolve(result);
 				else reject(new Error("Aborted"));
-			} else reject(new Error(stderr.trim() || (signal?.aborted ? "Aborted" : `runner exited with ${code}`)));
+			} else
+				reject(
+					new RunnerError(
+						stderr.trim() || (signal?.aborted ? "Aborted" : `runner exited with ${code}`),
+						finishDiagnostics(),
+					),
+				);
 		});
 
 		runner.stdin.end(JSON.stringify(options));
@@ -205,6 +278,8 @@ function fileLine(change: FileChange): string {
 
 function textForModel(run: RunResult, toolCallId: string): string {
 	const lines = [summaryLine(run)];
+	const timing = timingBreakdown(run);
+	if (timing) lines.push(`Timing: ${timing}`);
 
 	if (run.applied.length === 0 && run.changes.length > 0) {
 		lines.push("The real workspace is unchanged. Below is the candidate diff.");
@@ -232,6 +307,8 @@ function textForModel(run: RunResult, toolCallId: string): string {
 	// On failure the error goes last, where it's easiest to find; on success, the diff does.
 	if (run.exitCode === 0 && run.conflicts.length === 0) lines.push(...output, ...diff);
 	else lines.push(...diff, ...output);
+	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= run.timeoutMs || run.exitCode !== 0))
+		lines.push("", ...diagnosticLines(run.diagnostics));
 	return lines.join("\n");
 }
 

package/lsp-client.ts

@@ -0,0 +1,183 @@
+import { spawn, spawnSync, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { readdirSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve as resolvePath } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+	createMessageConnection,
+	StreamMessageReader,
+	StreamMessageWriter,
+	type MessageConnection,
+} from "vscode-jsonrpc/node";
+
+interface TypeScriptServer {
+	root: string;
+	process: ChildProcessWithoutNullStreams;
+	connection: MessageConnection;
+	files: Map<string, string>;
+}
+
+let current: TypeScriptServer | undefined;
+let operations = Promise.resolve();
+process.once("exit", disposeCurrent);
+
+export async function withTypeScriptServer<T>(
+	root: string,
+	use: (connection: MessageConnection) => Promise<T>,
+): Promise<T> {
+	const result = operations.then(async () => {
+		const projectRoot = realpathSync(root);
+		if (current?.root === projectRoot) {
+			if (!sameFiles(current.files, projectFiles(projectRoot))) disposeCurrent();
+		} else {
+			disposeCurrent();
+		}
+		if (!current) {
+			current = await startTypeScriptServer(projectRoot);
+		}
+		const server = current;
+		setReferenced(server, true);
+		try {
+			return await use(server.connection);
+		} finally {
+			if (current === server) setReferenced(server, false);
+		}
+	});
+	operations = result.then(
+		() => undefined,
+		() => undefined,
+	);
+	return result;
+}
+
+/** Keep a reused server current; a failed notification only forfeits reuse of that server. */
+export async function notifyTypeScriptServer(
+	connection: MessageConnection,
+	method: string,
+	params: unknown,
+): Promise<void> {
+	try {
+		await connection.sendNotification(method, params);
+	} catch {
+		if (current?.connection === connection) disposeCurrent();
+	}
+}
+
+export function recordTypeScriptFiles(connection: MessageConnection, files: string[]): void {
+	if (current?.connection !== connection) return;
+	for (const file of files) {
+		const value = fingerprint(file);
+		if (value) current.files.set(file, value);
+		else current.files.delete(file);
+	}
+}
+
+async function startTypeScriptServer(root: string): Promise<TypeScriptServer> {
+	const server = spawn(typeScriptExecutable(), ["--lsp", "--stdio"], { cwd: root, env: process.env });
+	await new Promise<void>((ready, reject) => {
+		server.once("spawn", ready);
+		server.once("error", reject);
+	});
+	const connection = createMessageConnection(
+		new StreamMessageReader(server.stdout),
+		new StreamMessageWriter(server.stdin),
+	);
+	connection.listen();
+	try {
+		await connection.sendRequest("initialize", {
+			processId: process.pid,
+			rootUri: pathToFileURL(root).href,
+			capabilities: {
+				workspace: {
+					workspaceEdit: { documentChanges: true },
+					fileOperations: { didRename: true, willRename: true },
+				},
+				textDocument: { rename: { prepareSupport: true } },
+			},
+		});
+		await connection.sendNotification("initialized", {});
+	} catch (error) {
+		connection.dispose();
+		if (server.exitCode === null) server.kill("SIGKILL");
+		throw error;
+	}
+	server.stderr.resume();
+	const started = { root, process: server, connection, files: projectFiles(root) };
+	server.once("exit", () => {
+		if (current?.process !== server) return;
+		connection.dispose();
+		current = undefined;
+	});
+	setReferenced(started, false);
+	return started;
+}
+
+function sameFiles(left: Map<string, string>, right: Map<string, string>): boolean {
+	return left.size === right.size && [...left].every(([file, signature]) => right.get(file) === signature);
+}
+
+function projectFiles(root: string): Map<string, string> {
+	// The runner only applies Git-visible files, so ignored build output cannot make reuse stale.
+	const listed = spawnSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+		cwd: root,
+		encoding: "utf8",
+	});
+	if (listed.status === 0) {
+		return new Map(
+			listed.stdout
+				.split("\0")
+				.filter((file) => file && /\.(?:[cm]?[jt]sx?|json)$/.test(file))
+				.flatMap((file) => {
+					const absolute = resolvePath(root, file);
+					const value = fingerprint(absolute);
+					return value ? [[absolute, value] as const] : [];
+				}),
+		);
+	}
+
+	const files = new Map<string, string>();
+	const visit = (directory: string) => {
+		for (const entry of readdirSync(directory, { withFileTypes: true })) {
+			if (entry.name === ".git" || entry.name === "node_modules") continue;
+			const file = resolvePath(directory, entry.name);
+			if (entry.isDirectory()) visit(file);
+			else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|json)$/.test(entry.name)) {
+				files.set(file, fingerprint(file)!);
+			}
+		}
+	};
+	visit(root);
+	return files;
+}
+
+function fingerprint(file: string): string | undefined {
+	const stats = statSync(file, { bigint: true, throwIfNoEntry: false });
+	return stats?.isFile() ? `${stats.mtimeNs}:${stats.size}` : undefined;
+}
+
+function setReferenced(server: TypeScriptServer, referenced: boolean): void {
+	const method = referenced ? "ref" : "unref";
+	server.process[method]();
+	for (const stream of [server.process.stdin, server.process.stdout, server.process.stderr])
+		(stream as unknown as Record<typeof method, () => void>)[method]?.();
+	process.removeListener("beforeExit", disposeCurrent);
+	if (!referenced) process.once("beforeExit", disposeCurrent);
+}
+
+function disposeCurrent(): void {
+	if (!current) return;
+	const { connection, process: server } = current;
+	current = undefined;
+	connection.dispose();
+	if (server.exitCode === null) server.kill("SIGKILL");
+	server.unref();
+}
+
+function typeScriptExecutable(): string {
+	const require = createRequire(import.meta.url);
+	const typescriptPackage = require.resolve("typescript/package.json");
+	const requireTypeScriptDependency = createRequire(typescriptPackage);
+	const nativePackage = `@typescript/typescript-${process.platform}-${process.arch}/package.json`;
+	const packageFile = requireTypeScriptDependency.resolve(nativePackage);
+	return resolvePath(dirname(packageFile), "lib", process.platform === "win32" ? "tsc.exe" : "tsc");
+}