@orkestrel/probe 0.0.24 → 0.0.25

package/dist/src/server/index.cjs

@@ -14,6 +14,7 @@ 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_async_hooks = require("node:async_hooks");
 let node_child_process = require("node:child_process");
 let _orkestrel_mcp_server = require("@orkestrel/mcp/server");
 let _orkestrel_tool = require("@orkestrel/tool");
@@ -533,6 +534,8 @@ function readWorkspaceManifest(workspace, name) {
 * @remarks
 * A package publishes its binaries under keys of its own choosing, and that key is often not the
 * package name: `typescript` publishes `tsc`. Name the key as `command` wherever the two differ.
+* Resolution reads `package.json` and its `bin` field, so TypeScript 6 and 7 need no exported
+* `typescript/bin/tsc` subpath.
 * Default: the package name.
 *
 * @param workspace - The target workspace root
@@ -975,7 +978,7 @@ function captureListeners(emitter, events) {
 */
 function releaseListeners(emitter, capture) {
 	for (const [event, captured] of capture) for (const listener of emitter.listeners(event)) {
-		if (captured.includes(listener)) continue;
+		if (captured.includes(listener) || !(0, _orkestrel_contract.isFunction)(listener)) continue;
 		emitter.removeListener(event, listener);
 	}
 }
@@ -1124,10 +1127,10 @@ var Overlay = class {
 };
 //#endregion
 //#region package.json
-var version = "0.0.24";
+var version = "0.0.25";
 var peerDependencies = {
-	"typescript": "^6.0.3",
-	"vitest": "^4.1.12"
+	"typescript": "^6.0.3 || ^7.0.2",
+	"vitest": "^4.1.12 || ^5.0.5"
 };
 //#endregion
 //#region src/server/stages/LintStage.ts
@@ -1349,6 +1352,11 @@ var LintStage = class {
 * Inspects tests through one resident Vitest service from the target workspace.
 *
 * @remarks
+* Vitest 4.1.12 and 5.0.5 share the mode-first `createVitest` overload used by this stage.
+* Result eviction removes one file from Vitest 4's results cache. Vitest 5 exposes only a full
+* cache clear, so eviction clears its results, dependency, and filesystem module caches.
+* Warming removes termination handlers registered within the factory's async context before
+* signal delivery, while retaining handlers the host registers outside that context.
 * 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
@@ -1573,38 +1581,46 @@ var RuntimeStage = class {
 		this.#sweep();
 		const output = new node_stream.PassThrough();
 		output.resume();
+		const scope = new node_async_hooks.AsyncLocalStorage();
+		const listener = this.#captureSignal.bind(this, scope);
 		const signals = captureListeners(process, ["SIGINT", "SIGTERM"]);
-		let warming;
+		process.on("newListener", listener);
 		try {
-			warming = factory("test", {
-				root: this.#workspace,
-				config: resolveWorkspaceFile(this.#workspace, "vite.config.ts"),
-				watch: false,
-				run: true,
-				pool: "threads",
-				reporters: [{
-					onInit() {},
-					onTestRunEnd() {}
-				}]
-			}, { plugins: [{
-				name: "orkestrel-project-instrumentation",
-				enforce: "post",
-				config: this.#configure.bind(this)
-			}] }, {
-				stdout: output,
-				stderr: process.stderr
+			return await scope.run(true, () => {
+				try {
+					return factory("test", {
+						root: this.#workspace,
+						config: resolveWorkspaceFile(this.#workspace, "vite.config.ts"),
+						watch: false,
+						run: true,
+						pool: "threads",
+						reporters: [{
+							onInit() {},
+							onTestRunEnd() {}
+						}]
+					}, { plugins: [{
+						name: "orkestrel-project-instrumentation",
+						enforce: "post",
+						config: this.#configure.bind(this)
+					}] }, {
+						stdout: output,
+						stderr: process.stderr
+					});
+				} finally {
+					releaseListeners(process, signals);
+				}
 			});
 		} catch (error) {
 			throw this.#configuration(error);
 		} finally {
-			releaseListeners(process, signals);
-		}
-		try {
-			return await warming;
-		} catch (error) {
-			throw this.#configuration(error);
+			process.off("newListener", listener);
+			scope.disable();
 		}
 	}
+	#captureSignal(scope, event, listener) {
+		if (scope.getStore() !== true || event !== "SIGINT" && event !== "SIGTERM") return;
+		queueMicrotask(() => process.off(event, listener));
+	}
 	#configure(config) {
 		const test = config.test;
 		if (test?.projects === void 0) return;
@@ -1798,8 +1814,16 @@ var RuntimeStage = class {
 			}
 			vitest.watcher.onFileDelete(file);
 			vitest.watcher.invalidates.delete(file);
-			vitest.cache.results.removeFromCache(normalizePath((0, node_path.relative)(this.#workspace, file)));
-			await vitest.cache.results.writeToCache();
+			const results = "results" in vitest.cache ? vitest.cache.results : void 0;
+			if ((0, _orkestrel_contract.isObject)(results) && "removeFromCache" in results && typeof results.removeFromCache === "function" && "writeToCache" in results && typeof results.writeToCache === "function") {
+				results.removeFromCache(normalizePath((0, node_path.relative)(this.#workspace, file)));
+				await results.writeToCache();
+			} else if ("clearCache" in vitest && typeof vitest.clearCache === "function") await vitest.clearCache();
+			else throw new _src_core.ProbeError("Vitest exposes no cache eviction API", {
+				origin: "instrument",
+				code: "malformed",
+				context: { stage: this.stage }
+			});
 			return [];
 		} catch (error) {
 			return [{
@@ -2008,6 +2032,8 @@ var RuntimeStage = class {
 * Inspects TypeScript source by running the target workspace's own compiler over a mirror of it.
 *
 * @remarks
+* TypeScript 6 and 7 run through the `tsc` entry in their package manifest; neither a compiler API
+* nor an exported binary subpath is required.
 * 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. Starting sweeps a
 * mirror an earlier host left behind, copies the workspace into a fresh one under
@@ -2045,6 +2071,7 @@ var TypeStage = class {
 	#revision = `${process.pid}-${(0, node_crypto.randomUUID)()}`;
 	#mirror;
 	#configs = /* @__PURE__ */ new Map();
+	#validated = /* @__PURE__ */ new Set();
 	#mirrored = /* @__PURE__ */ new Map();
 	#drafts = /* @__PURE__ */ new Set();
 	#children = /* @__PURE__ */ new Set();
@@ -2098,6 +2125,8 @@ var TypeStage = class {
 	* refreshed from the workspace first on a cache miss, so the digest names the configuration the
 	* check applies. The reading is cached per project for the life of the stage, so a draft written
 	* afterward cannot move it.
+	* Before returning the identity, validates the project with `--noEmit` unless an unoverlaid check
+	* already validated it. TypeScript 7's `--showConfig` can succeed for a malformed project.
 	*
 	* @param project - The workspace-relative TypeScript project to resolve
 	* @returns The resolved workspace-relative path and the digest of its compiler options
@@ -2157,6 +2186,10 @@ var TypeStage = class {
 		const contained = this.#contain(project);
 		this.#progress += 1;
 		const config = await this.#configure(contained);
+		if (!this.#validated.has(contained)) {
+			this.#refresh();
+			await this.#check(contained, []);
+		}
 		return {
 			path: contained,
 			digest: computeDigest(this.#workspace, config.compilerOptions)
@@ -2176,6 +2209,7 @@ var TypeStage = class {
 			});
 		} catch {}
 		this.#configs.clear();
+		this.#validated.clear();
 		this.#mirrored.clear();
 		this.#drafts.clear();
 	}
@@ -2349,7 +2383,9 @@ var TypeStage = class {
 				}
 			});
 		}
-		return this.#issues(diagnostics, project);
+		const issues = this.#issues(diagnostics, project, scratch);
+		if (this.#drafts.size === 0) this.#validated.add(this.#contain(project));
+		return issues;
 	}
 	#scratch(project, config, drafts) {
 		const directory = (0, node_path.dirname)(project);
@@ -2374,13 +2410,13 @@ var TypeStage = class {
 		(0, node_fs.writeFileSync)(target, `${JSON.stringify(body, void 0, "	")}\n`, "utf8");
 		return contained;
 	}
-	#issues(diagnostics, project) {
+	#issues(diagnostics, project, scratch) {
 		const issues = [];
 		for (const diagnostic of diagnostics) {
 			const message = this.#translate(diagnostic.message);
 			const resolved = diagnostic.path === void 0 ? void 0 : (0, node_path.resolve)(this.#mirror, diagnostic.path);
 			const drafted = resolved !== void 0 && this.#drafts.has(escapesRoot(this.#mirror, resolved) ? relativeWorkspaceFile(this.#workspace, resolved) : relativeWorkspaceFile(this.#mirror, resolved));
-			if (resolved === void 0 || !drafted && (0, node_path.extname)(resolved) === ".json") throw new _src_core.ProbeError(message, {
+			if (resolved === void 0 || !drafted && (0, node_path.extname)(resolved) === ".json") throw new _src_core.ProbeError(message.replaceAll(normalizePath(scratch), normalizePath(project)), {
 				origin: "workspace",
 				code: "malformed",
 				context: {
@@ -2490,6 +2526,8 @@ var TypeStage = class {
 * Answers claims through its type, lint, and runtime stages.
 *
 * @remarks
+* The workspace peers are TypeScript `^6.0.3 || ^7.0.2` and Vitest `^4.1.12 || ^5.0.5`.
+* Starting refuses TypeScript majors outside 6 and 7 before a stage starts.
 * 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
@@ -2538,7 +2576,7 @@ 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.89.0:vitest@4.1.12:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+* verdict.receipt?.startsWith(`probe:${verdict.digest}:type:`) // true
 * await probe.destroy()
 * ```
 */
@@ -3014,9 +3052,9 @@ var Probe = class {
 	#support() {
 		const version = this.#toolchain.typescript;
 		const range = peerDependencies.typescript;
-		const supported = /^\^(\d+)\./u.exec(range)?.[1];
 		const found = /^(\d+)\./u.exec(version)?.[1];
-		if (supported === void 0 || found !== supported) throw new _src_core.ProbeError(`The supported TypeScript range is ${range}; found ${version}`, {
+		const supported = range.split(" || ").some((entry) => /^\^(\d+)\./u.exec(entry)?.[1] === found);
+		if (found === void 0 || !supported) throw new _src_core.ProbeError(`The supported TypeScript range is ${range}; found ${version}`, {
 			origin: "workspace",
 			code: "malformed",
 			context: {