@acid-cat/cli 0.3.0 → 0.4.0

package/dist/conform/mcp.js

@@ -7,36 +7,36 @@ import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/cli
 */
 const RULE = "spec/bindings/mcp.md";
 /** A connected MCP client. */
-async function mcpClient(url) {
+async function mcpClient(url, signal) {
 	const client = new Client({
 		name: "acid-cat-conform",
 		version: "0.1.0"
 	}, { versionNegotiation: { mode: { pin: "2026-07-28" } } });
-	await client.connect(new StreamableHTTPClientTransport(new URL(url)));
+	await client.connect(new StreamableHTTPClientTransport(new URL(url)), signal ? { signal } : void 0);
 	return client;
 }
 const textOf = (result) => JSON.parse(result.content?.[0]?.text ?? "null");
 async function checkMcp(url, options) {
-	const checks = new Checks("mcp");
+	const checks = new Checks("mcp", options.deadline);
 	let client;
-	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#server`, async () => {
-		client = await mcpClient(url);
+	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#server`, async (signal) => {
+		client = await mcpClient(url, signal);
 	});
 	if (client === void 0) return checks;
 	const mcp = client;
-	const call = (name, args) => mcp.callTool({
+	const call = (signal, name, args) => mcp.callTool({
 		name,
 		arguments: args
-	});
+	}, { signal });
 	await checks.run("server/discover gives the description of the catalog as instructions", `${RULE}#server`, () => {
 		expectEqual(mcp.getInstructions(), fixture.description, "instructions");
 	});
