@acid-cat/cli 0.0.0-stage → 0.2.0

package/dist/conform/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `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 { serve } from "./serve.js";
+export type { Served, WebHandler } from "./serve.js";
+export { createTestHost } from "./webmcp.js";
+export type { TestHost, WebMcpInstall } from "./webmcp.js";
+export interface ConformOptions {
+    /** The URL of the MCP server, for example `http://localhost:8787/mcp`. */
+    readonly mcp?: string | undefined;
+    /** The base URL of the HTTP API, before `/capabilities`. */
+    readonly http?: string | undefined;
+    /** The command that starts the command line, for example `["node", "fixture-cli.ts"]`. */
+    readonly cli?: readonly string[] | undefined;
+    /**
+     * The WebMCP binding: the URL of a page that serves the `app` target, or a function that installs the implementation
+     * on a host in the same process. A page runs in Chromium, through Playwright.
+     */
+    readonly webmcp?: string | WebMcpInstall | undefined;
+    /** The body limit of the remote bindings, in bytes. The default is 1 MiB. */
+    readonly maximumBytes?: 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

@@ -0,0 +1,37 @@
+import { fixture } from "./check.js";
+import { checkCli } from "./cli.js";
+import { checkHttp } from "./http.js";
+import { checkMcp } from "./mcp.js";
+import { checkProperties, httpInvoke, mcpInvoke } from "./properties.js";
+import { browserDriver, checkWebMcp, processDriver } from "./webmcp.js";
+import { serve } from "./serve.js";
+//#region src/conform/index.ts
+/** Run all checks for the bindings that the options give. */
+async function conform(options) {
+	const maximumBytes = options.maximumBytes ?? 1048576;
+	const results = [];
+	if (options.mcp !== void 0) {
+		results.push(...(await checkMcp(options.mcp, { maximumBytes })).results);
+		const mcp = await mcpInvoke(options.mcp).catch(() => void 0);
+		if (mcp !== void 0) {
+			results.push(...(await checkProperties("mcp", mcp.invoke)).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);
+	}
+	if (options.cli !== void 0) results.push(...(await checkCli(options.cli)).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);
+		} finally {
+			await driver.close();
+		}
+	}
+	return results;
+}
+//#endregion
+export { conform, fixture, serve };

package/dist/conform/mcp.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Conformance checks for the MCP binding (spec/bindings/mcp.md). The protocol checks use the official MCP client,
+ * with revision 2026-07-28. The rejection checks send requests that a client never sends.
+ */
+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 checkMcp(url: string, options: {
+    readonly maximumBytes: number;
+}): Promise<Checks>;

package/dist/conform/mcp.js

