@orkestrel/probe 0.0.13 → 0.0.15

package/dist/src/server/index.d.cts

@@ -871,7 +871,7 @@ export declare function parseRevisionOwner(revision: string): number | undefined
  * const probe = new Probe({ workspace: process.cwd() })
  * const verdict = await probe.prove(claim)
  * verdict.digest // 'fcb88a2dee987b8673c1fc7107979470'
- * verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.82.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+ * verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.83.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
  * await probe.destroy()
  * ```
  */
@@ -895,9 +895,11 @@ export declare class Probe implements ProbeInterface {
  * stdio transport.
  *
  * @remarks
- * Construction creates the probe, publishes the `prove` tool, and binds the dual-era dispatcher to
- * the stdio transport. The probe begins warming there, so a harness that spawns the entry pays
- * arming while its client is still handshaking.
+ * 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
+ * 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.
  *
  * `start` seizes standard input and registers the signals a harness ends a child with, and records
  * whether standard input was already flowing. Every listener it attaches is held as a field, and
@@ -921,9 +923,10 @@ export declare class Probe implements ProbeInterface {
 export declare class ProbeServer implements ProbeServerInterface {
     #private;
     /**
-     * Creates the probe this server publishes and binds it to this process's stdio transport.
+     * 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.
      *
-     * @param options - Workspace, deadline, and initial observation hooks for the probe it creates
+     * @param options - Workspace, deadline, and initial observation hooks for the deferred probe
      */
     constructor(options?: ProbeOptions);
     start(): void;
@@ -934,11 +937,17 @@ export declare class ProbeServer implements ProbeServerInterface {
  * Serves one probe over this process's Model Context Protocol stdio transport.
  *
  * @remarks
+ * Construction snapshots the options and resolves the workspace against the current working
+ * directory without loading its toolchain. Discovery can therefore answer before an admitted
+ * `prove` call creates the real probe and starts arming. Invalid claims do not create it.
+ *
  * The server owns the process it runs in. `start` seizes standard input and standard output for
  * the transport and registers the termination handlers a harness signals, so a host that starts one
  * has already given the process to it. `destroy` reverses all of that and tears the probe down with
- * it, which is why there is no verb that stops serving and leaves the stages standing: a probe
- * nothing is reading from holds its tools and its mirror for nobody.
+ * it when an admitted call created it. When teardown begins during admitted construction, it waits
+ * for that construction and releases the resulting probe before it settles. Destruction before
+ * admission loads no workspace tools, which is why there is no verb that stops serving and leaves
+ * the stages standing: a probe nothing is reading from holds its tools and its mirror for nobody.
  *
  * @example
  * ```ts
