@acid-cat/cli 0.3.1 → 0.4.0

package/README.md

@@ -6,7 +6,7 @@ The AcidCat command line. npm package: `@acid-cat/cli`. It gives the `acid-cat`
 acid-cat check [--strict] <catalog.json ...>  # check catalogs
 acid-cat format [--write] <catalog.json ...>  # write catalogs in canonical form
 acid-cat view <catalog.json> <target>         # write the view of one target
-acid-cat conform --mcp <url> --http <url> --cli "<command>" --webmcp <url>  # test an implementation
+acid-cat conform --mcp <url> --http <url> --cli "<command>" --webmcp <url> [--deadline <ms>]  # test an implementation
 ```
 
 Install it as a development dependency, and run it with `pnpm exec acid-cat …`:
@@ -35,10 +35,12 @@ The exit code is 0 if there are no errors. It is 1 if there are errors. With `--
 `conform` tests a running implementation of the [conformance fixture](conformance/fixture.pkl) through its bindings (see [Conformance](../../spec/conformance.md#acid-cat-conform)):
 
 - **MCP:** the official MCP client, with revision `2026-07-28`, for tools and outcomes; raw requests for rejections.
-- **HTTP** and **CLI:** each outcome, each kind of call failure, availability, and rejections. For the CLI, an interrupt (`SIGINT`) during a call gives exit code 130.
+- **HTTP** and **CLI:** each outcome, each kind of call failure, availability, and rejections. For the CLI, an interrupt (`SIGINT`) during a call that holds gives exit code 130.
 - **WebMCP:** the checks act as the WebMCP host. `--webmcp <url>` opens a page that serves the `app` target in Chromium, through [Playwright](https://playwright.dev), with a test `modelContext`. Install Playwright to use it: `pnpm add -D playwright`, then `pnpm exec playwright install chromium`. In code, `webmcp` can also be a function that installs the implementation on a host in the same process.
 - **Properties:** with fast-check, through each remote binding: concurrent calls each get exactly their own outcome, and a cancellation changes only its own call.
 
+The checks wait for states that they can observe, not for times. Before a check cancels a call to `fixture.hold`, it waits until `fixture.held` gives the key of the call, or, for the CLI, until the marker file of the call exists. Each check has one deadline: `--deadline`, or `deadline` in code, in milliseconds. The default is 30 000. A check that does not settle before its deadline fails with "did not settle", and the check stops what it started. This cleanup has a deadline of the same length, so `conform` always returns. The deadline never makes a check pass.
+
 The exit code is 1 if a check fails. Both AcidCat cores run `conform` in their tests. In code, use `conform()` and `serve()` from `@acid-cat/cli`. `createTestHost()` gives the WebMCP host of the checks.
 
 ## Implementation

package/conformance/fixture.acidcat.json

@@ -133,12 +133,70 @@
         "type": "object"
       }
     },
+    "fixture.held": {
+      "description": "Return the keys of the calls to fixture.hold that hold now.",
+      "audience": [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      "output": {
+        "properties": {
+          "keys": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "keys"
+        ],
+        "type": "object"
+      },
+      "readOnly": true
+    },
     "fixture.hidden": {
       "description": "Only the app target can use this capability.",
       "audience": [
         "app"
       ]
     },
+    "fixture.hold": {
+      "description": "Hold until fixture.release releases the key, then return the key. While the call holds, fixture.held gives the key. With a marker, the call writes a file at that path when it starts to hold.",
+      "audience": [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      "input": {
+        "properties": {
+          "key": {
+            "type": "string"
+          },
+          "marker": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "key"
+        ],
+        "type": "object"
+      },
+      "output": {
+        "properties": {
+          "key": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "key"
+        ],
+        "type": "object"
+      }
+    },
     "fixture.refuse": {
       "description": "Always return the failure Refused.",
       "audience": [
@@ -166,8 +224,8 @@
         }
       }
     },
-    "fixture.slow": {
-      "description": "Wait for some milliseconds, then return null.",
+    "fixture.release": {
+      "description": "Release the calls to fixture.hold that hold the key.",
       "audience": [
         "app",
         "mcp",
@@ -176,12 +234,12 @@
       ],
       "input": {
         "properties": {
-          "milliseconds": {
-            "type": "number"
+          "key": {
+            "type": "string"
           }
         },
         "required": [
-          "milliseconds"
+          "key"
         ],
         "type": "object"
       }

package/dist/conform/check.d.ts

@@ -11,13 +11,28 @@ export interface Check {
 export declare const fixture: CatalogDocument;
 /** The ids of the capabilities in the view of a target of the fixture. */
 export declare const idsOf: (target: string) => string[];
-/** Collects checks for one binding. */
+/** The time, in milliseconds, that each check has to settle when `conform` gets no other time. */
+export declare const DEADLINE = 30000;
+/**
+ * Collects checks for one binding. Each check has one deadline. The check gives its signal to each operation, and the
+ * signal aborts at the deadline. Then each operation stops, and the check fails with "did not settle". The deadline
+ * never makes a check pass. The cleanup of a check, which releases what the check holds, gets its own signal with the
+ * same time, so that `conform` always returns.
+ */
 export declare class Checks {
     readonly results: Check[];
     readonly binding: string;
-    constructor(binding: string);
-    run(name: string, rule: string, body: () => Promise<void> | void): Promise<void>;
+    readonly deadline: number;
+    constructor(binding: string, deadline: number);
+    run(name: string, rule: string, body: (signal: AbortSignal) => Promise<void> | void): Promise<void>;
 }
+/**
+ * Read a state until `done` is true for it, and give that value. The read and the pause between two reads stop when the
+ * signal of the check aborts.
+ */
+export declare function until<T>(what: string, read: () => Promise<T>, done: (value: T) => boolean, signal: AbortSignal): Promise<T>;
+/** Settle as the promise does, or reject with the reason of the signal when it aborts first. */
+export declare function abortable<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
 /** Fail a check unless `condition` is true. */
 export declare function expect(condition: unknown, message: string): asserts condition;
 /** Fail a check unless the two values have the same JSON. */

package/dist/conform/check.js

@@ -1,21 +1,33 @@
 import fixture_acidcat_default from "../json/fixture.acidcat.json.js";
 import { viewOf } from "@acid-cat/spec-ts";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region src/conform/check.ts
 /** The result of one conformance check, and helpers to write checks. */
 /** The conformance fixture: the catalog that each implementation serves. */
 const fixture = fixture_acidcat_default;
 /** The ids of the capabilities in the view of a target of the fixture. */
 const idsOf = (target) => Object.keys(viewOf(fixture, target).capabilities).sort();
-/** Collects checks for one binding. */
+/** The time, in milliseconds, that each check has to settle when `conform` gets no other time. */
+const DEADLINE = 3e4;
+/**
+* Collects checks for one binding. Each check has one deadline. The check gives its signal to each operation, and the
+* signal aborts at the deadline. Then each operation stops, and the check fails with "did not settle". The deadline
+* never makes a check pass. The cleanup of a check, which releases what the check holds, gets its own signal with the
+* same time, so that `conform` always returns.
+*/
 var Checks = class {
 	results = [];
 	binding;
-	constructor(binding) {
+	deadline;
+	constructor(binding, deadline) {
 		this.binding = binding;
+		this.deadline = deadline;
 	}
 	async run(name, rule, body) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.deadline);
 		try {
-			await body();
+			await body(controller.signal);
 			this.results.push({
 				binding: this.binding,
 				name,
@@ -23,16 +35,44 @@ var Checks = class {
 				passed: true
 			});
 		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const detail = controller.signal.aborted ? `did not settle within ${this.deadline} ms: ${message}` : message;
 			this.results.push({
 				binding: this.binding,
 				name,
 				rule,
 				passed: false,
-				detail: error instanceof Error ? error.message : String(error)
+				detail
 			});
+		} finally {
+			clearTimeout(timer);
 		}
 	}
 };
+/**
+* Read a state until `done` is true for it, and give that value. The read and the pause between two reads stop when the
+* signal of the check aborts.
+*/
+async function until(what, read, done, signal) {
+	let last;
+	try {
+		for (;;) {
+			last = await read();
+			if (done(last)) return last;
+			await setTimeout$1(10, void 0, { signal });
+		}
+	} catch (error) {
+		throw signal.aborted ? /* @__PURE__ */ new Error(`waiting until ${what}; the last value was ${JSON.stringify(last)}`) : error;
+	}
+}
+/** Settle as the promise does, or reject with the reason of the signal when it aborts first. */
+function abortable(promise, signal) {
+	const aborted = new Promise((_, reject) => {
+		signal.throwIfAborted();
+		signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+	});
+	return Promise.race([promise, aborted]);
+}
 /** Fail a check unless `condition` is true. */
 function expect(condition, message) {
 	if (!condition) throw new Error(message);
@@ -48,4 +88,4 @@ const sorted = (values) => [...values].sort();
 /** An origin that no deployment allows. */
 const FORBIDDEN_ORIGIN = "https://not-allowed.acid-cat.invalid";
 //#endregion
-export { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, fixture, idsOf, sorted };
+export { Checks, DEADLINE, FORBIDDEN_ORIGIN, abortable, expect, expectEqual, fixture, idsOf, sorted, until };

package/dist/conform/cli.d.ts

@@ -1,2 +1,4 @@
 import { Checks } from "./check.js";
-export declare function checkCli(command: readonly string[]): Promise<Checks>;
+export declare function checkCli(command: readonly string[], options: {
+    readonly deadline: number;
+}): Promise<Checks>;

package/dist/conform/cli.js

@@ -1,5 +1,9 @@
-import { Checks, expect, expectEqual, idsOf, sorted } from "./check.js";
+import { Checks, expect, expectEqual, idsOf, sorted, until } from "./check.js";
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 //#region src/conform/cli.ts
 /** Conformance checks for the CLI binding (spec/bindings/cli.md). Each check runs the command line as a process. */
 const RULE = "spec/bindings/cli.md";
@@ -8,53 +12,62 @@ const USAGES = {
 	"fixture.crash": "fixture crash",
 	"fixture.echo": "fixture echo --text <string>",
 	"fixture.flags": "fixture flags --mode <fast|slow> [--count <integer>] [--extra <json>] [--label <string>] [--ratio <number>] [--verbose]",
+	"fixture.held": "fixture held",
+	"fixture.hold": "fixture hold --key <string> [--marker <string>]",
 	"fixture.refuse": "fixture refuse",
-	"fixture.slow": "fixture slow --milliseconds <number>",
+	"fixture.release": "fixture release --key <string>",
 	"fixture.switch.set": "fixture switch set --on",
 	"fixture.toggle": "fixture toggle"
 };
-/** The time that a command line has to start before the interrupt, in milliseconds. */
-const INTERRUPT_AFTER = 2e3;
-/** Run the command line. If `interruptAfter` is given, send `SIGINT` after that many milliseconds. */
-function run(command, args, interruptAfter) {
-	return new Promise((resolve, reject) => {
-		const child = spawn(command[0], [...command.slice(1), ...args], { stdio: [
+/**
+* Start the command line. When the signal aborts, the process is killed, and its run rejects. The rejection is observed
+* here too, so that a check that stops waiting first, for example at the deadline, records a failure and does not end
+* the process with an unhandled rejection.
+*/
+function start(command, args, signal) {
+	const child = spawn(command[0], [...command.slice(1), ...args], {
+		stdio: [
 			"ignore",
 			"pipe",
 			"pipe"
-		] });
-		const timer = interruptAfter === void 0 ? void 0 : setTimeout(() => child.kill("SIGINT"), interruptAfter);
+		],
+		signal,
+		killSignal: "SIGKILL"
+	});
+	const run = new Promise((resolve, reject) => {
 		let stdout = "";
 		let stderr = "";
 		child.stdout.on("data", (chunk) => stdout += chunk.toString());
 		child.stderr.on("data", (chunk) => stderr += chunk.toString());
-		child.on("error", reject);
-		child.on("close", (code, signal) => {
-			clearTimeout(timer);
-			resolve({
-				code,
-				signal,
-				stdout,
-				stderr
-			});
-		});
+		child.on("error", (error) => reject(signal.aborted ? /* @__PURE__ */ new Error(`waiting until the command line exits: ${args.join(" ")}`) : error));
+		child.on("close", (code, exitSignal) => resolve({
+			code,
+			signal: exitSignal,
+			stdout,
+			stderr
+		}));
 	});
+	run.catch(() => void 0);
+	return {
+		child,
+		run
+	};
 }
-async function checkCli(command) {
-	const checks = new Checks("cli");
-	const cli = (...args) => run(command, args);
-	await checks.run("a value goes to standard output with exit code 0", `${RULE}#outcomes`, async () => {
-		const result = await cli("fixture", "echo", "--text", "hello");
+async function checkCli(command, options) {
+	const checks = new Checks("cli", options.deadline);
+	const run = (signal, ...args) => start(command, args, signal).run;
+	await checks.run("a value goes to standard output with exit code 0", `${RULE}#outcomes`, async (signal) => {
+		const result = await run(signal, "fixture", "echo", "--text", "hello");
 		expectEqual(result.code, 0, "exit code");
 		expectEqual(JSON.parse(result.stdout), { text: "hello" }, "standard output");
 	});
-	await checks.run("a failure goes to standard output with exit code 1", `${RULE}#outcomes`, async () => {
-		const result = await cli("fixture", "refuse");
+	await checks.run("a failure goes to standard output with exit code 1", `${RULE}#outcomes`, async (signal) => {
+		const result = await run(signal, "fixture", "refuse");
 		expectEqual(result.code, 1, "exit code");
 		expectEqual(JSON.parse(result.stdout)._tag, "Refused", "_tag");
 	});
-	await checks.run("a defect goes to standard error with exit code 5", `${RULE}#outcomes`, async () => {
-		const result = await cli("fixture", "crash");
+	await checks.run("a defect goes to standard error with exit code 5", `${RULE}#outcomes`, async (signal) => {
+		const result = await run(signal, "fixture", "crash");
 		expectEqual(result.code, 5, "exit code");
 		expect(/"kind":"internal"/.test(result.stderr), "standard error must contain the call failure");
 	});
@@ -78,8 +91,10 @@ async function checkCli(command) {
 			"a flag that is not valid has exit code 3",
 			[
 				"fixture",
-				"slow",
-				"--milliseconds",
+				"flags",
+				"--mode",
+				"fast",
+				"--ratio",
 				"soon"
 			],
 			3
@@ -93,31 +108,47 @@ async function checkCli(command) {
 			],
 			3
 		]
-	]) await checks.run(name, `${RULE}#outcomes`, async () => {
-		expectEqual((await cli(...args)).code, code, "exit code");
+	]) await checks.run(name, `${RULE}#outcomes`, async (signal) => {
+		expectEqual((await run(signal, ...args)).code, code, "exit code");
 	});
-	await checks.run("an interrupt cancels the call with exit code 130", `${RULE}#commands`, async () => {
-		const result = await run(command, [
-			"fixture",
-			"slow",
-			"--milliseconds",
-			"60000"
-		], INTERRUPT_AFTER);
-		expect(result.signal === null, `the process must exit, not end by the signal ${result.signal}`);
-		expectEqual(result.code, 130, "exit code");
-		expectEqual(result.stdout, "", "standard output");
+	await checks.run("an interrupt cancels the call with exit code 130", `${RULE}#commands`, async (signal) => {
+		const directory = await mkdtemp(join(tmpdir(), "acid-cat-conform-"));
+		const marker = join(directory, "held");
+		try {
+			const { child, run } = start(command, [
+				"fixture",
+				"hold",
+				"--key",
+				"interrupt",
+				"--marker",
+				marker
+			], signal);
+			const ended = () => child.exitCode !== null || child.signalCode !== null;
+			await until("the call writes its marker file", async () => existsSync(marker) || ended(), (ready) => ready, signal);
+			if (!ended()) child.kill("SIGINT");
+			const result = await run;
+			expect(existsSync(marker), `the call must hold before the interrupt, but the command line ended with ${result.code}: ${result.stderr}`);
+			expect(result.signal === null, `the process must exit, not end by the signal ${result.signal}`);
+			expectEqual(result.code, 130, "exit code");
+			expectEqual(result.stdout, "", "standard output");
+		} finally {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			});
+		}
 	});
-	await checks.run("call gives the value of a capability", `${RULE}#commands`, async () => {
-		const result = await cli("call", "fixture.echo", "{\"text\":\"hello\"}");
+	await checks.run("call gives the value of a capability", `${RULE}#commands`, async (signal) => {
+		const result = await run(signal, "call", "fixture.echo", "{\"text\":\"hello\"}");
 		expectEqual(result.code, 0, "exit code");
 		expectEqual(JSON.parse(result.stdout), { text: "hello" }, "standard output");
 	});
-	await checks.run("list gives the view", `${RULE}#commands`, async () => {
-		const result = await cli("list");
+	await checks.run("list gives the view", `${RULE}#commands`, async (signal) => {
+		const result = await run(signal, "list");
 		expectEqual(sorted(JSON.parse(result.stdout).map((entry) => entry.id)), idsOf("cli"), "ids");
 	});
-	await checks.run("list gives the usage of each capability, with its flags", `${RULE}#commands`, async () => {
-		const entries = JSON.parse((await cli("list")).stdout);
+	await checks.run("list gives the usage of each capability, with its flags", `${RULE}#commands`, async (signal) => {
+		const entries = JSON.parse((await run(signal, "list")).stdout);
 		for (const { id, usage } of entries) {
 			expect(typeof usage === "string", `${id} must have a usage`);
 			const [program, ...rest] = usage.split(" ");

package/dist/conform/http.d.ts

@@ -2,4 +2,5 @@
 import { Checks } from "./check.js";
 export declare function checkHttp(base: string, options: {
     readonly maximumBytes: number;
+    readonly deadline: number;
 }): Promise<Checks>;

package/dist/conform/http.js

@@ -3,31 +3,32 @@ import { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, idsOf, sorted } from "./
 /** Conformance checks for the HTTP binding (spec/bindings/http.md). */
 const RULE = "spec/bindings/http.md";
 async function checkHttp(base, options) {
-	const checks = new Checks("http");
-	const post = (id, body, headers = {}) => fetch(`${base}/capabilities/${id}`, {
+	const checks = new Checks("http", options.deadline);
+	const post = (signal, id, body, headers = {}) => fetch(`${base}/capabilities/${id}`, {
 		method: "POST",
 		headers: {
 			"Content-Type": "application/json",
 			...headers
 		},
-		body: typeof body === "string" ? body : body instanceof Uint8Array ? new Blob([body]) : JSON.stringify(body)
+		body: typeof body === "string" ? body : body instanceof Uint8Array ? new Blob([body]) : JSON.stringify(body),
+		signal
 	});
 	const json = async (response) => await response.json();
-	await checks.run("GET /capabilities lists the view with availability", `${RULE}#requests`, async () => {
-		const list = await (await fetch(`${base}/capabilities`)).json();
+	await checks.run("GET /capabilities lists the view with availability", `${RULE}#requests`, async (signal) => {
+		const list = await (await fetch(`${base}/capabilities`, { signal })).json();
 		expectEqual(sorted(list.map((entry) => entry.id)), idsOf("api"), "ids");
 		expect(list.every((entry) => typeof entry.available === "boolean"), "each entry must have available");
 	});
-	await checks.run("a value has the status 200", `${RULE}#requests`, async () => {
-		const response = await post("fixture.echo", { text: "hello" });
+	await checks.run("a value has the status 200", `${RULE}#requests`, async (signal) => {
+		const response = await post(signal, "fixture.echo", { text: "hello" });
 		expectEqual(response.status, 200, "status");
 		expectEqual(await json(response), {
 			ok: true,
 			value: { text: "hello" }
 		}, "body");
 	});
-	await checks.run("a failure has the status 200 and ok: false", `${RULE}#requests`, async () => {
-		const response = await post("fixture.refuse", {});
+	await checks.run("a failure has the status 200 and ok: false", `${RULE}#requests`, async (signal) => {
+		const response = await post(signal, "fixture.refuse", {});
 		const body = await json(response);
 		expectEqual(response.status, 200, "status");
 		expect(body.ok === false && body.error?._tag === "Refused", `got ${JSON.stringify(body)}`);
@@ -54,38 +55,41 @@ async function checkHttp(base, options) {
 			500,
 			"internal"
 		]
-	]) await checks.run(name, `${RULE}#requests`, async () => {
-		const response = await post(id, input);
+	]) await checks.run(name, `${RULE}#requests`, async (signal) => {
+		const response = await post(signal, id, input);
 		expectEqual(response.status, status, "status");
 		expectEqual((await json(response)).kind, kind, "kind");
 	});
-	await checks.run("an unavailable capability has the status 503", `${RULE}#requests`, async () => {
-		await post("fixture.switch.set", { on: false });
+	await checks.run("an unavailable capability has the status 503", `${RULE}#requests`, async (signal) => {
+		await post(signal, "fixture.switch.set", { on: false });
 		try {
-			const toggle = (await (await fetch(`${base}/capabilities`)).json()).find((entry) => entry.id === "fixture.toggle");
+			const toggle = (await (await fetch(`${base}/capabilities`, { signal })).json()).find((entry) => entry.id === "fixture.toggle");
 			expect(toggle?.available === false && typeof toggle.reason === "string", "fixture.toggle must be unavailable, with a reason");
-			const response = await post("fixture.toggle", {});
+			const response = await post(signal, "fixture.toggle", {});
 			expectEqual(response.status, 503, "status");
 			expectEqual((await json(response)).kind, "unavailable", "kind");
 		} finally {
-			await post("fixture.switch.set", { on: true });
+			await post(AbortSignal.timeout(options.deadline), "fixture.switch.set", { on: true });
 		}
 	});
 	const status = async (response, expected) => expectEqual(response.status, expected, "status");
-	await checks.run("a method that is not accepted is rejected with 405", `${RULE}#requests`, async () => {
-		await status(await fetch(`${base}/capabilities`, { method: "PUT" }), 405);
+	await checks.run("a method that is not accepted is rejected with 405", `${RULE}#requests`, async (signal) => {
+		await status(await fetch(`${base}/capabilities`, {
+			method: "PUT",
+			signal
+		}), 405);
 	});
-	await checks.run("an origin that is not allowed is rejected with 403", `${RULE}#requests`, async () => {
-		await status(await post("fixture.echo", { text: "x" }, { Origin: FORBIDDEN_ORIGIN }), 403);
+	await checks.run("an origin that is not allowed is rejected with 403", `${RULE}#requests`, async (signal) => {
+		await status(await post(signal, "fixture.echo", { text: "x" }, { Origin: FORBIDDEN_ORIGIN }), 403);
 	});
-	await checks.run("a media type other than JSON is rejected with 415", `${RULE}#requests`, async () => {
-		await status(await post("fixture.echo", { text: "x" }, { "Content-Type": "text/plain" }), 415);
+	await checks.run("a media type other than JSON is rejected with 415", `${RULE}#requests`, async (signal) => {
+		await status(await post(signal, "fixture.echo", { text: "x" }, { "Content-Type": "text/plain" }), 415);
 	});
-	await checks.run("a body over the limit is rejected with 413", `${RULE}#requests`, async () => {
-		await status(await post("fixture.echo", " ".repeat(options.maximumBytes + 1)), 413);
+	await checks.run("a body over the limit is rejected with 413", `${RULE}#requests`, async (signal) => {
+		await status(await post(signal, "fixture.echo", " ".repeat(options.maximumBytes + 1)), 413);
 	});
-	await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE}#requests`, async () => {
-		await status(await post("fixture.echo", new Uint8Array([
+	await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE}#requests`, async (signal) => {
+		await status(await post(signal, "fixture.echo", new Uint8Array([
 			123,
 			255,
 			125

package/dist/conform/index.d.ts

@@ -1,11 +1,7 @@
-/**
- * `acid-cat conform`: test a running implementation through its bindings (spec/conformance.md). The implementation
- * serves the conformance fixture (conformance/fixture.acidcat.json), with its switch on.
- */
 import type { Check } from "./check.js";
 import type { WebMcpInstall } from "./webmcp.js";
 export type { Check } from "./check.js";
-export { fixture } from "./check.js";
+export { DEADLINE, fixture } from "./check.js";
 export { serve } from "./serve.js";
 export type { Served, WebHandler } from "./serve.js";
 export { createTestHost } from "./webmcp.js";
@@ -24,6 +20,11 @@ export interface ConformOptions {
     readonly webmcp?: string | WebMcpInstall | undefined;
     /** The body limit of the remote bindings, in bytes. The default is 1 MiB. */
     readonly maximumBytes?: number | undefined;
+    /**
+     * The time, in milliseconds, that each check has to settle. A check that does not settle in this time fails. The
+     * default is `DEADLINE`, 30 seconds.
+     */
+    readonly deadline?: number | undefined;
 }
 /** Run all checks for the bindings that the options give. */
 export declare function conform(options: ConformOptions): Promise<readonly Check[]>;

package/dist/conform/index.js

@@ -1,4 +1,4 @@
-import { fixture } from "./check.js";
+import { DEADLINE, fixture } from "./check.js";
 import { checkCli } from "./cli.js";
 import { checkHttp } from "./http.js";
 import { checkMcp } from "./mcp.js";
@@ -6,27 +6,38 @@ import { checkProperties, httpInvoke, mcpInvoke } from "./properties.js";
 import { browserDriver, checkWebMcp, processDriver } from "./webmcp.js";
 import { serve } from "./serve.js";
 //#region src/conform/index.ts
+/**
+* `acid-cat conform`: test a running implementation through its bindings (spec/conformance.md). The implementation
+* serves the conformance fixture (conformance/fixture.acidcat.json), with its switch on.
+*/
 /** Run all checks for the bindings that the options give. */
 async function conform(options) {
 	const maximumBytes = options.maximumBytes ?? 1048576;
+	const deadline = options.deadline ?? 3e4;
 	const results = [];
 	if (options.mcp !== void 0) {
-		results.push(...(await checkMcp(options.mcp, { maximumBytes })).results);
-		const mcp = await mcpInvoke(options.mcp).catch(() => void 0);
+		results.push(...(await checkMcp(options.mcp, {
+			maximumBytes,
+			deadline
+		})).results);
+		const mcp = await mcpInvoke(options.mcp, AbortSignal.timeout(deadline)).catch(() => void 0);
 		if (mcp !== void 0) {
-			results.push(...(await checkProperties("mcp", mcp.invoke)).results);
+			results.push(...(await checkProperties("mcp", mcp.invoke, deadline)).results);
 			await mcp.close();
 		}
 	}
 	if (options.http !== void 0) {
-		results.push(...(await checkHttp(options.http, { maximumBytes })).results);
-		results.push(...(await checkProperties("http", httpInvoke(options.http))).results);
+		results.push(...(await checkHttp(options.http, {
+			maximumBytes,
+			deadline
+		})).results);
+		results.push(...(await checkProperties("http", httpInvoke(options.http), deadline)).results);
 	}
-	if (options.cli !== void 0) results.push(...(await checkCli(options.cli)).results);
+	if (options.cli !== void 0) results.push(...(await checkCli(options.cli, { deadline })).results);
 	if (options.webmcp !== void 0) {
 		const driver = typeof options.webmcp === "string" ? await browserDriver(options.webmcp) : await processDriver(options.webmcp);
 		try {
-			results.push(...(await checkWebMcp(driver)).results);
+			results.push(...(await checkWebMcp(driver, { deadline })).results);
 		} finally {
 			await driver.close();
 		}
@@ -34,4 +45,4 @@ async function conform(options) {
 	return results;
 }
 //#endregion
-export { conform, fixture, serve };
+export { DEADLINE, conform, fixture, serve };

package/dist/conform/mcp.d.ts

@@ -5,7 +5,8 @@
 import { Client } from "@modelcontextprotocol/client";
 import { Checks } from "./check.js";
 /** A connected MCP client. */
-export declare function mcpClient(url: string): Promise<Client>;
+export declare function mcpClient(url: string, signal?: AbortSignal): Promise<Client>;
 export declare function checkMcp(url: string, options: {
     readonly maximumBytes: number;
+    readonly deadline: number;
 }): Promise<Checks>;