@@ -0,0 +1,127 @@
+import { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, idsOf, sorted } from "./check.js";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+//#region src/conform/mcp.ts
+/**
+* Conformance checks for the MCP binding (spec/bindings/mcp.md). The protocol checks use the official MCP client,
+* with revision 2026-07-28. The rejection checks send requests that a client never sends.
+*/
+const RULE = "spec/bindings/mcp.md";
+/** A connected MCP client. */
+async function mcpClient(url) {
+	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)));
+	return client;
+}
+const textOf = (result) => JSON.parse(result.content?.[0]?.text ?? "null");
+async function checkMcp(url, options) {
+	const checks = new Checks("mcp");
+	let client;
+	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#server`, async () => {
+		client = await mcpClient(url);
+	});
+	if (client === void 0) return checks;
+	const mcp = client;
+	const call = (name, args) => mcp.callTool({
+		name,
+		arguments: args
+	});
+	await checks.run("tools/list gives each available capability of the view", `${RULE}#tools`, async () => {
+		const { tools } = await mcp.listTools();
+		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();
+		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(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" });
+		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", {});
+		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", {});
+		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 });
+		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);
+		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 });
+		try {
+			const { tools } = await mcp.listTools();
+			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 mcp.close();
+	const post = (init) => fetch(url, {
+		method: "POST",
+		...init,
+		headers: {
+			"Content-Type": "application/json",
+			...init.headers
+		}
+	});
+	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 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({
+			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({
+			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 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 UTF-8 is rejected with 400", `${RULE}#server`, async () => {
+		await rejection(await post({ body: new Uint8Array([
+			123,
+			255,
+			125
+		]) }), 400);
+	});
+	return checks;
+}
+//#endregion
+export { checkMcp, mcpClient };

package/dist/conform/properties.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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. */
+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<{
+    readonly invoke: Invoke;
+    close(): Promise<void>;
+}>;
+export declare function checkProperties(binding: string, invoke: Invoke): Promise<Checks>;

package/dist/conform/properties.js

@@ -0,0 +1,98 @@
+import { Checks, expect } from "./check.js";
+import { mcpClient } from "./mcp.js";
+import fc from "fast-check";
+//#region src/conform/properties.ts
+const RULE = "spec/invocation.md#cancellation-and-concurrency";
+function httpInvoke(base) {
+	return async (id, input, signal) => {
+		return await (await fetch(`${base}/capabilities/${id}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input),
+			...signal ? { signal } : {}
+		})).json();
+	};
+}
+async function mcpInvoke(url) {
+	const client = await mcpClient(url);
+	return {
+		invoke: async (id, input, signal) => {
+			try {
+				const result = await client.callTool({
+					name: id,
+					arguments: input
+				}, signal ? { signal } : void 0);
+				const body = JSON.parse(result.content[0]?.text ?? "null");
+				if (result.isError !== true) return {
+					ok: true,
+					value: result.structuredContent ?? body
+				};
+				return body;
+			} catch (error) {
+				if (error.code === -32602) return {
+					kind: "unknown-capability",
+					message: String(error)
+				};
+				throw error;
+			}
+		},
+		close: () => client.close()
+	};
+}
+const operation = fc.oneof(fc.string({ maxLength: 40 }).map((text) => ({
+	kind: "echo",
+	text
+})), fc.constant({ kind: "refuse" }), fc.constant({ kind: "crash" }), fc.constant({ kind: "invalid" }));
+/** The outcome that an operation must have. */
+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 "crash": return "kind" in outcome && outcome.kind === "internal";
+		case "invalid": return "kind" in outcome && outcome.kind === "invalid-input";
+	}
+}
+const callFor = (invoke, operation) => {
+	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 });
+	}
+};
+async function checkProperties(binding, invoke) {
+	const checks = new Checks(`${binding} properties`);
+	await checks.run("concurrent calls each get exactly their own outcome", RULE, async () => {
+		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 });
+	});
+	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 });
+	});
+	return checks;
+}
+//#endregion
+export { checkProperties, httpInvoke, mcpInvoke };

package/dist/conform/serve.d.ts

@@ -0,0 +1,10 @@
+export interface Served {
+    /** The base URL, for example `http://127.0.0.1:40123`. */
+    readonly url: string;
+    close(): Promise<void>;
+}
+export type WebHandler = (request: Request) => Promise<Response>;
+/** Serve handlers by path prefix, for example `{ "/mcp": mcp, "/api": http }`. */
+export declare function serve(routes: {
+    readonly [prefix: string]: WebHandler;
+}): Promise<Served>;

package/dist/conform/serve.js

@@ -0,0 +1,62 @@
+import { createServer } from "node:http";
+//#region src/conform/serve.ts
+/**
+* Serve a web request handler, `(request: Request) => Promise<Response>`, on a local port. Implementations use it
+* to run `acid-cat conform` against their bindings in a test.
+*/
+/** Serve handlers by path prefix, for example `{ "/mcp": mcp, "/api": http }`. */
+function serve(routes) {
+	const prefixes = Object.keys(routes).sort((a, b) => b.length - a.length);
+	const server = createServer((incoming, outgoing) => {
+		answer(incoming, outgoing, prefixes, routes);
+	});
+	return new Promise((resolve) => {
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			resolve({
+				url: `http://127.0.0.1:${typeof address === "object" && address !== null ? address.port : 0}`,
+				close: () => new Promise((done) => server.close(() => done()))
+			});
+		});
+	});
+}
+async function answer(incoming, outgoing, prefixes, routes) {
+	const url = new URL(incoming.url ?? "/", `http://${incoming.headers.host ?? "127.0.0.1"}`);
+	const prefix = prefixes.find((candidate) => url.pathname === candidate || url.pathname.startsWith(`${candidate}/`));
+	if (prefix === void 0) {
+		outgoing.writeHead(404).end();
+		return;
+	}
+	const abort = new AbortController();
+	outgoing.on("close", () => {
+		if (!outgoing.writableFinished) abort.abort();
+	});
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(incoming.headers)) if (Array.isArray(value)) value.forEach((item) => headers.append(name, item));
+	else if (value !== void 0) headers.set(name, value);
+	const hasBody = incoming.method !== "GET" && incoming.method !== "HEAD";
+	const request = new Request(url, {
+		method: incoming.method ?? "GET",
+		headers,
+		signal: abort.signal,
+		...hasBody ? {
+			body: incoming,
+			duplex: "half"
+		} : {}
+	});
+	try {
+		const response = await routes[prefix](request);
+		outgoing.writeHead(response.status, Object.fromEntries(response.headers));
+		if (response.body === null) {
+			outgoing.end();
+			return;
+		}
+		for await (const chunk of response.body) outgoing.write(chunk);
+		outgoing.end();
+	} catch {
+		if (!outgoing.headersSent) outgoing.writeHead(500);
+		outgoing.end();
+	}
+}
+//#endregion
+export { serve };

package/dist/conform/webmcp.d.ts

@@ -0,0 +1,51 @@
+import { Checks } from "./check.js";
+/** A tool as the host records it. */
+export interface RecordedTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: unknown;
+}
+/** What a call to a tool gives: the value that `execute` resolves with, or the error that it rejects with. */
+export type ToolCall = {
+    readonly resolved: unknown;
+} | {
+    readonly rejected: {
+        readonly name: string;
+        readonly kind: unknown;
+        readonly message: string;
+    };
+} | {
+    readonly missing: true;
+};
+/** The host that the checks give to the page. */
+export interface TestHost {
+    readonly modelContext: {
+        registerTool(tool: object, options: {
+            readonly signal: AbortSignal;
+        }): 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>;
+}
+/**
+ * Make a test host. The function uses no imports and no outer variables, because the browser driver sends its
+ * source text to the page.
+ */
+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>;
+    close(): Promise<void>;
+}
+/**
+ * Install the implementation on a host in the same process. Return a function that removes it, or nothing. The
+ * implementation serves the `app` target of the fixture, with its switch on.
+ */
+export type WebMcpInstall = (modelContext: TestHost["modelContext"]) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>;
+/** A driver for an implementation in the same process. Values pass through JSON, as they do from a page. */
+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>;

package/dist/conform/webmcp.js

@@ -0,0 +1,179 @@
+import { Checks, expect, expectEqual, fixture, idsOf, sorted } from "./check.js";
+import { REFERENCE, visitObjects } from "@acid-cat/spec-ts";
+//#region src/conform/webmcp.ts
+/**
+* Conformance checks for the WebMCP binding (spec/bindings/webmcp.md).
+*
+* The checks act as the WebMCP host: they give the page a `modelContext`, record the tools that the binding registers,
+* and call them. The page can run in a browser, or the implementation can install itself on the host in the same
+* process.
+*/
+const RULE = "spec/bindings/webmcp.md";
+/** The target of the fixture that has the WebMCP binding. */
+const TARGET = "app";
+/**
+* Make a test host. The function uses no imports and no outer variables, because the browser driver sends its
+* source text to the page.
+*/
+function createTestHost() {
+	const registered = /* @__PURE__ */ new Map();
+	return {
+		modelContext: { registerTool(tool, options) {
+			const recorded = tool;
+			registered.set(recorded.name, recorded);
+			options.signal.addEventListener("abort", () => {
+				if (registered.get(recorded.name) === recorded) registered.delete(recorded.name);
+			});
+		} },
+		tools: () => [...registered.values()].map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: tool.inputSchema
+		})),
+		async call(name, input, cancelAfter) {
+			const tool = registered.get(name);
+			if (tool === void 0) return { missing: true };
+			const controller = new AbortController();
+			if (cancelAfter !== void 0) setTimeout(() => controller.abort(), cancelAfter);
+			try {
+				return { resolved: await tool.execute(input, { signal: controller.signal }) };
+			} catch (error) {
+				const { name: errorName, kind, message } = error;
+				return { rejected: {
+					name: String(errorName),
+					kind,
+					message: String(message)
+				} };
+			}
+		}
+	};
+}
+/** 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 {
+		tools: async () => copy(host.tools()),
+		call: async (name, input, cancelAfter) => copy(await host.call(name, input, cancelAfter)),
+		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) {
+	let playwright;
+	try {
+		playwright = await import("playwright");
+	} catch {
+		throw new Error("acid-cat conform --webmcp needs Playwright and Chromium: `pnpm add -D playwright`, then `pnpm exec playwright install chromium`.");
+	}
+	const browser = await playwright.chromium.launch();
+	const page = await browser.newPage();
+	const errors = [];
+	page.on("pageerror", (error) => errors.push(error.message));
+	await page.addInitScript(`
+    window.__acidCatConform = (${createTestHost.toString()})();
+    for (const scope of [document, navigator]) {
+      Object.defineProperty(scope, "modelContext", { value: window.__acidCatConform.modelContext, configurable: true });
+    }
+  `);
+	await page.goto(url);
+	return {
+		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), [
+			name,
+			input,
+			cancelAfter
+		]),
+		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) {
+	const types = schema.$defs ?? {};
+	let bundled = true;
+	visitObjects(schema, (node) => {
+		if (typeof node.$ref !== "string") return;
+		const name = REFERENCE.exec(node.$ref)?.[1];
+		if (name === void 0 || !(name in types)) bundled = false;
+	});
+	return bundled;
+}
+const names = async (driver) => sorted((await driver.tools()).map((tool) => tool.name));
+async function checkWebMcp(driver) {
+	const checks = new Checks("webmcp");
+	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("a tool has the description and the bundled input schema of its capability", `${RULE}#tools`, async () => {
+		for (const tool of await driver.tools()) {
+			expectEqual(tool.description, view[tool.name]?.description, `description of ${tool.name}`);
+			const schema = tool.inputSchema;
+			const input = view[tool.name]?.input ?? {};
+			expectEqual(schema.type, "object", `type of the input schema of ${tool.name}`);
+			expectEqual(sorted(Object.keys(schema.properties ?? {})), sorted(Object.keys(input.properties ?? {})), `properties of ${tool.name}`);
+			expectEqual(sorted(schema.required ?? []), sorted(input.required ?? []), `required properties of ${tool.name}`);
+			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: {
+			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", {});
+		expect("resolved" in call, `the call must resolve, got ${JSON.stringify(call)}`);
+		expectEqual(call.resolved.error?._tag, "Refused", "_tag");
+	});
+	for (const [name, capability, input, kind, errorName] of [[
+		"a defect rejects with the kind internal",
+		"fixture.crash",
+		{},
+		"internal",
+		void 0
+	], [
+		"invalid input rejects with the kind invalid-input, as a TypeError",
+		"fixture.echo",
+		{ text: 1 },
+		"invalid-input",
+		"TypeError"
+	]]) await checks.run(name, `${RULE}#tools`, async () => {
+		const call = await driver.call(capability, input);
+		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("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");
+	});
+	return checks;
+}
+//#endregion
+export { browserDriver, checkWebMcp, createTestHost, processDriver };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/** The library of `@acid-cat/cli`: catalog checks, and the conformance tests. */
+export { bundle, check, viewOf } from "./catalog.js";
+export type { Catalog, Report } from "./catalog.js";
+export { conform, fixture, serve } from "./conform/index.js";
+export type { Check, ConformOptions, Served, WebHandler } from "./conform/index.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+import { bundle, check, viewOf } from "./catalog.js";
+import { fixture } from "./conform/check.js";
+import { serve } from "./conform/serve.js";
+import { conform } from "./conform/index.js";
+export { bundle, check, conform, fixture, serve, viewOf };