@@ -971,14 +980,15 @@ export declare interface ProbeServerInterface {
      *
      * @remarks
      * Settling is idempotent: a call made while teardown is running joins it and returns the same
-     * promise, and a call made afterwards returns that settled promise. The server removes exactly the
-     * listeners it attached, holding each one as a field rather than choosing by absence from a
-     * capture, so a host that keeps running after this call reads its own standard input again and
-     * receives its own signals, and a listener the host registered while
-     * the server was serving is still attached and still fires. That covers the stream's flow as
-     * well as its listeners: standard input is left flowing when it was already flowing before
-     * `start` and when something else is reading it at release, and a stream nothing had read yet
-     * and nothing else reads is paused.
+     * promise, and a call made afterwards returns that settled promise. An admitted probe construction
+     * is part of teardown ownership even when a callback begins teardown before that construction
+     * returns. The server removes exactly the listeners it attached, holding each one as a field
+     * instead of choosing by absence from a capture. A host that keeps running after this call reads
+     * its own standard input again and receives its own signals, and a listener the host registered
+     * while the server was serving is still attached and still fires. That covers the stream's flow
+     * as well as its listeners: standard input is left flowing when it was already flowing before
+     * `start` and when something else is reading it at release, and a stream nothing had read yet and
+     * nothing else reads is paused.
      *
      * @returns A promise that settles after the probe releases every stage's tool and mirror
      */
@@ -1273,6 +1283,9 @@ export declare class RuntimeStage implements StageInterface {
     /**
      * 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.
+     *
      * @param workspace - The target workspace root. Default: the current working directory
      */
     constructor(workspace?: string);

package/dist/src/server/index.d.ts

@@ -871,7 +871,7 @@ export declare function parseRevisionOwner(revision: string): number | undefined
  * const probe = new Probe({ workspace: process.cwd() })
  * const verdict = await probe.prove(claim)
  * verdict.digest // 'fcb88a2dee987b8673c1fc7107979470'
- * verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.82.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+ * verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.83.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
  * await probe.destroy()
  * ```
  */
@@ -895,9 +895,11 @@ export declare class Probe implements ProbeInterface {
  * stdio transport.
  *
  * @remarks
- * Construction creates the probe, publishes the `prove` tool, and binds the dual-era dispatcher to
- * the stdio transport. The probe begins warming there, so a harness that spawns the entry pays
- * arming while its client is still handshaking.
+ * 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
+ * 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.
  *
  * `start` seizes standard input and registers the signals a harness ends a child with, and records
  * whether standard input was already flowing. Every listener it attaches is held as a field, and
@@ -921,9 +923,10 @@ export declare class Probe implements ProbeInterface {
 export declare class ProbeServer implements ProbeServerInterface {
     #private;
     /**
-     * Creates the probe this server publishes and binds it to this process's stdio transport.
+     * 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.
      *
-     * @param options - Workspace, deadline, and initial observation hooks for the probe it creates
+     * @param options - Workspace, deadline, and initial observation hooks for the deferred probe
      */
     constructor(options?: ProbeOptions);
     start(): void;
@@ -934,11 +937,17 @@ export declare class ProbeServer implements ProbeServerInterface {
  * Serves one probe over this process's Model Context Protocol stdio transport.
  *
  * @remarks
+ * Construction snapshots the options and resolves the workspace against the current working
+ * directory without loading its toolchain. Discovery can therefore answer before an admitted
+ * `prove` call creates the real probe and starts arming. Invalid claims do not create it.
+ *
  * The server owns the process it runs in. `start` seizes standard input and standard output for
  * the transport and registers the termination handlers a harness signals, so a host that starts one
  * has already given the process to it. `destroy` reverses all of that and tears the probe down with
- * it, which is why there is no verb that stops serving and leaves the stages standing: a probe
- * nothing is reading from holds its tools and its mirror for nobody.
+ * it when an admitted call created it. When teardown begins during admitted construction, it waits
+ * for that construction and releases the resulting probe before it settles. Destruction before
+ * admission loads no workspace tools, which is why there is no verb that stops serving and leaves
+ * the stages standing: a probe nothing is reading from holds its tools and its mirror for nobody.
  *
  * @example
  * ```ts
@@ -971,14 +980,15 @@ export declare interface ProbeServerInterface {
      *
      * @remarks
      * Settling is idempotent: a call made while teardown is running joins it and returns the same
-     * promise, and a call made afterwards returns that settled promise. The server removes exactly the
-     * listeners it attached, holding each one as a field rather than choosing by absence from a
-     * capture, so a host that keeps running after this call reads its own standard input again and
-     * receives its own signals, and a listener the host registered while
-     * the server was serving is still attached and still fires. That covers the stream's flow as
-     * well as its listeners: standard input is left flowing when it was already flowing before
-     * `start` and when something else is reading it at release, and a stream nothing had read yet
-     * and nothing else reads is paused.
+     * promise, and a call made afterwards returns that settled promise. An admitted probe construction
+     * is part of teardown ownership even when a callback begins teardown before that construction
+     * returns. The server removes exactly the listeners it attached, holding each one as a field
+     * instead of choosing by absence from a capture. A host that keeps running after this call reads
+     * its own standard input again and receives its own signals, and a listener the host registered
+     * while the server was serving is still attached and still fires. That covers the stream's flow
+     * as well as its listeners: standard input is left flowing when it was already flowing before
+     * `start` and when something else is reading it at release, and a stream nothing had read yet and
+     * nothing else reads is paused.
      *
      * @returns A promise that settles after the probe releases every stage's tool and mirror
      */
@@ -1273,6 +1283,9 @@ export declare class RuntimeStage implements StageInterface {
     /**
      * 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.
+     *
      * @param workspace - The target workspace root. Default: the current working directory
      */
     constructor(workspace?: string);

package/dist/src/server/index.js

@@ -1103,7 +1103,7 @@ var Overlay = class {
 };
 //#endregion
 //#region package.json
-var version = "0.0.13";
+var version = "0.0.15";
 var peerDependencies = {
 	"oxlint": "^1.82.0",
 	"typescript": "^6.0.3",
@@ -1386,12 +1386,14 @@ var RuntimeStage = class {
 	/**
 	* 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.
+	*
 	* @param workspace - The target workspace root. Default: the current working directory
 	*/
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
-		const vitest = loadWorkspaceVitest(this.#workspace);
-		this.#store(this.#warm(vitest.createVitest));
+		this.#store(this.#warm());
 	}
 	get stage() {
 		return "runtime";
@@ -1522,13 +1524,14 @@ var RuntimeStage = class {
 		}
 	}
 	async #warm(create) {
+		const factory = create ?? loadWorkspaceVitest(this.#workspace).createVitest;
 		this.#sweep();
 		const output = new PassThrough();
 		output.resume();
 		const signals = captureListeners(process, ["SIGINT", "SIGTERM"]);
 		let warming;
 		try {
-			warming = create("test", {
+			warming = factory("test", {
 				root: this.#workspace,
 				config: resolveWorkspaceFile(this.#workspace, "vite.config.ts"),
 				watch: false,
@@ -2481,7 +2484,7 @@ var TypeStage = class {
 * const probe = new Probe({ workspace: process.cwd() })
 * const verdict = await probe.prove(claim)
 * verdict.digest // 'fcb88a2dee987b8673c1fc7107979470'
-* verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.82.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+* verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.83.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
 * await probe.destroy()
 * ```
 */
@@ -2919,9 +2922,11 @@ var Probe = class {
 * stdio transport.
 *
 * @remarks
-* Construction creates the probe, publishes the `prove` tool, and binds the dual-era dispatcher to
-* the stdio transport. The probe begins warming there, so a harness that spawns the entry pays
-* arming while its client is still handshaking.
+* 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
+* 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.
 *
 * `start` seizes standard input and registers the signals a harness ends a child with, and records
 * whether standard input was already flowing. Every listener it attaches is held as a field, and
@@ -2943,7 +2948,7 @@ var Probe = class {
 * ```
 */
 var ProbeServer = class {
-	#probe;
+	#options;
 	#stream;
 	#transport;
 	#data;
@@ -2952,14 +2957,25 @@ var ProbeServer = class {
 	#signal;
 	#server;
 	#owns;
+	#construction;
 	#closing;
 	/**
-	* Creates the probe this server publishes and binds it to this process's stdio transport.
+	* 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.
 	*
-	* @param options - Workspace, deadline, and initial observation hooks for the probe it creates
+	* @param options - Workspace, deadline, and initial observation hooks for the deferred probe
 	*/
 	constructor(options) {
-		this.#probe = new Probe(options);
+		const workspace = options?.workspace;
+		const deadline = options?.deadline;
+		const on = options?.on;
+		const error = options?.error;
+		this.#options = Object.freeze({
+			workspace: resolve(workspace ?? process.cwd()),
+			...deadline === void 0 ? {} : { deadline },
+			...on === void 0 ? {} : { on: Object.freeze({ ...on }) },
+			...error === void 0 ? {} : { error }
+		});
 		this.#stream = new PassThrough();
 		this.#server = this.#publish();
 		this.#transport = createStdioServer(createMCPLegacy(this.#server), { input: this.#stream });
@@ -2994,7 +3010,10 @@ var ProbeServer = class {
 		if (this.#owns === true && process.stdin.listenerCount("data") === 0) process.stdin.pause();
 		this.#owns = void 0;
 		this.#stream.destroy();
-		await this.#probe.destroy();
+		const construction = this.#construction;
+		if (construction === void 0) return;
+		const probe = await construction.catch(() => void 0);
+		if (probe !== void 0) await probe.destroy();
 	}
 	#receive(chunk) {
 		this.#stream.write(chunk);
@@ -3040,7 +3059,20 @@ var ProbeServer = class {
 				context: { value: input }
 			});
 		}
-		return this.#probe.prove(input);
+		return (await this.#resolveProbe()).prove(input);
+	}
+	async #resolveProbe() {
+		if (this.#closing !== void 0) throw createDestroyedError("probe server");
+		const current = this.#construction;
+		if (current !== void 0) return await current;
+		const construction = Promise.resolve().then(() => new Probe(this.#options));
+		this.#construction = construction;
+		try {
+			return await construction;
+		} catch (error) {
+			if (this.#construction === construction) this.#construction = void 0;
+			throw error;
+		}
 	}
 	async #execute(context) {
 		const result = await context.tools.execute(context.call);