@orkestrel/probe 0.0.20 → 0.0.22

package/dist/src/server/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _orkestrel_mcp = require("@orkestrel/mcp");
 let node_fs = require("node:fs");
 let node_crypto = require("node:crypto");
 let node_module = require("node:module");
@@ -7,15 +8,34 @@ let node_url = require("node:url");
 let _orkestrel_contract = require("@orkestrel/contract");
 let _src_core = require("../core/index.cjs");
 let _orkestrel_emitter = require("@orkestrel/emitter");
-let _orkestrel_queue = require("@orkestrel/queue");
-let _orkestrel_timeout = require("@orkestrel/timeout");
+let _orkestrel_pool = require("@orkestrel/pool");
 let _orkestrel_lsp = require("@orkestrel/lsp");
+let node_events = require("node:events");
+let _orkestrel_timeout = require("@orkestrel/timeout");
 let _orkestrel_lsp_server = require("@orkestrel/lsp/server");
 let node_stream = require("node:stream");
 let node_child_process = require("node:child_process");
-let _orkestrel_mcp = require("@orkestrel/mcp");
 let _orkestrel_mcp_server = require("@orkestrel/mcp/server");
 let _orkestrel_tool = require("@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 _orkestrel_mcp.MCPError(`[${error.origin}] ${error.code}: ${error.message}`, _orkestrel_mcp.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.
@@ -1104,7 +1124,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"
@@ -1115,7 +1135,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
@@ -1151,21 +1171,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";
@@ -1173,6 +1194,15 @@ var LintStage = class {
 	get progress() {
 		return this.#progress;
 	}
+	get exit() {
+		return this.#exited.promise;
+	}
+	start() {
+		if (this.#closing !== void 0) return Promise.reject((0, _src_core.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));
 	}
@@ -1189,8 +1219,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 (0, _src_core.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 {
@@ -1201,38 +1233,39 @@ var LintStage = class {
 	}
 	async #destroy() {
 		await this.#client?.destroy();
+		await this.#transport?.close();
 	}
 	async #warm() {
 		const binary = resolveWorkspaceBinary(this.#workspace, "oxlint");
+		const transport = (0, _orkestrel_lsp_server.createStdioClientTransport)({
+			server: {
+				command: [
+					process.execPath,
+					binary,
+					"--lsp"
+				],
+				directory: this.#workspace
+			},
+			grace: _src_core.LINT_DEADLINE / 2
+		});
+		this.#transport = transport;
 		const client = (0, _orkestrel_lsp.createLSPClient)({
-			transport: (0, _orkestrel_lsp_server.createStdioClientTransport)({
-				server: {
-					command: [
-						process.execPath,
-						binary,
-						"--lsp"
-					],
-					directory: this.#workspace
-				},
-				grace: _src_core.LINT_DEADLINE / 2
-			}),
+			transport,
 			workspace: (0, node_url.pathToFileURL)(this.#workspace).href,
 			timeout: _src_core.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 = (0, node_url.pathToFileURL)(resolveWorkspaceFile(this.#workspace, draft.path)).href;
@@ -1275,9 +1308,9 @@ var LintStage = class {
 		});
 	}
 	#translate(error, path) {
-		if (this.#closing !== void 0) return (0, _src_core.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 (0, _src_core.createDestroyedError)("lint stage");
 		if ((0, _orkestrel_contract.isError)(error)) return error;
 		return this.#fault(describeUnknown(error), error, path);
 	}
@@ -1316,7 +1349,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
@@ -1375,6 +1408,7 @@ var LintStage = class {
 var RuntimeStage = class {
 	#workspace;
 	#vitest;
+	#warming;
 	#overlay = new Overlay();
 	#loads = /* @__PURE__ */ new Set();
 	#reads = /* @__PURE__ */ new Set();
@@ -1384,16 +1418,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";
@@ -1402,6 +1432,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((0, _src_core.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
@@ -1432,6 +1476,7 @@ var RuntimeStage = class {
 	async #inspect(subject) {
 		if (this.#closing !== void 0) throw (0, _src_core.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 (0, _src_core.createDestroyedError)("runtime stage");
@@ -1964,7 +2009,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.
@@ -2007,16 +2052,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, `${_src_core.TYPE_MIRROR}/${this.#revision}`);
-		this.#warming = this.#warm();
-		this.#warming.catch(() => {});
+		this.#mirror = (0, node_path.resolve)(workspace, _src_core.TYPE_MIRROR, this.#revision);
 	}
 	get stage() {
 		return "type";
@@ -2024,6 +2066,12 @@ var TypeStage = class {
 	get progress() {
 		return this.#progress;
 	}
+	start() {
+		if (this.#closing !== void 0) return Promise.reject((0, _src_core.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.
 	*
@@ -2067,7 +2115,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) => ({
@@ -2103,6 +2151,8 @@ var TypeStage = class {
 		}
 	}
 	async #resolve(project) {
+		this.#refuseDestroyed();
+		await this.start();
 		this.#refuseDestroyed();
 		const contained = this.#contain(project);
 		this.#progress += 1;
@@ -2116,7 +2166,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 {
 			(0, node_fs.rmSync)(this.#mirror, {
 				recursive: true,
@@ -2130,6 +2180,7 @@ var TypeStage = class {
 		this.#drafts.clear();
 	}
 	async #warm() {
+		this.#compiler = resolveWorkspaceBinary(this.#workspace, "typescript", "tsc");
 		this.#sweep();
 		this.#createMirror();
 		this.#refresh();
@@ -2364,8 +2415,10 @@ var TypeStage = class {
 	}
 	#spawn(args, cwd) {
 		this.#refuseDestroyed();
+		const compiler = this.#compiler;
+		if (compiler === void 0) throw (0, _src_core.createDestroyedError)("type stage");
 		return new Promise((settle, refuse) => {
-			const child = (0, node_child_process.spawn)(process.execPath, [this.#compiler, ...args], {
+			const child = (0, node_child_process.spawn)(process.execPath, [compiler, ...args], {
 				cwd,
 				stdio: [
 					"ignore",
@@ -2402,7 +2455,7 @@ var TypeStage = class {
 					code: "malformed",
 					context: {
 						stage: this.stage,
-						path: this.#compiler
+						path: compiler
 					},
 					cause: error
 				}));
@@ -2437,9 +2490,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
@@ -2484,34 +2538,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 = (0, _orkestrel_timeout.createTimeout)({ ms: options?.deadline ?? _src_core.PROBE_DEADLINE }).ms;
+		this.#warmth = (0, _orkestrel_timeout.createTimeout)({ ms: options?.warm ?? _src_core.PROBE_WARM }).ms;
 		this.#emitter = new _orkestrel_emitter.Emitter({
 			...options?.on === void 0 ? {} : { on: options.on },
 			...options?.error === void 0 ? {} : { error: options.error }
@@ -2521,26 +2577,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 = (0, _orkestrel_queue.createQueue)({
-			concurrency: 1,
-			retries: 0,
-			handler: this.#inspectType.bind(this)
+		this.#type = (0, _orkestrel_pool.createPool)({
+			create: () => this.#warm(new TypeStage(this.#workspace)),
+			destroy: this.#dispose.bind(this),
+			error: this.#surface.bind(this),
+			min: 1,
+			restarts: _src_core.PROBE_RESTARTS
 		});
-		this.#lintQueue = (0, _orkestrel_queue.createQueue)({
-			concurrency: 1,
-			retries: 0,
-			handler: this.#inspectLint.bind(this)
+		this.#lint = (0, _orkestrel_pool.createPool)({
+			create: this.#createLint.bind(this),
+			destroy: this.#dispose.bind(this),
+			watch: (stage) => stage.exit,
+			error: this.#surface.bind(this),
+			min: 1,
+			restarts: _src_core.PROBE_RESTARTS
 		});
-		this.#runtimeQueue = (0, _orkestrel_queue.createQueue)({
-			concurrency: 1,
-			retries: 0,
-			handler: this.#inspectRuntime.bind(this)
+		this.#runtime = (0, _orkestrel_pool.createPool)({
+			create: () => this.#warm(new RuntimeStage(this.#workspace)),
+			destroy: this.#dispose.bind(this),
+			error: this.#surface.bind(this),
+			min: 1,
+			restarts: _src_core.PROBE_RESTARTS
 		});
-		this.#arming = this.#arm();
-		this.#arming.catch(() => {});
 	}
 	get emitter() {
 		return this.#emitter;
@@ -2552,7 +2610,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 (0, _src_core.createDestroyedError)("probe");
 			const started = performance.now();
 			const id = (0, node_crypto.randomUUID)();
@@ -2587,45 +2654,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((0, _src_core.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) {
-			if (this.#closing !== void 0) throw error;
+			this.#surface(error);
+			throw error;
+		}
+		try {
+			await filling;
+			if (this.#closing !== void 0) throw (0, _src_core.createDestroyedError)("probe");
+		} catch (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 (0, _src_core.createDestroyedError)("probe");
+			const cause = this.#refusal?.cause ?? ((0, _orkestrel_pool.isPoolError)(error) ? error.cause : error);
+			this.#surface(cause);
+			throw cause;
 		}
 		try {
+			if (this.#closing !== void 0) throw (0, _src_core.createDestroyedError)("probe");
 			await this.#boot(created);
 		} catch (error) {
-			const failure = new _src_core.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 ((0, _src_core.isProbeError)(error)) this.#surfaced.add(error);
 		this.#emitter.emit("error", error);
 	}
@@ -2741,102 +2828,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 ((0, _src_core.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 = (0, _orkestrel_timeout.createTimeout)({ ms: this.#deadline });
+	async #bound(operation, message, stage, progress, ms = this.#deadline) {
+		const timeout = (0, _orkestrel_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 = (0, _orkestrel_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 ((0, _orkestrel_pool.isPoolError)(error)) {
+				if (error.code === "destroyed") throw (0, _src_core.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 _src_core.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 = (0, node_events.addAbortListener)(this.#abort.signal, () => aborted.reject((0, _src_core.createDestroyedError)("probe")));
 		try {
-			const stage = this.#type;
+			if (this.#closing !== void 0) throw (0, _src_core.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, _src_core.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 ((0, _src_core.isProbeError)(error) && this.#deadlines.has(error)) return;
+			if (this.#closing !== void 0 || stage.stage === "lint" && (0, _src_core.isProbeError)(error) && (0, _orkestrel_lsp.isLSPError)(error.cause) && error.cause.code === "timeout") throw error;
+			this.#surface(error);
+		}
+	}
+	#refuseArm(error) {
+		if (this.#closing !== void 0) return (0, _src_core.createDestroyedError)("probe");
+		const cause = (0, _orkestrel_pool.isPoolError)(error) ? error.cause : error;
+		const failure = new _src_core.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) => {
@@ -2846,7 +2961,7 @@ var Probe = class {
 					code: "deadline",
 					context: {
 						stage: stage.stage,
-						deadline: this.#deadline
+						deadline: timeout.ms
 					}
 				});
 				this.#deadlines.add(error);
@@ -2855,26 +2970,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 (0, _orkestrel_pool.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 (!(0, _src_core.isProbeError)(error) || !this.#deadlines.has(error)) throw error;
-		}
-	}
 	#version(name) {
 		const version = readWorkspaceManifest(this.#workspace, name).contents.version;
 		if (!(0, _orkestrel_contract.isString)(version)) throw new _src_core.ProbeError(`${name} publishes no readable version`, {
@@ -2919,12 +3031,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.
 *
@@ -2934,7 +3047,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
@@ -2943,7 +3057,7 @@ var Probe = class {
 * @example
 * ```ts
 * const server = new ProbeServer({ workspace: process.cwd() })
-* server.start()
+* await server.start()
 * await server.destroy()
 * ```
 */
@@ -2955,24 +3069,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: (0, node_path.resolve)(workspace ?? process.cwd()),
 			...deadline === void 0 ? {} : { deadline },
+			...warm === void 0 ? {} : { warm },
 			...on === void 0 ? {} : { on: Object.freeze({ ...on }) },
 			...error === void 0 ? {} : { error }
 		});
@@ -2983,22 +3101,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 (0, _src_core.createDestroyedError)("probe server");
-		if (this.#owns !== void 0) return;
+		if (this.#closing !== void 0) return Promise.reject((0, _src_core.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 = (0, node_events.addAbortListener)(options.signal, () => aborted.reject(options.signal.reason));
+		try {
+			await Promise.race([this.#starting, aborted.promise]);
+			if (this.#closing !== void 0) throw (0, _src_core.createDestroyedError)("probe server");
+		} catch (error) {
+			options.signal.throwIfAborted();
+			if ((0, _src_core.isProbeError)(error)) throw createHandshakeError(error);
+			throw error;
+		} finally {
+			listener[Symbol.dispose]();
+		}
 	}
 	async #destroy() {
 		process.removeListener("SIGINT", this.#signal);
@@ -3007,13 +3155,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);
@@ -3047,7 +3199,8 @@ var ProbeServer = class {
 			},
 			tools,
 			limit: { keys: _src_core.PROBE_KEYS },
-			execution: this.#execute.bind(this)
+			execution: this.#execute.bind(this),
+			handshake: this.#handshake.bind(this)
 		});
 	}
 	async #prove(input) {
@@ -3124,6 +3277,7 @@ exports.buildRevisionPath = buildRevisionPath;
 exports.captureListeners = captureListeners;
 exports.collectWorkspaceFiles = collectWorkspaceFiles;
 exports.computeDigest = computeDigest;
+exports.createHandshakeError = createHandshakeError;
 exports.describeUnknown = describeUnknown;
 exports.escapesRoot = escapesRoot;
 exports.filterUniqueIssues = filterUniqueIssues;