@orkestrel/probe 0.0.20 → 0.0.22

package/dist/src/server/index.js

@@ -1,20 +1,40 @@
 import { createRequire } from "node:module";
+import { JSONRPC_SERVER_ERROR, MCPError, createMCPLegacy, createMCPServer, isBoundedJSON } from "@orkestrel/mcp";
 import { closeSync, constants, existsSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { attempt, compileGuard, compileSchema, isArray, isError, isNumber, isObject, isRecord, isString, parseJSON, schemaToParameters } from "@orkestrel/contract";
-import { CLAIM_SHAPE, LINT_DEADLINE, PROBE_DEADLINE, PROBE_KEYS, PROBE_SPECIFICATIONS, ProbeError, RUNTIME_PLUGIN, TYPE_MIRROR, computeReceipt, createDestroyedError, formatCheck, formatReceipt, formatSpecification, formatVerdict, isClaim, isDraft, isProbeError, isVerdict, matchesSpecification } from "../core/index.js";
+import { CLAIM_SHAPE, LINT_DEADLINE, LINT_TEARDOWN, PROBE_DEADLINE, PROBE_KEYS, PROBE_RESTARTS, PROBE_SPECIFICATIONS, PROBE_WARM, ProbeError, RUNTIME_PLUGIN, TYPE_MIRROR, computeReceipt, createDestroyedError, formatCheck, formatReceipt, formatSpecification, formatVerdict, isClaim, isDraft, isProbeError, isVerdict, matchesSpecification } from "../core/index.js";
 import { Emitter } from "@orkestrel/emitter";
-import { createQueue } from "@orkestrel/queue";
+import { createPool, isPoolError } from "@orkestrel/pool";
+import { createLSPClient, isLSPError } from "@orkestrel/lsp";
+import { addAbortListener } from "node:events";
 import { createTimeout } from "@orkestrel/timeout";
-import { createLSPClient } from "@orkestrel/lsp";
 import { createStdioClientTransport } from "@orkestrel/lsp/server";
 import { PassThrough } from "node:stream";
 import { spawn, spawnSync } from "node:child_process";
-import { createMCPLegacy, createMCPServer, isBoundedJSON } from "@orkestrel/mcp";
 import { createStdioServer } from "@orkestrel/mcp/server";
 import { createTool, createToolManager } from "@orkestrel/tool";
+//#region src/server/errors.ts
+/**
+* Creates the protocol failure returned when the MCP handshake cannot arm the probe.
+*
+* @param error - The classified probe failure that ended initialization
+* @returns An MCP server error carrying the probe failure's origin and code as protocol data
+*
+* @example
+* ```ts
+* createHandshakeError(createDestroyedError('probe server')).code // -32000
+* ```
+*/
+function createHandshakeError(error) {
+	return new MCPError(`[${error.origin}] ${error.code}: ${error.message}`, JSONRPC_SERVER_ERROR, {
+		origin: error.origin,
+		code: error.code
+	});
+}
+//#endregion
 //#region src/server/helpers.ts
 /**
 * Rewrites one path into the forward-slash spelling this package compares and reports paths in.
@@ -1103,7 +1123,7 @@ var Overlay = class {
 };
 //#endregion
 //#region package.json
-var version = "0.0.20";
+var version = "0.0.22";
 var peerDependencies = {
 	"typescript": "^6.0.3",
 	"vitest": "^4.1.11"
@@ -1114,7 +1134,7 @@ var peerDependencies = {
 * Inspects virtual documents through one resident Oxlint language server.
 *
 * @remarks
-* Construction starts the target workspace's Oxlint binary with its Language Server Protocol mode
+* Starting launches the target workspace's Oxlint binary with its Language Server Protocol mode
 * and hands the conversation to `@orkestrel/lsp`: `createStdioClientTransport` owns the child
 * process and its bytes, and `createLSPClient` owns the framing, the request correlation, the
 * capabilities this stage advertises, and the choice between pulled and pushed diagnostics. This
@@ -1150,21 +1170,22 @@ var peerDependencies = {
 var LintStage = class {
 	#workspace;
 	#documents = /* @__PURE__ */ new Set();
-	#warmth;
+	#warming;
+	#exited = Promise.withResolvers();
 	#client;
+	#transport;
 	#ending;
 	#closing;
 	#progress = 0;
 	#revision = 0;
 	/**
-	* Starts warming the target workspace's Oxlint language server.
+	* Records the target workspace without starting its language server.
 	*
 	* @param workspace - The target workspace root. Default: the current working directory
 	*/
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
-		this.#warmth = this.#warm();
-		this.#warmth.catch(() => {});
+		this.#exited.promise.catch(() => {});
 	}
 	get stage() {
 		return "lint";
@@ -1172,6 +1193,15 @@ var LintStage = class {
 	get progress() {
 		return this.#progress;
 	}
+	get exit() {
+		return this.#exited.promise;
+	}
+	start() {
+		if (this.#closing !== void 0) return Promise.reject(createDestroyedError("lint stage"));
+		this.#warming ??= guardStage(this.stage, this.#warm());
+		this.#warming.catch(() => {});
+		return this.#warming;
+	}
 	inspect(subject, options) {
 		return guardStage(this.stage, this.#inspect(subject, options));
 	}
@@ -1188,8 +1218,10 @@ var LintStage = class {
 			context: { stage: this.stage }
 		});
 		const started = performance.now();
-		const client = await this.#warmed();
+		await this.start();
 		if (this.#closing !== void 0) throw createDestroyedError("lint stage");
+		const client = this.#client;
+		if (client === void 0) throw this.#fault("The Oxlint language server did not initialize");
 		const issues = [];
 		for (const draft of [...subject.files, subject.test]) issues.push(...await this.#document(client, draft, options.signal));
 		return {
@@ -1200,38 +1232,39 @@ var LintStage = class {
 	}
 	async #destroy() {
 		await this.#client?.destroy();
+		await this.#transport?.close();
 	}
 	async #warm() {
 		const binary = resolveWorkspaceBinary(this.#workspace, "oxlint");
+		const transport = createStdioClientTransport({
+			server: {
+				command: [
+					process.execPath,
+					binary,
+					"--lsp"
+				],
+				directory: this.#workspace
+			},
+			grace: LINT_DEADLINE / 2
+		});
+		this.#transport = transport;
 		const client = createLSPClient({
-			transport: createStdioClientTransport({
-				server: {
-					command: [
-						process.execPath,
-						binary,
-						"--lsp"
-					],
-					directory: this.#workspace
-				},
-				grace: LINT_DEADLINE / 2
-			}),
+			transport,
 			workspace: pathToFileURL(this.#workspace).href,
 			timeout: LINT_DEADLINE
 		});
 		this.#client = client;
 		client.emitter.on("exit", (exit) => this.#retire(exit));
-		await client.start();
-		return client;
-	}
-	async #warmed() {
 		try {
-			return await this.#warmth;
+			await client.start();
 		} catch (error) {
 			throw this.#translate(error);
 		}
 	}
 	#retire(exit) {
+		if (this.#closing !== void 0) return;
 		this.#ending = exit.signal === null ? `code ${exit.code}` : `signal ${exit.signal}`;
+		this.#exited.reject(this.#fault(`The Oxlint language server exited with ${this.#ending}`));
 	}
 	async #document(client, draft, signal) {
 		const uri = pathToFileURL(resolveWorkspaceFile(this.#workspace, draft.path)).href;
@@ -1274,9 +1307,9 @@ var LintStage = class {
 		});
 	}
 	#translate(error, path) {
-		if (this.#closing !== void 0) return createDestroyedError("lint stage");
 		const ending = this.#ending;
 		if (ending !== void 0) return this.#fault(`The Oxlint language server exited with ${ending}`, error, path);
+		if (this.#closing !== void 0) return createDestroyedError("lint stage");
 		if (isError(error)) return error;
 		return this.#fault(describeUnknown(error), error, path);
 	}
@@ -1315,7 +1348,7 @@ var LintStage = class {
 * Inspects tests through one resident Vitest service from the target workspace.
 *
 * @remarks
-* Construction starts Vitest with the threads pool and instruments each inline or function-declared
+* Starting launches Vitest with the threads pool and instruments each inline or function-declared
 * project with a Vite plugin that reads the active inspection's candidate overlay. A selected
 * string-declared project reports a workspace issue because its configuration carries no runtime
 * overlay plugin. Every inspection writes one fresh sibling specification, invalidates each
@@ -1374,6 +1407,7 @@ var LintStage = class {
 var RuntimeStage = class {
 	#workspace;
 	#vitest;
+	#warming;
 	#overlay = new Overlay();
 	#loads = /* @__PURE__ */ new Set();
 	#reads = /* @__PURE__ */ new Set();
@@ -1383,16 +1417,12 @@ var RuntimeStage = class {
 	#closing;
 	#progress = 0;
 	/**
-	* Starts warming the target workspace's Vitest service.
-	*
-	* @remarks Loading starts during this call. A loader refusal rejects the owned warm operation
-	* rather than construction, so `inspect` reports it and `destroy` remains available.
+	* Records the target workspace without loading its Vitest service.
 	*
 	* @param workspace - The target workspace root. Default: the current working directory
 	*/
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
-		this.#store(this.#warm());
 	}
 	get stage() {
 		return "runtime";
@@ -1401,6 +1431,20 @@ var RuntimeStage = class {
 		return this.#progress;
 	}
 	/**
+	* Begins the warm or joins the warm already begun.
+	*
+	* @returns A promise that resolves after the resident Vitest service is ready
+	* @throws When warming fails or teardown has begun
+	*/
+	start() {
+		if (this.#closing !== void 0) return Promise.reject(createDestroyedError("runtime stage"));
+		this.#warming ??= guardStage(this.stage, this.#store(this.#warm()).then(() => {}));
+		this.#warming.catch(() => {
+			this.#warming = void 0;
+		});
+		return this.#warming;
+	}
+	/**
 	* Inspects one case.
 	*
 	* @param subject - The candidate drafts and test to inspect
@@ -1431,6 +1475,7 @@ var RuntimeStage = class {
 	async #inspect(subject) {
 		if (this.#closing !== void 0) throw createDestroyedError("runtime stage");
 		const started = performance.now();
+		await this.start();
 		const exitCode = process.exitCode;
 		const vitest = await this.#runner();
 		if (this.#closing !== void 0) throw createDestroyedError("runtime stage");
@@ -1963,7 +2008,7 @@ var RuntimeStage = class {
 *
 * @remarks
 * The compiler is a process this stage spawns rather than a module it loads, so nothing here holds
-* a resident program and the host's event loop is free for the whole check. Construction sweeps a
+* a resident program and the host's event loop is free for the whole check. Starting sweeps a
 * mirror an earlier host left behind, copies the workspace into a fresh one under
 * {@link TYPE_MIRROR}, and builds each declared project's incremental state there, so the first
 * inspection is warm.
@@ -2006,16 +2051,13 @@ var TypeStage = class {
 	#closing;
 	#progress = 0;
 	/**
-	* Resolves the target workspace's compiler and starts warming its mirror.
+	* Records the workspace and the mirror path without starting its compiler.
 	*
 	* @param workspace - The target workspace root. Default: the current working directory
 	*/
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
-		this.#compiler = resolveWorkspaceBinary(workspace, "typescript", "tsc");
-		this.#mirror = resolveWorkspaceFile(workspace, `${TYPE_MIRROR}/${this.#revision}`);
-		this.#warming = this.#warm();
-		this.#warming.catch(() => {});
+		this.#mirror = resolve(workspace, TYPE_MIRROR, this.#revision);
 	}
 	get stage() {
 		return "type";
@@ -2023,6 +2065,12 @@ var TypeStage = class {
 	get progress() {
 		return this.#progress;
 	}
+	start() {
+		if (this.#closing !== void 0) return Promise.reject(createDestroyedError("type stage"));
+		this.#warming ??= guardStage(this.stage, this.#warm());
+		this.#warming.catch(() => {});
+		return this.#warming;
+	}
 	/**
 	* Inspects one case, against a caller-named project where the caller names one.
 	*
@@ -2066,7 +2114,7 @@ var TypeStage = class {
 	async #inspect(subject, project) {
 		this.#refuseDestroyed();
 		const started = performance.now();
-		await this.#warming;
+		await this.start();
 		this.#refuseDestroyed();
 		const test = resolveWorkspaceFile(this.#workspace, subject.test.path);
 		const resolved = subject.files.map((draft) => ({
@@ -2102,6 +2150,8 @@ var TypeStage = class {
 		}
 	}
 	async #resolve(project) {
+		this.#refuseDestroyed();
+		await this.start();
 		this.#refuseDestroyed();
 		const contained = this.#contain(project);
 		this.#progress += 1;
@@ -2115,7 +2165,7 @@ var TypeStage = class {
 		const children = [...this.#children];
 		this.#children.clear();
 		for (const child of children) this.#terminate(child);
-		await this.#warming.catch(() => void 0);
+		await this.#warming?.catch(() => void 0);
 		try {
 			rmSync(this.#mirror, {
 				recursive: true,
@@ -2129,6 +2179,7 @@ var TypeStage = class {
 		this.#drafts.clear();
 	}
 	async #warm() {
+		this.#compiler = resolveWorkspaceBinary(this.#workspace, "typescript", "tsc");
 		this.#sweep();
 		this.#createMirror();
 		this.#refresh();
@@ -2363,8 +2414,10 @@ var TypeStage = class {
 	}
 	#spawn(args, cwd) {
 		this.#refuseDestroyed();
+		const compiler = this.#compiler;
+		if (compiler === void 0) throw createDestroyedError("type stage");
 		return new Promise((settle, refuse) => {
-			const child = spawn(process.execPath, [this.#compiler, ...args], {
+			const child = spawn(process.execPath, [compiler, ...args], {
 				cwd,
 				stdio: [
 					"ignore",
@@ -2401,7 +2454,7 @@ var TypeStage = class {
 					code: "malformed",
 					context: {
 						stage: this.stage,
-						path: this.#compiler
+						path: compiler
 					},
 					cause: error
 				}));
@@ -2436,9 +2489,10 @@ var TypeStage = class {
 * Answers claims through its type, lint, and runtime stages.
 *
 * @remarks
-* Construction resolves the target workspace's toolchain and begins warming every stage. The boot
+* Construction resolves the target workspace's toolchain. Starting warms every stage and waits
+* for lint and runtime; type warming and the boot controls continue behind that gate. The boot
 * controls mutate imported dependencies and refuse service unless the type and runtime stages
-* report their respective changes. One queue per stage admits inspections in arrival order, one at
+* report their respective changes. One pool per stage admits inspections in arrival order, one at
 * a time, so a stage never serves two claims at once and the deadline covers active work rather
 * than queue wait. Each active stage inspection has a coordinator-owned deadline. An expiry at any
 * stage abandons that stage and replaces it before the next queued inspection begins, so one slow
@@ -2483,34 +2537,36 @@ var TypeStage = class {
 * const probe = new Probe({ workspace: process.cwd() })
 * const verdict = await probe.prove(claim)
 * verdict.digest // 'bdf03e5dfd6bd413ead671c7a2940fcf'
-* verdict.receipt // 'probe:bdf03e5dfd6bd413ead671c7a2940fcf:type:typescript@6.0.3:oxlint@1.86.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+* verdict.receipt // 'probe:bdf03e5dfd6bd413ead671c7a2940fcf:type:typescript@6.0.3:oxlint@1.87.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
 * await probe.destroy()
 * ```
 */
 var Probe = class {
 	#workspace;
 	#deadline;
+	#warmth;
 	#emitter;
 	#toolchain;
 	#type;
 	#lint;
 	#runtime;
-	#typeQueue;
-	#lintQueue;
-	#runtimeQueue;
 	#deadlines = /* @__PURE__ */ new WeakSet();
 	#surfaced = /* @__PURE__ */ new WeakSet();
-	#typeTail = Promise.resolve();
+	#survivors = /* @__PURE__ */ new Map();
+	#abort = new AbortController();
 	#arming;
+	#refusal;
+	#starting;
 	#closing;
 	/**
-	* Resolves the target toolchain and starts warming every stage.
+	* Resolves the target toolchain and constructs the stage pools without warming them.
 	*
-	* @param options - Workspace, deadline, and initial observation hooks
+	* @param options - Workspace, inspection and warm bounds, and initial observation hooks
 	*/
 	constructor(options) {
 		this.#workspace = options?.workspace ?? process.cwd();
 		this.#deadline = createTimeout({ ms: options?.deadline ?? PROBE_DEADLINE }).ms;
+		this.#warmth = createTimeout({ ms: options?.warm ?? PROBE_WARM }).ms;
 		this.#emitter = new Emitter({
 			...options?.on === void 0 ? {} : { on: options.on },
 			...options?.error === void 0 ? {} : { error: options.error }
@@ -2520,26 +2576,28 @@ var Probe = class {
 			oxlint: this.#version("oxlint"),
 			vitest: this.#version("vitest")
 		});
-		this.#type = new TypeStage(this.#workspace);
-		this.#lint = new LintStage(this.#workspace);
-		this.#runtime = new RuntimeStage(this.#workspace);
-		this.#typeQueue = createQueue({
-			concurrency: 1,
-			retries: 0,
-			handler: this.#inspectType.bind(this)
+		this.#type = createPool({
+			create: () => this.#warm(new TypeStage(this.#workspace)),
+			destroy: this.#dispose.bind(this),
+			error: this.#surface.bind(this),
+			min: 1,
+			restarts: PROBE_RESTARTS
 		});
-		this.#lintQueue = createQueue({
-			concurrency: 1,
-			retries: 0,
-			handler: this.#inspectLint.bind(this)
+		this.#lint = createPool({
+			create: this.#createLint.bind(this),
+			destroy: this.#dispose.bind(this),
+			watch: (stage) => stage.exit,
+			error: this.#surface.bind(this),
+			min: 1,
+			restarts: PROBE_RESTARTS
 		});
-		this.#runtimeQueue = createQueue({
-			concurrency: 1,
-			retries: 0,
-			handler: this.#inspectRuntime.bind(this)
+		this.#runtime = createPool({
+			create: () => this.#warm(new RuntimeStage(this.#workspace)),
+			destroy: this.#dispose.bind(this),
+			error: this.#surface.bind(this),
+			min: 1,
+			restarts: PROBE_RESTARTS
 		});
-		this.#arming = this.#arm();
-		this.#arming.catch(() => {});
 	}
 	get emitter() {
 		return this.#emitter;
@@ -2551,7 +2609,16 @@ var Probe = class {
 		try {
 			this.#support();
 			this.#admit(claim);
-			await this.#ready();
+			await this.start();
+			const arming = this.#arming;
+			try {
+				await arming;
+			} catch (error) {
+				if (this.#arming === arming) this.#arming = void 0;
+				const refusal = this.#refusal;
+				this.#refusal = void 0;
+				throw refusal === void 0 ? error : refusal.cause;
+			}
 			if (this.#closing !== void 0) throw createDestroyedError("probe");
 			const started = performance.now();
 			const id = randomUUID();
@@ -2586,45 +2653,65 @@ var Probe = class {
 	}
 	destroy() {
 		if (this.#closing !== void 0) return this.#closing;
-		this.#closing = this.#destroy();
+		this.#closing = Promise.resolve().then(this.#destroy.bind(this));
 		return this.#closing;
 	}
-	async #ready() {
-		const attempt = this.#arming;
+	start() {
+		if (this.#closing !== void 0) return Promise.reject(createDestroyedError("probe"));
+		const warming = this.#type.start();
+		warming.catch(() => {});
+		const filling = Promise.all([this.#lint.start(), this.#runtime.start()]);
+		filling.catch(() => {});
+		if (this.#starting !== void 0) return this.#starting;
+		this.#starting = this.#start(filling, warming);
+		this.#starting.then(() => {
+			this.#starting = void 0;
+		}, () => {
+			this.#starting = void 0;
+		});
+		return this.#starting;
+	}
+	async #start(filling, warming) {
+		let created = false;
 		try {
-			await attempt;
-			return;
+			this.#support();
+			if (this.#arming === void 0) created = this.#workbench();
+		} catch (error) {
+			this.#surface(error);
+			throw error;
+		}
+		try {
+			await filling;
+			if (this.#closing !== void 0) throw createDestroyedError("probe");
 		} catch (error) {
-			if (this.#closing !== void 0) throw error;
+			throw this.#refuseArm(error);
 		}
-		if (this.#arming === attempt) {
-			this.#arming = this.#arm();
-			this.#arming.catch(() => {});
+		if (this.#arming === void 0) {
+			this.#arming = this.#arm(warming, created);
+			this.#arming.catch(() => {
+				if (this.#refusal === void 0) this.#arming = void 0;
+			});
 		}
-		await this.#arming;
 	}
-	async #arm() {
-		let created;
+	async #arm(warming, created) {
 		try {
-			created = this.#workbench();
+			await warming;
 		} catch (error) {
-			this.#surface(error);
-			throw error;
+			if (this.#closing !== void 0) throw createDestroyedError("probe");
+			const cause = this.#refusal?.cause ?? (isPoolError(error) ? error.cause : error);
+			this.#surface(cause);
+			throw cause;
 		}
 		try {
+			if (this.#closing !== void 0) throw createDestroyedError("probe");
 			await this.#boot(created);
 		} catch (error) {
-			const failure = new ProbeError(`The probe could not arm: ${describeUnknown(error)}`, {
-				origin: "instrument",
-				code: "malformed",
-				cause: error
-			});
-			this.#surface(failure);
-			throw failure;
+			throw this.#refuseArm(error);
 		}
 		this.#emitter.emit("arm", this.#toolchain);
 	}
 	#surface(error) {
+		if (this.#closing !== void 0) return;
 		if (isProbeError(error)) this.#surfaced.add(error);
 		this.#emitter.emit("error", error);
 	}
@@ -2740,102 +2827,130 @@ var Probe = class {
 			subject,
 			claim
 		};
-		const admitted = [
-			this.#typeQueue.enqueue(inspection),
-			this.#lintQueue.enqueue(inspection),
-			this.#runtimeQueue.enqueue(inspection)
-		];
-		for (const pending of admitted) pending.catch(() => {});
-		return Promise.all(admitted);
+		return Promise.all([
+			this.#inspectType(inspection),
+			this.#inspectLint(inspection),
+			this.#inspectRuntime(inspection)
+		]);
 	}
 	async #inspectType(inspection) {
-		const release = await this.#admitType();
-		try {
-			const stage = this.#type;
-			return await this.#inspectStage(stage, stage.progress, () => stage.inspect(inspection.subject, inspection.claim.project), inspection.claim);
-		} finally {
-			release();
-		}
+		const token = await this.#lease(this.#type);
+		return this.#inspectStage(token, () => token.value.inspect(inspection.subject, inspection.claim.project), inspection.claim);
 	}
-	#inspectLint(inspection) {
-		const stage = this.#lint;
-		return this.#inspectStage(stage, stage.progress, (signal) => stage.inspect(inspection.subject, { signal }), inspection.claim);
+	async #inspectLint(inspection) {
+		const token = await this.#lease(this.#lint);
+		return this.#inspectStage(token, (signal) => token.value.inspect(inspection.subject, { signal }), inspection.claim);
 	}
-	#inspectRuntime(inspection) {
-		const stage = this.#runtime;
-		return this.#inspectStage(stage, stage.progress, () => stage.inspect(inspection.subject), inspection.claim);
+	async #inspectRuntime(inspection) {
+		const token = await this.#lease(this.#runtime);
+		return this.#inspectStage(token, () => token.value.inspect(inspection.subject), inspection.claim);
 	}
-	async #inspectStage(stage, progress, operation, claim) {
+	async #inspectStage(token, operation, claim, message = `The ${token.value.stage} stage exceeded ${this.#deadline} ms`) {
+		const stage = token.value;
 		try {
-			return await this.#bound(operation, `The ${stage.stage} stage exceeded ${this.#deadline} ms`, stage, progress);
+			return await this.#bound(operation, message, stage, stage.progress);
 		} catch (error) {
-			this.#emitExpiry(stage, claim);
+			if (isProbeError(error) && this.#deadlines.has(error)) {
+				await token.destroy().catch(() => {});
+				if (this.#closing === void 0) this.#emitter.emit("expire", claim);
+			}
 			throw error;
+		} finally {
+			token.release();
 		}
 	}
-	async #bound(operation, message, stage, progress) {
-		const timeout = createTimeout({ ms: this.#deadline });
+	async #bound(operation, message, stage, progress, ms = this.#deadline) {
+		const timeout = createTimeout({ ms });
 		timeout.start();
 		const expiry = this.#expiry(timeout, message, stage, progress);
 		const refusal = expiry.catch((error) => error);
 		try {
 			return await Promise.race([operation(timeout.signal), expiry]);
 		} catch (error) {
-			if (!timeout.expired) throw error;
-			await this.#recycle(stage);
-			throw await refusal;
+			if (timeout.expired) throw await refusal;
+			throw error;
 		} finally {
 			timeout.clear();
 		}
 	}
-	async #recycle(stage) {
-		if (this.#closing !== void 0) return false;
-		const timeout = createTimeout({ ms: this.#deadline });
-		timeout.start();
-		try {
-			await Promise.race([stage.destroy(), this.#expiry(timeout, `The ${stage.stage} stage recovery exceeded ${this.#deadline} ms`, stage, stage.progress)]);
-		} catch {} finally {
-			timeout.clear();
-		}
-		if (this.#closing !== void 0) return false;
-		if (stage === this.#type) {
-			this.#type = new TypeStage(this.#workspace);
-			return true;
-		}
-		if (stage === this.#lint) {
-			this.#lint = new LintStage(this.#workspace);
-			return true;
+	async #resolve(claim) {
+		const token = await this.#lease(this.#type);
+		if (this.#refusal !== void 0) {
+			const refusal = this.#refusal;
+			this.#refusal = void 0;
+			token.release();
+			throw refusal.cause;
 		}
-		if (stage === this.#runtime) {
-			this.#runtime = new RuntimeStage(this.#workspace);
-			return true;
+		const stage = token.value;
+		return this.#inspectStage(token, () => stage.resolve(claim.project), claim, `The type stage project resolution exceeded ${this.#deadline} ms`);
+	}
+	async #lease(pool) {
+		try {
+			return await pool.acquire();
+		} catch (error) {
+			if (isPoolError(error)) {
+				if (error.code === "destroyed") throw createDestroyedError("probe");
+				if (error.code === "create" && pool === this.#type) {
+					const refusal = this.#refusal;
+					this.#refusal = void 0;
+					throw refusal === void 0 ? error.cause : refusal.cause;
+				}
+				if (error.code === "create" || error.code === "cleanup") throw error.cause;
+			}
+			throw error;
 		}
-		return false;
 	}
-	async #admitType() {
-		const previous = this.#typeTail;
-		const turn = Promise.withResolvers();
-		this.#typeTail = turn.promise;
-		await previous;
-		return turn.resolve;
+	#createLint() {
+		for (const cause of this.#survivors.values()) throw new ProbeError("The Oxlint language server survived cleanup; restart the probe server", {
+			origin: "instrument",
+			code: "malformed",
+			context: { stage: "lint" },
+			cause
+		});
+		return this.#warm(new LintStage(this.#workspace));
 	}
-	async #resolve(claim) {
-		const release = await this.#admitType();
+	async #warm(stage) {
+		const bound = stage.stage === "type" ? this.#warmth : this.#deadline;
+		const aborted = Promise.withResolvers();
+		aborted.promise.catch(() => {});
+		const subscription = addAbortListener(this.#abort.signal, () => aborted.reject(createDestroyedError("probe")));
 		try {
-			const stage = this.#type;
+			if (this.#closing !== void 0) throw createDestroyedError("probe");
+			await this.#bound(() => Promise.race([stage.start(), aborted.promise]), `The ${stage.stage} stage warm exceeded ${bound} ms`, stage, stage.progress, bound);
+			return stage;
+		} catch (error) {
+			if (stage.stage === "type" && this.#closing === void 0) this.#refusal ??= { cause: error };
 			try {
-				return await this.#bound(() => stage.resolve(claim.project), `The type stage project resolution exceeded ${this.#deadline} ms`, stage, stage.progress);
-			} catch (error) {
-				this.#emitExpiry(stage, claim);
-				throw error;
+				await this.#dispose(stage);
+			} catch (failure) {
+				this.#survivors.set(stage, failure);
+				throw failure;
 			}
+			throw error;
 		} finally {
-			release();
+			subscription[Symbol.dispose]();
 		}
 	}
-	#emitExpiry(stage, claim) {
-		if (stage === this.#type || stage === this.#lint || stage === this.#runtime) return;
-		this.#emitter.emit("expire", claim);
+	async #dispose(stage) {
+		const bound = stage.stage === "lint" ? Math.max(this.#deadline, LINT_TEARDOWN) : this.#deadline;
+		try {
+			await this.#bound(() => stage.destroy(), `The ${stage.stage} stage teardown exceeded ${bound} ms`, stage, stage.progress, bound);
+		} catch (error) {
+			if (isProbeError(error) && this.#deadlines.has(error)) return;
+			if (this.#closing !== void 0 || stage.stage === "lint" && isProbeError(error) && isLSPError(error.cause) && error.cause.code === "timeout") throw error;
+			this.#surface(error);
+		}
+	}
+	#refuseArm(error) {
+		if (this.#closing !== void 0) return createDestroyedError("probe");
+		const cause = isPoolError(error) ? error.cause : error;
+		const failure = new ProbeError(`The probe could not arm: ${describeUnknown(cause)}`, {
+			origin: "instrument",
+			code: "malformed",
+			cause
+		});
+		this.#surface(failure);
+		return failure;
 	}
 	#expiry(timeout, message, stage, progress) {
 		return new Promise((_resolve, reject) => {
@@ -2845,7 +2960,7 @@ var Probe = class {
 					code: "deadline",
 					context: {
 						stage: stage.stage,
-						deadline: this.#deadline
+						deadline: timeout.ms
 					}
 				});
 				this.#deadlines.add(error);
@@ -2854,26 +2969,23 @@ var Probe = class {
 		});
 	}
 	async #destroy() {
+		this.#abort.abort();
+		const barriers = Promise.allSettled([
+			this.#type.destroy(),
+			this.#lint.destroy(),
+			this.#runtime.destroy()
+		]);
 		try {
-			try {
-				await this.#arming;
-			} catch {}
-			await Promise.all([
-				this.#destroyStage(this.#type),
-				this.#destroyStage(this.#lint),
-				this.#destroyStage(this.#runtime)
-			]);
+			await this.#starting?.catch(() => {});
+			await this.#arming?.catch(() => {});
+			const results = await barriers;
+			const survivors = await Promise.allSettled([...this.#survivors.keys()].map((stage) => this.#dispose(stage)));
+			this.#survivors.clear();
+			for (const result of [...results, ...survivors]) if (result.status === "rejected") throw isPoolError(result.reason) ? result.reason.cause : result.reason;
 		} finally {
 			this.#emitter.destroy();
 		}
 	}
-	async #destroyStage(stage) {
-		try {
-			await this.#bound(() => stage.destroy(), `The ${stage.stage} stage teardown exceeded ${this.#deadline} ms`, stage, stage.progress);
-		} catch (error) {
-			if (!isProbeError(error) || !this.#deadlines.has(error)) throw error;
-		}
-	}
 	#version(name) {
 		const version = readWorkspaceManifest(this.#workspace, name).contents.version;
 		if (!isString(version)) throw new ProbeError(`${name} publishes no readable version`, {
@@ -2918,12 +3030,13 @@ var Probe = class {
 /**
 * Implements `ProbeServerInterface` over a `PassThrough` stream this server owns, binding the
 * published `prove` tool and the dual-era dispatcher to this process's Model Context Protocol
-* stdio transport.
+* stdio transport. Starting creates the probe and awaits its lint and runtime onset; type warming
+* and the boot controls continue behind it.
 *
 * @remarks
 * Construction snapshots the probe options, publishes the `prove` tool, and binds the dual-era
-* dispatcher to the stdio transport. An admitted `prove` call creates the probe and begins
-* workspace arming, so discovery does not depend on the workspace toolchain. Construction is held
+* dispatcher to the stdio transport.
+* Discovery remains available while the legacy handshake awaits that onset. Construction is held
 * before it begins, so teardown entered through a construction callback waits for the resulting
 * probe and releases it. A constructor refusal clears that held operation for a later retry.
 *
@@ -2933,7 +3046,8 @@ var Probe = class {
 * serving is still attached and still fires afterwards. The transport reads a stream this server
 * owns rather than this process's standard input, which is what makes that possible: the
 * transport's own listeners land on that stream, and the only listeners this server ever puts on
-* `process.stdin` are the `data`, `close`, and `error` forwarders into it. `destroy` pauses the
+* `process.stdin` are the `data`, `close`, and `error` forwarders and the input-end teardown.
+* `destroy` pauses the
 * stream only when this server is what set it flowing and nothing else is reading it, so a process
 * that outlives this server reads its own standard input again and receives its own signals.
 * Teardown removes the signal handlers first: it takes seconds when a boot is in flight, and a
@@ -2942,7 +3056,7 @@ var Probe = class {
 * @example
 * ```ts
 * const server = new ProbeServer({ workspace: process.cwd() })
-* server.start()
+* await server.start()
 * await server.destroy()
 * ```
 */
@@ -2954,24 +3068,28 @@ var ProbeServer = class {
 	#close;
 	#error;
 	#signal;
+	#end;
+	#starting;
 	#server;
 	#owns;
 	#construction;
 	#closing;
 	/**
 	* Snapshots the probe options this server will use and binds the published schema to this
-	* process's stdio transport. An admitted `prove` call creates the probe.
+	* process's stdio transport without warming the workspace.
 	*
-	* @param options - Workspace, deadline, and initial observation hooks for the deferred probe
+	* @param options - Workspace, deadline, and initial observation hooks for the probe
 	*/
 	constructor(options) {
 		const workspace = options?.workspace;
 		const deadline = options?.deadline;
+		const warm = options?.warm;
 		const on = options?.on;
 		const error = options?.error;
 		this.#options = Object.freeze({
 			workspace: resolve(workspace ?? process.cwd()),
 			...deadline === void 0 ? {} : { deadline },
+			...warm === void 0 ? {} : { warm },
 			...on === void 0 ? {} : { on: Object.freeze({ ...on }) },
 			...error === void 0 ? {} : { error }
 		});
@@ -2982,22 +3100,52 @@ var ProbeServer = class {
 		this.#close = this.#finish.bind(this);
 		this.#error = this.#fail.bind(this);
 		this.#signal = this.#release.bind(this);
+		this.#end = this.#release.bind(this);
 	}
 	start() {
-		if (this.#closing !== void 0) throw createDestroyedError("probe server");
-		if (this.#owns !== void 0) return;
+		if (this.#closing !== void 0) return Promise.reject(createDestroyedError("probe server"));
+		this.#starting ??= this.#setup();
+		this.#starting.catch(() => {});
+		return this.#starting;
+	}
+	destroy() {
+		if (this.#closing !== void 0) return this.#closing;
+		this.#closing = this.#destroy();
+		return this.#closing;
+	}
+	async #setup() {
 		this.#owns = process.stdin.readableFlowing !== true;
 		this.#transport.start();
 		process.stdin.on("data", this.#data);
 		process.stdin.on("close", this.#close);
 		process.stdin.on("error", this.#error);
+		process.stdin.on("end", this.#end);
 		process.on("SIGINT", this.#signal);
 		process.on("SIGTERM", this.#signal);
+		try {
+			const probe = await this.#resolveProbe();
+			if (this.#closing !== void 0) return;
+			await probe.start();
+			if (this.#closing !== void 0) return;
+		} catch (error) {
+			if (this.#closing !== void 0) return;
+			throw error;
+		}
 	}
-	destroy() {
-		if (this.#closing !== void 0) return this.#closing;
-		this.#closing = this.#destroy();
-		return this.#closing;
+	async #handshake(options) {
+		options.signal.throwIfAborted();
+		const aborted = Promise.withResolvers();
+		const listener = addAbortListener(options.signal, () => aborted.reject(options.signal.reason));
+		try {
+			await Promise.race([this.#starting, aborted.promise]);
+			if (this.#closing !== void 0) throw createDestroyedError("probe server");
+		} catch (error) {
+			options.signal.throwIfAborted();
+			if (isProbeError(error)) throw createHandshakeError(error);
+			throw error;
+		} finally {
+			listener[Symbol.dispose]();
+		}
 	}
 	async #destroy() {
 		process.removeListener("SIGINT", this.#signal);
@@ -3006,13 +3154,17 @@ var ProbeServer = class {
 		process.stdin.removeListener("data", this.#data);
 		process.stdin.removeListener("close", this.#close);
 		process.stdin.removeListener("error", this.#error);
+		process.stdin.removeListener("end", this.#end);
 		if (this.#owns === true && process.stdin.listenerCount("data") === 0) process.stdin.pause();
 		this.#owns = void 0;
 		this.#stream.destroy();
 		const construction = this.#construction;
-		if (construction === void 0) return;
-		const probe = await construction.catch(() => void 0);
-		if (probe !== void 0) await probe.destroy();
+		try {
+			const probe = await construction?.catch(() => void 0);
+			if (probe !== void 0) await probe.destroy();
+		} finally {
+			await this.#starting?.catch(() => {});
+		}
 	}
 	#receive(chunk) {
 		this.#stream.write(chunk);
@@ -3046,7 +3198,8 @@ var ProbeServer = class {
 			},
 			tools,
 			limit: { keys: PROBE_KEYS },
-			execution: this.#execute.bind(this)
+			execution: this.#execute.bind(this),
+			handshake: this.#handshake.bind(this)
 		});
 	}
 	async #prove(input) {
@@ -3113,6 +3266,6 @@ var ProbeServer = class {
 	}
 };
 //#endregion
-export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, buildRevisionPath, captureListeners, collectWorkspaceFiles, computeDigest, describeUnknown, escapesRoot, filterUniqueIssues, findRefusedPaths, guardStage, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceVitest, matchesLiveProcess, matchesWorkspaceModule, normalizePath, normalizeValue, overwriteFile, parseProjectConfig, parseRevisionOwner, readFaultCode, readWorkspaceManifest, relativeWorkspaceFile, relativeWorkspaceMessage, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule, scanDiagnostics };
+export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, buildRevisionPath, captureListeners, collectWorkspaceFiles, computeDigest, createHandshakeError, describeUnknown, escapesRoot, filterUniqueIssues, findRefusedPaths, guardStage, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceVitest, matchesLiveProcess, matchesWorkspaceModule, normalizePath, normalizeValue, overwriteFile, parseProjectConfig, parseRevisionOwner, readFaultCode, readWorkspaceManifest, relativeWorkspaceFile, relativeWorkspaceMessage, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule, scanDiagnostics };
 
 //# sourceMappingURL=index.js.map