@acid-cat/cli 0.3.1 → 0.5.0

package/dist/conform/http.js

@@ -1,36 +1,45 @@
+import { isArrayOf, isObject, memberOf, readJson } from "../json.js";
 import { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, idsOf, sorted } from "./check.js";
 //#region src/conform/http.ts
 /** Conformance checks for the HTTP binding (spec/bindings/http.md). */
 const RULE = "spec/bindings/http.md";
+const isEntry = (value) => isObject(value) && typeof value.id === "string";
+/** The list that `GET /capabilities` gives. The check fails when it is not a list of entries. */
+async function entriesOf(response) {
+	const list = await readJson(response);
+	if (!isArrayOf(list, isEntry)) throw new Error(`GET /capabilities must give a list of objects with an id, got ${JSON.stringify(list)}`);
+	return list;
+}
 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([new Uint8Array(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();
+	const kindOf = async (response) => memberOf(await readJson(response), "kind");
+	await checks.run("GET /capabilities lists the view with availability", `${RULE}#requests`, async (signal) => {
+		const list = await entriesOf(await fetch(`${base}/capabilities`, { signal }));
 		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), {
+		expectEqual(await readJson(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", {});
-		const body = await json(response);
+	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 readJson(response);
 		expectEqual(response.status, 200, "status");
-		expect(body.ok === false && body.error?._tag === "Refused", `got ${JSON.stringify(body)}`);
+		expect(memberOf(body, "ok") === false && memberOf(memberOf(body, "error"), "_tag") === "Refused", `got ${JSON.stringify(body)}`);
 	});
 	for (const [name, id, input, status, kind] of [
 		[
@@ -54,38 +63,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");
+		expectEqual(await kindOf(response), 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 entriesOf(await fetch(`${base}/capabilities`, { signal }))).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");
+			expectEqual(await kindOf(response), "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>;

package/dist/conform/mcp.js

@@ -1,3 +1,4 @@
+import { isObject, memberOf, parseJson, readJson } from "../json.js";
 import { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, fixture, idsOf, sorted } from "./check.js";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 //#region src/conform/mcp.ts
@@ -7,118 +8,125 @@ 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");
+/** The JSON value in the first text content of a tool result, or `null` when there is no text content. */
+const textOf = (result) => {
+	const first = result.content[0];
+	return parseJson(first?.type === "text" ? first.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");
 		expect(refuse?.annotations?.readOnlyHint !== true, "fixture.refuse must not have readOnlyHint: true");
-		expect((echo?.outputSchema)?.type === "object", "fixture.echo must have an object outputSchema");
+		expect(echo?.outputSchema?.type === "object", "fixture.echo must have an object outputSchema");
 		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");
+		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)}`);
+		expect(memberOf(body, "ok") === false && memberOf(memberOf(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(isObject(body), `expected an object, got ${JSON.stringify(body)}`);
 		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");
+		const message = typeof body.message === "string" ? body.message : "";
+		expect(!/\n\s+at /.test(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 });
-		expectEqual(textOf(result).kind, "invalid-input", "kind");
+	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(memberOf(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);
-		expect(error?.code === -32602, `expected the JSON-RPC error -32602, got ${JSON.stringify(error)}`);
+	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(memberOf(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, { headers = {}, body }) => fetch(url, {
 		method: "POST",
-		...init,
+		body,
 		headers: {
 			"Content-Type": "application/json",
-			...init.headers
-		}
+			...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");
+		if (code !== void 0) expectEqual(memberOf(memberOf(await readJson(response), "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,11 @@
-/**
- * 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 type { JsonObject } from "../json.js";
 import { Checks } from "./check.js";
-/** A call through one binding. A cancelled call can reject. */
-export type Invoke = (id: string, input: object, signal?: AbortSignal) => Promise<Outcome<unknown, unknown>>;
+/** 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: JsonObject, 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,20 +1,30 @@
-import { Checks, expect } from "./check.js";
+import { isStringArray, memberOf, parseJson, readJson } from "../json.js";
+import { Checks, expect, isOutcome, 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) => {
-		return await (await fetch(`${base}/capabilities/${id}`, {
+		const response = await fetch(`${base}/capabilities/${id}`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(input),
 			...signal ? { signal } : {}
-		})).json();
+		});
+		const outcome = await readJson(response);
+		if (!isOutcome(outcome)) throw new Error(`POST /capabilities/${id} gave ${JSON.stringify(outcome)}, which is not an outcome`);
+		return outcome;
 	};
 }
-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 {
@@ -22,14 +32,17 @@ async function mcpInvoke(url) {
 					name: id,
 					arguments: input
 				}, signal ? { signal } : void 0);
-				const body = JSON.parse(result.content[0]?.text ?? "null");
+				const first = result.content[0];
+				const body = parseJson(first?.type === "text" ? first.text : "null");
 				if (result.isError !== true) return {
 					ok: true,
 					value: result.structuredContent ?? body
 				};
+				if (!isOutcome(body)) throw new Error(`the error result of ${id} gave ${JSON.stringify(body)}, which is not an outcome`);
 				return body;
 			} catch (error) {
-				if (error.code === -32602) return {
+				if (signal?.aborted && error instanceof SdkError && error.message === String(signal.reason)) throw signal.reason;
+				if (memberOf(error, "code") === -32602) return {
 					kind: "unknown-capability",
 					message: String(error)
 				};
@@ -47,50 +60,109 @@ const operation = fc.oneof(fc.string({ maxLength: 40 }).map((text) => ({
 function agrees(operation, outcome) {
 	switch (operation.kind) {
 		case "echo": return "ok" in outcome && outcome.ok && JSON.stringify(outcome.value) === JSON.stringify({ text: operation.text });
-		case "refuse": return "ok" in outcome && !outcome.ok && outcome.error._tag === "Refused";
+		case "refuse": return "ok" in outcome && !outcome.ok && memberOf(outcome.error, "_tag") === "Refused";
 		case "crash": return "kind" in outcome && outcome.kind === "internal";
 		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)}`);
+	const keys = memberOf(outcome.value, "keys");
+	expect(isStringArray(keys), `fixture.held gave ${JSON.stringify(outcome)}, with no list of keys`);
+	return 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)));
-			operations.forEach((op, index) => expect(agrees(op, outcomes[index]), `${op.kind} gave ${JSON.stringify(outcomes[index])}`));
-		}), { numRuns: 25 });
+			fc.pre(!signal.aborted);
+			(await Promise.all(operations.map(async (op) => ({
+				op,
+				outcome: await callFor(invoke, op, signal)
+			})))).forEach(({ op, outcome }) => expect(agrees(op, outcome), `${op.kind} gave ${JSON.stringify(outcome)}`));
+		}), {
+			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;
 }