-	await checks.run("tools/list gives each available capability of the view", `${RULE}#tools`, async () => {
-		const { tools } = await mcp.listTools();
+	await checks.run("tools/list gives each available capability of the view", `${RULE}#tools`, async (signal) => {
+		const { tools } = await mcp.listTools(void 0, { signal });
 		expectEqual(sorted(tools.map((tool) => tool.name)), idsOf("mcp"), "tools");
 	});
-	await checks.run("tools have their hints and output schemas", `${RULE}#tools`, async () => {
-		const { tools } = await mcp.listTools();
+	await checks.run("tools have their hints and output schemas", `${RULE}#tools`, async (signal) => {
+		const { tools } = await mcp.listTools(void 0, { signal });
 		const echo = tools.find((tool) => tool.name === "fixture.echo");
 		const refuse = tools.find((tool) => tool.name === "fixture.refuse");
 		expect(echo?.annotations?.readOnlyHint === true, "fixture.echo must have readOnlyHint: true");
@@ -45,80 +45,81 @@ async function checkMcp(url, options) {
 		expect(refuse?.outputSchema === void 0, "fixture.refuse has no object output, so it must have no outputSchema");
 		expect((echo?.inputSchema).type === "object", "an inputSchema must be an object");
 	});
-	await checks.run("a value is a tool result with structured content", `${RULE}#tools`, async () => {
-		const result = await call("fixture.echo", { text: "hello" });
+	await checks.run("a value is a tool result with structured content", `${RULE}#tools`, async (signal) => {
+		const result = await call(signal, "fixture.echo", { text: "hello" });
 		expect(result.isError !== true, "a value must not be an error result");
 		expectEqual(result.structuredContent, { text: "hello" }, "structuredContent");
 		expectEqual(textOf(result), { text: "hello" }, "text content");
 	});
-	await checks.run("a failure is an error result with ok: false", `${RULE}#tools`, async () => {
-		const result = await call("fixture.refuse", {});
+	await checks.run("a failure is an error result with ok: false", `${RULE}#tools`, async (signal) => {
+		const result = await call(signal, "fixture.refuse", {});
 		expect(result.isError === true, "a failure must be an error result");
 		const body = textOf(result);
 		expect(body.ok === false && body.error?._tag === "Refused", `expected { ok: false, error: { _tag: "Refused" } }, got ${JSON.stringify(body)}`);
 	});
-	await checks.run("a defect is an internal call failure with no internal details", `${RULE}#tools`, async () => {
-		const result = await call("fixture.crash", {});
+	await checks.run("a defect is an internal call failure with no internal details", `${RULE}#tools`, async (signal) => {
+		const result = await call(signal, "fixture.crash", {});
 		const body = textOf(result);
 		expect(result.isError === true && body.kind === "internal" && !("ok" in body), `expected { kind: "internal" }, got ${JSON.stringify(body)}`);
 		expect(!/\n\s+at /.test(body.message ?? ""), "the message must not contain a stack trace");
 	});
-	await checks.run("an input that does not agree with its schema is invalid-input", `${RULE}#tools`, async () => {
-		const result = await call("fixture.echo", { text: 1 });
+	await checks.run("an input that does not agree with its schema is invalid-input", `${RULE}#tools`, async (signal) => {
+		const result = await call(signal, "fixture.echo", { text: 1 });
 		expectEqual(textOf(result).kind, "invalid-input", "kind");
 	});
-	await checks.run("a capability outside the view is an unknown tool", `${RULE}#tools`, async () => {
-		const error = await call("fixture.hidden", {}).then(() => void 0, (caught) => caught);
+	await checks.run("a capability outside the view is an unknown tool", `${RULE}#tools`, async (signal) => {
+		const error = await call(signal, "fixture.hidden", {}).then(() => void 0, (caught) => caught);
 		expect(error?.code === -32602, `expected the JSON-RPC error -32602, got ${JSON.stringify(error)}`);
 	});
-	await checks.run("an unavailable capability is not listed", `${RULE}#tools`, async () => {
-		await call("fixture.switch.set", { on: false });
+	await checks.run("an unavailable capability is not listed", `${RULE}#tools`, async (signal) => {
+		await call(signal, "fixture.switch.set", { on: false });
 		try {
-			const { tools } = await mcp.listTools();
+			const { tools } = await mcp.listTools(void 0, { signal });
 			expect(!tools.some((tool) => tool.name === "fixture.toggle"), "fixture.toggle must not be listed while it is unavailable");
 		} finally {
-			await call("fixture.switch.set", { on: true });
+			await call(AbortSignal.timeout(options.deadline), "fixture.switch.set", { on: true });
 		}
 	});
 	await mcp.close();
-	const post = (init) => fetch(url, {
+	const post = (signal, init) => fetch(url, {
 		method: "POST",
 		...init,
 		headers: {
 			"Content-Type": "application/json",
 			...init.headers
-		}
+		},
+		signal
 	});
 	const rejection = async (response, status, code) => {
 		expectEqual(response.status, status, "status");
 		expectEqual(response.headers.get("Cache-Control"), "no-store", "Cache-Control");
 		if (code !== void 0) expectEqual((await response.json()).error?.code, code, "JSON-RPC error code");
 	};
-	await checks.run("a method other than POST is rejected with 405", `${RULE}#server`, async () => {
-		const response = await fetch(url);
+	await checks.run("a method other than POST is rejected with 405", `${RULE}#server`, async (signal) => {
+		const response = await fetch(url, { signal });
 		await rejection(response, 405);
 		expectEqual(response.headers.get("Allow"), "POST", "Allow");
 	});
-	await checks.run("an origin that is not allowed is rejected with 403", `${RULE}#server`, async () => {
-		await rejection(await post({
+	await checks.run("an origin that is not allowed is rejected with 403", `${RULE}#server`, async (signal) => {
+		await rejection(await post(signal, {
 			headers: { Origin: FORBIDDEN_ORIGIN },
 			body: "{}"
 		}), 403);
 	});
-	await checks.run("a media type other than JSON is rejected with 415", `${RULE}#server`, async () => {
-		await rejection(await post({
+	await checks.run("a media type other than JSON is rejected with 415", `${RULE}#server`, async (signal) => {
+		await rejection(await post(signal, {
 			headers: { "Content-Type": "text/plain" },
 			body: "{}"
 		}), 415);
 	});
-	await checks.run("a body over the limit is rejected with 413 and -32600", `${RULE}#server`, async () => {
-		await rejection(await post({ body: " ".repeat(options.maximumBytes + 1) }), 413, -32600);
+	await checks.run("a body over the limit is rejected with 413 and -32600", `${RULE}#server`, async (signal) => {
+		await rejection(await post(signal, { body: " ".repeat(options.maximumBytes + 1) }), 413, -32600);
 	});
-	await checks.run("a body that is not JSON is rejected with 400 and -32700", `${RULE}#server`, async () => {
-		await rejection(await post({ body: "{" }), 400, -32700);
+	await checks.run("a body that is not JSON is rejected with 400 and -32700", `${RULE}#server`, async (signal) => {
+		await rejection(await post(signal, { body: "{" }), 400, -32700);
 	});
-	await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE}#server`, async () => {
-		await rejection(await post({ body: new Uint8Array([
+	await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE}#server`, async (signal) => {
+		await rejection(await post(signal, { body: new Uint8Array([
 			123,
 			255,
 			125

package/dist/conform/properties.d.ts

@@ -1,14 +1,10 @@
-/**
- * Property-based checks for the guarantees of spec/invocation.md#cancellation-and-concurrency, through each remote
- * binding. fast-check makes random sets of concurrent calls and cancellations.
- */
 import type { Outcome } from "@acid-cat/spec-ts";
 import { Checks } from "./check.js";
-/** A call through one binding. A cancelled call can reject. */
+/** A call through one binding. When the signal aborts, the client stops the call and rejects with the reason of the signal. */
 export type Invoke = (id: string, input: object, signal?: AbortSignal) => Promise<Outcome<unknown, unknown>>;
 export declare function httpInvoke(base: string): Invoke;
-export declare function mcpInvoke(url: string): Promise<{
+export declare function mcpInvoke(url: string, signal: AbortSignal): Promise<{
     readonly invoke: Invoke;
     close(): Promise<void>;
 }>;
-export declare function checkProperties(binding: string, invoke: Invoke): Promise<Checks>;
+export declare function checkProperties(binding: string, invoke: Invoke, deadline: number): Promise<Checks>;

package/dist/conform/properties.js

@@ -1,7 +1,13 @@
-import { Checks, expect } from "./check.js";
+import { Checks, expect, until } from "./check.js";
 import { mcpClient } from "./mcp.js";
+import { SdkError } from "@modelcontextprotocol/client";
+import { randomUUID } from "node:crypto";
 import fc from "fast-check";
 //#region src/conform/properties.ts
+/**
+* Property-based checks for the guarantees of spec/invocation.md#cancellation-and-concurrency, through each remote
+* binding. fast-check makes random sets of concurrent calls and cancellations.
+*/
 const RULE = "spec/invocation.md#cancellation-and-concurrency";
 function httpInvoke(base) {
 	return async (id, input, signal) => {
@@ -13,8 +19,8 @@ function httpInvoke(base) {
 		})).json();
 	};
 }
-async function mcpInvoke(url) {
-	const client = await mcpClient(url);
+async function mcpInvoke(url, signal) {
+	const client = await mcpClient(url, signal);
 	return {
 		invoke: async (id, input, signal) => {
 			try {
@@ -29,6 +35,7 @@ async function mcpInvoke(url) {
 				};
 				return body;
 			} catch (error) {
+				if (signal?.aborted && error instanceof SdkError && error.message === String(signal.reason)) throw signal.reason;
 				if (error.code === -32602) return {
 					kind: "unknown-capability",
 					message: String(error)
@@ -52,45 +59,100 @@ function agrees(operation, outcome) {
 		case "invalid": return "kind" in outcome && outcome.kind === "invalid-input";
 	}
 }
-const callFor = (invoke, operation) => {
+const callFor = (invoke, operation, signal) => {
 	switch (operation.kind) {
-		case "echo": return invoke("fixture.echo", { text: operation.text });
-		case "refuse": return invoke("fixture.refuse", {});
-		case "crash": return invoke("fixture.crash", {});
-		case "invalid": return invoke("fixture.echo", { text: 0 });
+		case "echo": return invoke("fixture.echo", { text: operation.text }, signal);
+		case "refuse": return invoke("fixture.refuse", {}, signal);
+		case "crash": return invoke("fixture.crash", {}, signal);
+		case "invalid": return invoke("fixture.echo", { text: 0 }, signal);
 	}
 };
-async function checkProperties(binding, invoke) {
-	const checks = new Checks(`${binding} properties`);
-	await checks.run("concurrent calls each get exactly their own outcome", RULE, async () => {
+const settle = (call) => call.then((outcome) => ({ outcome }), (rejected) => ({ rejected }));
+const describe = (settled) => "outcome" in settled ? JSON.stringify(settled.outcome) : `the rejection ${String(settled.rejected)}`;
+/**
+* True if a call ended as a cancellation: with the call failure `cancelled`, or with the rejection that the client gives
+* when it aborts the call, which is the reason of its signal. Any other rejection is not a cancellation.
+*/
+const isCancellation = (settled, reason) => "outcome" in settled ? "kind" in settled.outcome && settled.outcome.kind === "cancelled" : settled.rejected === reason;
+/** The keys of the calls that hold now, as fixture.held gives them through the binding. */
+async function heldKeys(invoke, signal) {
+	const outcome = await invoke("fixture.held", {}, signal);
+	expect("ok" in outcome && outcome.ok, `fixture.held gave ${JSON.stringify(outcome)}`);
+	return outcome.value.keys;
+}
+/**
+* Start one call to fixture.hold for each flag, and wait until each call holds. Then cancel each call whose flag is
+* true, and release the others. Each cancelled call must end as a cancellation and stop holding. Each other call must
+* hold until it is released, and then give its own key. At the end, the cleanup releases every key, with a signal that
+* aborts `deadline` milliseconds later.
+*/
+async function cancelSome(invoke, flags, signal, deadline) {
+	const calls = flags.map((cancelled) => {
+		const key = randomUUID();
+		const controller = new AbortController();
+		const reason = /* @__PURE__ */ new Error(`acid-cat conform cancels the call that holds ${key}`);
+		return {
+			key,
+			cancelled,
+			cancel: () => controller.abort(reason),
+			reason,
+			settled: settle(invoke("fixture.hold", { key }, AbortSignal.any([controller.signal, signal])))
+		};
+	});
+	const cancelled = calls.filter((call) => call.cancelled);
+	const kept = calls.filter((call) => !call.cancelled);
+	const read = () => heldKeys(invoke, signal);
+	try {
+		await until("fixture.held gives the key of each call", read, (held) => calls.every((call) => held.includes(call.key)), signal);
+		for (const call of cancelled) call.cancel();
+		for (const call of cancelled) {
+			const settled = await call.settled;
+			expect(isCancellation(settled, call.reason), `a cancelled call gave ${describe(settled)}`);
+		}
+		const held = await until("the cancelled calls stop holding", read, (held) => cancelled.every((call) => !held.includes(call.key)), signal);
+		expect(kept.every((call) => held.includes(call.key)), "a call that was not cancelled stopped holding");
+		for (const call of kept) {
+			await invoke("fixture.release", { key: call.key }, signal);
+			const settled = await call.settled;
+			const own = {
+				ok: true,
+				value: { key: call.key }
+			};
+			expect("outcome" in settled && JSON.stringify(settled.outcome) === JSON.stringify(own), `a call that was not cancelled gave ${describe(settled)}`);
+		}
+	} finally {
+		const cleanup = AbortSignal.timeout(deadline);
+		await Promise.all(calls.map((call) => invoke("fixture.release", { key: call.key }, cleanup).catch(() => void 0)));
+	}
+}
+/** Two calls or more, at least one of them cancelled and at least one not. */
+const cancellations = fc.array(fc.boolean(), {
+	minLength: 2,
+	maxLength: 5
+}).filter((flags) => flags.includes(true) && flags.includes(false));
+async function checkProperties(binding, invoke, deadline) {
+	const checks = new Checks(`${binding} properties`, deadline);
+	await checks.run("concurrent calls each get exactly their own outcome", RULE, async (signal) => {
 		await fc.assert(fc.asyncProperty(fc.array(operation, {
 			minLength: 1,
 			maxLength: 12
 		}), async (operations) => {
-			const outcomes = await Promise.all(operations.map((op) => callFor(invoke, op)));
+			fc.pre(!signal.aborted);
+			const outcomes = await Promise.all(operations.map((op) => callFor(invoke, op, signal)));
 			operations.forEach((op, index) => expect(agrees(op, outcomes[index]), `${op.kind} gave ${JSON.stringify(outcomes[index])}`));
-		}), { numRuns: 25 });
+		}), {
+			numRuns: 25,
+			includeErrorInReport: true
+		});
 	});
-	await checks.run("cancelling a call affects only that call", RULE, async () => {
-		await fc.assert(fc.asyncProperty(fc.array(fc.boolean(), {
-			minLength: 2,
-			maxLength: 5
-		}), async (cancel) => {
-			const calls = cancel.map((cancelled) => {
-				const controller = new AbortController();
-				const outcome = invoke("fixture.slow", { milliseconds: 200 }, controller.signal).catch(() => "aborted");
-				if (cancelled) setTimeout(() => controller.abort(), 20);
-				return {
-					cancelled,
-					outcome
-				};
-			});
-			for (const call of calls) {
-				const outcome = await call.outcome;
-				if (!call.cancelled) expect(outcome !== "aborted" && "ok" in outcome && outcome.ok, `a call that was not cancelled gave ${JSON.stringify(outcome)}`);
-				else expect(outcome === "aborted" || "kind" in outcome && outcome.kind === "cancelled", `a cancelled call gave ${JSON.stringify(outcome)}`);
-			}
-		}), { numRuns: 5 });
+	await checks.run("cancelling a call affects only that call", RULE, async (signal) => {
+		await fc.assert(fc.asyncProperty(cancellations, (flags) => {
+			fc.pre(!signal.aborted);
+			return cancelSome(invoke, flags, signal, deadline);
+		}), {
+			numRuns: 5,
+			includeErrorInReport: true
+		});
 	});
 	return checks;
 }

package/dist/conform/webmcp.d.ts

@@ -25,8 +25,10 @@ export interface TestHost {
         }): void;
     };
     tools(): RecordedTool[];
-    /** Call a tool. If `cancelAfter` is given, abort the signal of the call after that many milliseconds. */
-    call(name: string, input: unknown, cancelAfter?: number): Promise<ToolCall>;
+    /** Call a tool. With an `id`, `cancel` can abort the signal of the call. */
+    call(name: string, input: unknown, id?: string): Promise<ToolCall>;
+    /** Abort the signal of the call that has this `id`, if it runs. */
+    cancel(id: string): void;
 }
 /**
  * Make a test host. The function uses no imports and no outer variables, because the browser driver sends its
@@ -35,8 +37,15 @@ export interface TestHost {
 export declare function createTestHost(): TestHost;
 /** The view from the checks: the tools of the page, and calls to them. */
 export interface WebMcpDriver {
-    tools(): Promise<RecordedTool[]>;
-    call(name: string, input: unknown, cancelAfter?: number): Promise<ToolCall>;
+    tools(signal: AbortSignal): Promise<RecordedTool[]>;
+    /**
+     * Call a tool. When `cancel` aborts, the host aborts the signal of the call, and the driver waits for what the tool
+     * gives. When `signal` aborts, the host aborts the signal of the call, and the driver stops waiting.
+     */
+    call(name: string, input: unknown, options?: {
+        readonly signal?: AbortSignal;
+        readonly cancel?: AbortSignal;
+    }): Promise<ToolCall>;
     close(): Promise<void>;
 }
 /**
@@ -48,4 +57,6 @@ export type WebMcpInstall = (modelContext: TestHost["modelContext"]) => void | (
 export declare function processDriver(install: WebMcpInstall): Promise<WebMcpDriver>;
 /** A driver for a page in Chromium, through Playwright. The page loads with the test host as its `modelContext`. */
 export declare function browserDriver(url: string): Promise<WebMcpDriver>;
-export declare function checkWebMcp(driver: WebMcpDriver): Promise<Checks>;
+export declare function checkWebMcp(driver: WebMcpDriver, options: {
+    readonly deadline: number;
+}): Promise<Checks>;

package/dist/conform/webmcp.js

@@ -1,4 +1,4 @@
-import { Checks, expect, expectEqual, fixture, idsOf, sorted } from "./check.js";
+import { Checks, abortable, expect, expectEqual, fixture, idsOf, sorted, until } from "./check.js";
 import { REFERENCE, visitObjects } from "@acid-cat/spec-ts";
 //#region src/conform/webmcp.ts
 /**
@@ -17,6 +17,7 @@ const TARGET = "app";
 */
 function createTestHost() {
 	const registered = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
 	return {
 		modelContext: { registerTool(tool, options) {
 			const recorded = tool;
@@ -30,11 +31,11 @@ function createTestHost() {
 			description: tool.description,
 			inputSchema: tool.inputSchema
 		})),
-		async call(name, input, cancelAfter) {
+		async call(name, input, id) {
 			const tool = registered.get(name);
 			if (tool === void 0) return { missing: true };
 			const controller = new AbortController();
-			if (cancelAfter !== void 0) setTimeout(() => controller.abort(), cancelAfter);
+			if (id !== void 0) calls.set(id, controller);
 			try {
 				return { resolved: await tool.execute(input, { signal: controller.signal }) };
 			} catch (error) {
@@ -44,22 +45,46 @@ function createTestHost() {
 					kind,
 					message: String(message)
 				} };
+			} finally {
+				if (id !== void 0) calls.delete(id);
 			}
+		},
+		cancel(id) {
+			calls.get(id)?.abort();
 		}
 	};
 }
+let lastCall = 0;
+function driverOf(host) {
+	return {
+		tools: (signal) => abortable(host.tools(), signal),
+		call: (name, input, { signal, cancel } = {}) => {
+			const id = String(++lastCall);
+			const stop = () => void host.cancel(id).catch(() => void 0);
+			signal?.addEventListener("abort", stop, { once: true });
+			cancel?.addEventListener("abort", stop, { once: true });
+			const call = host.call(name, input, id).finally(() => {
+				signal?.removeEventListener("abort", stop);
+				cancel?.removeEventListener("abort", stop);
+			});
+			return signal === void 0 ? call : abortable(call, signal);
+		},
+		close: () => host.close()
+	};
+}
 /** A driver for an implementation in the same process. Values pass through JSON, as they do from a page. */
 async function processDriver(install) {
 	const host = createTestHost();
 	const remove = await install(host.modelContext);
 	const copy = (value) => JSON.parse(JSON.stringify(value));
-	return {
+	return driverOf({
 		tools: async () => copy(host.tools()),
-		call: async (name, input, cancelAfter) => copy(await host.call(name, input, cancelAfter)),
+		call: async (name, input, id) => copy(await host.call(name, input, id)),
+		cancel: async (id) => host.cancel(id),
 		close: async () => {
 			if (typeof remove === "function") await remove();
 		}
-	};
+	});
 }
 /** A driver for a page in Chromium, through Playwright. The page loads with the test host as its `modelContext`. */
 async function browserDriver(url) {
@@ -80,27 +105,19 @@ async function browserDriver(url) {
     }
   `);
 	await page.goto(url);
-	return {
+	return driverOf({
 		tools: async () => {
 			if (errors.length > 0) throw new Error(`The page has errors: ${errors.join("; ")}`);
 			return page.evaluate(() => window.__acidCatConform.tools());
 		},
-		call: (name, input, cancelAfter) => page.evaluate(([name, input, cancelAfter]) => window.__acidCatConform.call(name, input, cancelAfter), [
+		call: (name, input, id) => page.evaluate(([name, input, id]) => window.__acidCatConform.call(name, input, id), [
 			name,
 			input,
-			cancelAfter
+			id
 		]),
+		cancel: (id) => page.evaluate((id) => window.__acidCatConform.cancel(id), id),
 		close: () => browser.close()
-	};
-}
-/** Wait until `condition` is true. Give up after `timeout` milliseconds. */
-async function eventually(condition, what, timeout = 5e3) {
-	const end = Date.now() + timeout;
-	for (;;) {
-		if (await condition()) return;
-		if (Date.now() > end) throw new Error(`after ${timeout} ms: ${what}`);
-		await new Promise((resolve) => setTimeout(resolve, 20));
-	}
+	});
 }
 /** True if each `$ref` of a schema refers to a type in its own `$defs` (spec/catalog.md#bundling). */
 function isBundled(schema) {
@@ -113,16 +130,22 @@ function isBundled(schema) {
 	});
 	return bundled;
 }
-const names = async (driver) => sorted((await driver.tools()).map((tool) => tool.name));
-async function checkWebMcp(driver) {
-	const checks = new Checks("webmcp");
+const names = async (driver, signal) => sorted((await driver.tools(signal)).map((tool) => tool.name));
+/** The keys of the calls that hold now, as fixture.held gives them through the host. */
+async function heldKeys(driver, signal) {
+	const call = await driver.call("fixture.held", {}, { signal });
+	expect("resolved" in call, `fixture.held gave ${JSON.stringify(call)}`);
+	return call.resolved.value.keys;
+}
+async function checkWebMcp(driver, options) {
+	const checks = new Checks("webmcp", options.deadline);
 	const view = fixture.capabilities;
 	const expected = idsOf(TARGET);
-	await checks.run("each available capability of the view is a tool", `${RULE}#tools`, async () => {
-		await eventually(async () => JSON.stringify(await names(driver)) === JSON.stringify(expected), `the tools must be ${expected.join(", ")}`);
+	await checks.run("each available capability of the view is a tool", `${RULE}#tools`, async (signal) => {
+		await until(`the tools are ${expected.join(", ")}`, () => names(driver, signal), (tools) => JSON.stringify(tools) === JSON.stringify(expected), signal);
 	});
-	await checks.run("a tool has the description and the bundled input schema of its capability", `${RULE}#tools`, async () => {
-		for (const tool of await driver.tools()) {
+	await checks.run("a tool has the description and the bundled input schema of its capability", `${RULE}#tools`, async (signal) => {
+		for (const tool of await driver.tools(signal)) {
 			expectEqual(tool.description, view[tool.name]?.description, `description of ${tool.name}`);
 			const schema = tool.inputSchema;
 			const input = view[tool.name]?.input ?? {};
@@ -132,14 +155,14 @@ async function checkWebMcp(driver) {
 			expect(isBundled(schema), `the input schema of ${tool.name} must be bundled`);
 		}
 	});
-	await checks.run("a value resolves as a result", `${RULE}#tools`, async () => {
-		expectEqual(await driver.call("fixture.echo", { text: "hello" }), { resolved: {
+	await checks.run("a value resolves as a result", `${RULE}#tools`, async (signal) => {
+		expectEqual(await driver.call("fixture.echo", { text: "hello" }, { signal }), { resolved: {
 			ok: true,
 			value: { text: "hello" }
 		} }, "outcome");
 	});
-	await checks.run("a failure resolves as a result", `${RULE}#tools`, async () => {
-		const call = await driver.call("fixture.refuse", {});
+	await checks.run("a failure resolves as a result", `${RULE}#tools`, async (signal) => {
+		const call = await driver.call("fixture.refuse", {}, { signal });
 		expect("resolved" in call, `the call must resolve, got ${JSON.stringify(call)}`);
 		expectEqual(call.resolved.error?._tag, "Refused", "_tag");
 	});
@@ -155,23 +178,39 @@ async function checkWebMcp(driver) {
 		{ text: 1 },
 		"invalid-input",
 		"TypeError"
-	]]) await checks.run(name, `${RULE}#tools`, async () => {
-		const call = await driver.call(capability, input);
+	]]) await checks.run(name, `${RULE}#tools`, async (signal) => {
+		const call = await driver.call(capability, input, { signal });
 		expect("rejected" in call, `the call must reject, got ${JSON.stringify(call)}`);
 		expectEqual(call.rejected.kind, kind, "kind");
 		if (errorName !== void 0) expectEqual(call.rejected.name, errorName, "name");
 	});
-	await checks.run("the signal of the host cancels a call, as an AbortError", `${RULE}#tools`, async () => {
-		const call = await driver.call("fixture.slow", { milliseconds: 6e4 }, 50);
-		expect("rejected" in call, `the call must reject, got ${JSON.stringify(call)}`);
-		expectEqual(call.rejected.kind, "cancelled", "kind");
-		expectEqual(call.rejected.name, "AbortError", "name");
+	await checks.run("the signal of the host cancels a call, as an AbortError", `${RULE}#tools`, async (signal) => {
+		const key = "cancel";
+		const cancel = new AbortController();
+		const call = driver.call("fixture.hold", { key }, {
+			signal,
+			cancel: cancel.signal
+		});
+		call.catch(() => void 0);
+		const read = () => heldKeys(driver, signal);
+		try {
+			await until(`fixture.held gives ${key}`, read, (held) => held.includes(key), signal);
+			cancel.abort();
+			const result = await call;
+			expect("rejected" in result, `the call must reject, got ${JSON.stringify(result)}`);
+			expectEqual(result.rejected.kind, "cancelled", "kind");
+			expectEqual(result.rejected.name, "AbortError", "name");
+			await until("the cancelled call stops holding", read, (held) => !held.includes(key), signal);
+		} finally {
+			await driver.call("fixture.release", { key }, { signal: AbortSignal.timeout(options.deadline) }).catch(() => void 0);
+		}
 	});
-	await checks.run("a tool is removed while its capability is unavailable, and registered again after", `${RULE}#tools`, async () => {
-		await driver.call("fixture.switch.set", { on: false });
-		await eventually(async () => !(await names(driver)).includes("fixture.toggle"), "fixture.toggle must be removed");
-		await driver.call("fixture.switch.set", { on: true });
-		await eventually(async () => (await names(driver)).includes("fixture.toggle"), "fixture.toggle must be registered again");
+	await checks.run("a tool is removed while its capability is unavailable, and registered again after", `${RULE}#tools`, async (signal) => {
+		const toggle = (present) => (tools) => tools.includes("fixture.toggle") === present;
+		await driver.call("fixture.switch.set", { on: false }, { signal });
+		await until("fixture.toggle is removed", () => names(driver, signal), toggle(false), signal);
+		await driver.call("fixture.switch.set", { on: true }, { signal });
+		await until("fixture.toggle is registered again", () => names(driver, signal), toggle(true), signal);
 	});
 	return checks;
 }