@acid-cat/cli 0.8.0 → 0.10.0

package/dist/conform/mcp.js

@@ -1,18 +1,24 @@
-import { isObject, memberOf, parseJson, readJson } from "../json.js";
-import { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, fixture, idsOf, sorted } from "./check.js";
+import { isArrayOf, isObject, isStringArray, memberOf, parseJson, readJson } from "../json.js";
+import { Checks, FORBIDDEN_ORIGIN, eventIdsOf, expect, expectEqual, expectOccurrence, fixture, idsOf, sorted, until } from "./check.js";
+import { sseReader } from "./sse.js";
+import { checkPoll } from "./poll.js";
+import { checkWebhook } from "./webhook.js";
+import { MCP_EVENTS_EXTENSION, MCP_SUBSCRIPTION_ID } from "@acid-cat/spec-ts";
+import { randomUUID } from "node:crypto";
 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.
+* Conformance checks for the MCP binding through HTTP (spec/bindings/mcp.md). The protocol checks use the official MCP
+* client with revision 2026-07-28. With `handshake`, they run again with the `initialize` handshake of revision
+* 2025-11-25. The other checks send requests that a client never sends.
 */
 const RULE = "spec/bindings/mcp.md";
-/** A connected MCP client. */
-async function mcpClient(url, signal) {
+/** A connected MCP client. With `handshake`, the client opens the session with `initialize`. */
+async function mcpClient(url, signal, handshake = false) {
 	const client = new Client({
 		name: "acid-cat-conform",
 		version: "0.1.0"
-	}, { versionNegotiation: { mode: { pin: "2026-07-28" } } });
+	}, handshake ? { versionNegotiation: { mode: "legacy" } } : { versionNegotiation: { mode: { pin: "2026-07-28" } } });
 	await client.connect(new StreamableHTTPClientTransport(new URL(url)), signal ? { signal } : void 0);
 	return client;
 }
@@ -24,16 +30,126 @@ const textOf = (result) => {
 async function checkMcp(url, options) {
 	const checks = new Checks("mcp", options.deadline);
 	let client;
-	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#server`, async (signal) => {
+	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#http`, async (signal) => {
 		client = await mcpClient(url, signal);
 	});
 	if (client === void 0) return checks;
 	const mcp = client;
+	await checkTools(checks, mcp);
+	await mcp.close();
+	const post = (signal, { headers = {}, body }) => fetch(url, {
+		method: "POST",
+		body,
+		headers: {
+			"Content-Type": "application/json",
+			...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(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}#http`, 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}#http`, 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}#http`, 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}#http`, 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}#http`, 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}#http`, async (signal) => {
+		await rejection(await post(signal, { body: new Uint8Array([
+			123,
+			255,
+			125
+		]) }), 400);
+	});
+	await checkEvents(checks, httpChannel(url), {
+		transport: "http",
+		poll: options.poll,
+		webhook: options.webhook !== void 0
+	});
+	if (options.webhook !== void 0) await checkWebhook(checks, url, options.webhook);
+	if (options.handshake) await checkHandshake(checks, url, options.deadline);
+	return checks;
+}
+const ANCHOR = `${RULE}#earlier-revisions-through-http`;
+/** The checks of the `initialize` handshake of revision 2025-11-25 (spec/bindings/mcp.md#earlier-revisions-through-http). */
+async function checkHandshake(checks, url, deadline) {
+	const handshakeChecks = new Checks("mcp 2025-11-25", deadline);
+	let client;
+	await handshakeChecks.run("an MCP client connects with the initialize handshake of revision 2025-11-25", ANCHOR, async (signal) => {
+		client = await mcpClient(url, signal, true);
+		expectEqual(client.getNegotiatedProtocolVersion(), "2025-11-25", "the revision of the session");
+	});
+	if (client !== void 0) {
+		await checkTools(handshakeChecks, client);
+		await client.close();
+	}
+	const rpc = (signal, message, version) => fetch(url, {
+		method: "POST",
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			...message
+		}),
+		headers: {
+			"Content-Type": "application/json",
+			...version === void 0 ? {} : { "MCP-Protocol-Version": version }
+		},
+		signal
+	});
+	await handshakeChecks.run("initialize gives the revision of the client, and the server keeps no session", ANCHOR, async (signal) => {
+		const response = await rpc(signal, {
+			id: 1,
+			method: "initialize",
+			params: {
+				protocolVersion: "2025-11-25",
+				capabilities: {},
+				clientInfo: {
+					name: "acid-cat-conform",
+					version: "0.1.0"
+				}
+			}
+		});
+		expectEqual(response.status, 200, "status");
+		expectEqual(response.headers.get("Mcp-Session-Id"), null, "Mcp-Session-Id");
+		const result = memberOf(await readJson(response), "result");
+		expectEqual(memberOf(result, "protocolVersion"), "2025-11-25", "protocolVersion");
+		const extensions = memberOf(memberOf(result, "capabilities"), "extensions");
+		expect(memberOf(extensions, MCP_EVENTS_EXTENSION) === void 0, `the capabilities of initialize must not have the events extension, got ${JSON.stringify(extensions)}`);
+	});
+	await handshakeChecks.run("a notification of a revision with a handshake gets 202", ANCHOR, async (signal) => {
+		expectEqual((await rpc(signal, { method: "notifications/initialized" }, "2025-11-25")).status, 202, "status");
+	});
+	checks.results.push(...handshakeChecks.results);
+}
+/**
+* The checks of the tools and their outcomes, through a connected client (spec/bindings/mcp.md#tools). Each transport
+* runs them.
+*/
+async function checkTools(checks, mcp) {
 	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`, () => {
+	await checks.run("the instructions are the description of the catalog", `${RULE}#server`, () => {
 		expectEqual(mcp.getInstructions(), fixture.description, "instructions");
 	});
 	await checks.run("tools/list gives each available capability of the view", `${RULE}#tools`, async (signal) => {
@@ -84,55 +200,407 @@ async function checkMcp(url, options) {
 			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(AbortSignal.timeout(options.deadline), "fixture.switch.set", { on: true });
+			await call(AbortSignal.timeout(checks.deadline), "fixture.switch.set", { on: true });
 		}
 	});
-	await mcp.close();
-	const post = (signal, { headers = {}, body }) => fetch(url, {
+}
+/** The revision of the protocol that serves the events extension. */
+const EVENTS_REVISION = "2026-07-28";
+/** The `_meta` of each request of revision 2026-07-28: the revision, and the capabilities of the client, which has none. */
+const META = {
+	"io.modelcontextprotocol/protocolVersion": EVENTS_REVISION,
+	"io.modelcontextprotocol/clientCapabilities": {}
+};
+/** A channel to a server through HTTP. Each request has the `headers` too, for example the credentials of a principal. */
+function httpChannel(url, headers = {}) {
+	const post = (id, method, params, signal) => fetch(url, {
 		method: "POST",
-		body,
 		headers: {
+			...headers,
 			"Content-Type": "application/json",
-			...headers
+			Accept: "application/json, text/event-stream",
+			"Mcp-Method": method,
+			"MCP-Protocol-Version": EVENTS_REVISION,
+			...typeof params.name === "string" ? { "Mcp-Name": params.name } : {}
 		},
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params: {
+				...params,
+				_meta: META
+			}
+		}),
 		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(memberOf(memberOf(await readJson(response), "error"), "code"), code, "JSON-RPC error code");
+	/** The messages of a response: one JSON message, or a stream of server-sent events with one message in each. */
+	const messagesOf = (response, close) => {
+		if (response.headers.get("Content-Type")?.startsWith("text/event-stream") !== true) {
+			let read = false;
+			return {
+				next: async () => {
+					if (read) return void 0;
+					read = true;
+					const message = await readJson(response);
+					expect(isObject(message), `expected a JSON-RPC message, got ${JSON.stringify(message)}`);
+					return message;
+				},
+				cancel: async () => close()
+			};
+		}
+		const reader = sseReader(response);
+		return {
+			next: async () => {
+				const event = await reader.next();
+				if (event === void 0) return void 0;
+				const message = parseJson(event.data);
+				expect(isObject(message), `each server-sent event must hold one JSON-RPC message, got ${JSON.stringify(event.data)}`);
+				return message;
+			},
+			cancel: async () => close()
+		};
 	};
-	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");
+	let next = 0;
+	return {
+		async request(method, params, signal) {
+			const response = await post(`conform-${next += 1}`, method, params, signal);
+			const message = await messagesOf(response, () => void 0).next();
+			if (message === void 0) throw new Error(`the response to ${method} has no message`);
+			return message;
+		},
+		async stream(id, params, signal) {
+			const controller = new AbortController();
+			const response = await post(id, "events/stream", params, AbortSignal.any([signal, controller.signal]));
+			return messagesOf(response, () => controller.abort());
+		}
+	};
+}
+/** The subscription id in the `_meta` of the params of a notification, or of a result. */
+const subscriptionOf = (message) => memberOf(memberOf(memberOf(message, "params") ?? memberOf(message, "result"), "_meta"), MCP_SUBSCRIPTION_ID);
+/** The params of a notification of a subscription, without `_meta`. */
+const paramsOf = (message) => {
+	const params = memberOf(message, "params");
+	expect(isObject(params), `expected a notification with params, got ${JSON.stringify(message)}`);
+	const { _meta: _, ...rest } = params;
+	return rest;
+};
+/** The order of the delivery modes in `events/list` (spec/bindings/mcp.md#events). */
+const DELIVERY_ORDER = [
+	"push",
+	"poll",
+	"webhook"
+];
+/** The requests that the checks of events send through a channel, and the capabilities of the fixture that they call. */
+function eventRequests(channel) {
+	const resultOf = async (method, params, signal) => {
+		const message = await channel.request(method, params, signal);
+		const result = memberOf(message, "result");
+		expect(isObject(result), `${method} must give a result, got ${JSON.stringify(message)}`);
+		return result;
+	};
+	const errorOf = (message) => {
+		const error = memberOf(message, "error");
+		expect(isObject(error), `expected a JSON-RPC error, got ${JSON.stringify(message)}`);
+		return error;
+	};
+	const tool = async (name, args, signal) => memberOf(await resultOf("tools/call", {
+		name,
+		arguments: args
+	}, signal), "structuredContent");
+	/** The keys of the subscriptions to `fixture.watch` that are active now. */
+	const watching = async (signal) => {
+		const keys = memberOf(await tool("fixture.watching", {}, signal), "keys");
+		expect(isStringArray(keys), `fixture.watching must give a list of keys, got ${JSON.stringify(keys)}`);
+		return keys;
+	};
+	/** Give a value to the subscriptions to `fixture.watch` that watch the key. The result is the number of these subscriptions. */
+	const signalKey = async (key, value, signal) => memberOf(await tool("fixture.signal", {
+		key,
+		value
+	}, signal), "delivered");
+	return {
+		resultOf,
+		errorOf,
+		tool,
+		watching,
+		signalKey
+	};
+}
+/** The number of times that a key is in a list of keys. */
+const count = (keys, key) => keys.filter((each) => each === key).length;
+/**
+* The checks of the events extension (spec/bindings/mcp.md#events), through a channel. Each transport runs them. Through
+* stdio, `cancel` sends `notifications/cancelled`; through HTTP, it closes the request.
+*/
+async function checkEvents(checks, channel, options) {
+	const RULE_EVENTS = `${RULE}#events`;
+	const { resultOf, errorOf, watching, signalKey } = eventRequests(channel);
+	/** The next message of a stream, which must be a notification of the method for this subscription. */
+	const notification = async (stream, id, method) => {
+		const message = await stream.next();
+		expect(message !== void 0 && message.method === method, `expected ${method}, got ${JSON.stringify(message)}`);
+		expectEqual(subscriptionOf(message), id, `the subscription id of ${method}`);
+		return message;
+	};
+	const occurrence = async (stream, id, name) => expectOccurrence(paramsOf(await notification(stream, id, "notifications/events/event")), name);
+	const active = async (stream, id) => {
+		const message = await notification(stream, id, "notifications/events/active");
+		expectEqual(paramsOf(message), { truncated: false }, "the params of notifications/events/active");
+	};
+	/** The response of the stream, which must be the result `complete` for this subscription, then the end. */
+	const complete = async (stream, id) => {
+		const message = await stream.next();
+		expect(message !== void 0 && message.id === id, `expected the result of events/stream, got ${JSON.stringify(message)}`);
+		expectEqual(memberOf(memberOf(message, "result"), "resultType"), "complete", "resultType");
+		expectEqual(subscriptionOf(message), id, "the subscription id of the result");
+		expectEqual(await stream.next(), void 0, "the stream after the result");
+	};
+	const streamId = () => `conform-${randomUUID()}`;
+	await checks.run("server/discover declares the events extension", RULE_EVENTS, async (signal) => {
+		const result = await resultOf("server/discover", {}, signal);
+		const extensions = memberOf(memberOf(result, "capabilities"), "extensions");
+		expect(isObject(memberOf(extensions, MCP_EVENTS_EXTENSION)), `the capabilities must have the extension ${MCP_EVENTS_EXTENSION}, got ${JSON.stringify(result)}`);
 	});
-	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);
+	/** The delivery modes that the server serves, from `events/list`. */
+	let delivery = [];
+	await checks.run("events/list gives each event of the view, with the delivery modes of the server and its schemas", RULE_EVENTS, async (signal) => {
+		const result = await resultOf("events/list", {}, signal);
+		const entries = result.events;
+		if (!isArrayOf(entries, isObject)) throw new Error(`events/list must give a list of events, got ${JSON.stringify(result)}`);
+		expectEqual(sorted(entries.map((entry) => String(entry.name))), eventIdsOf("mcp"), "names");
+		const first = entries[0]?.delivery;
+		expect(isStringArray(first), `the delivery of each event must be a list of modes, got ${JSON.stringify(first)}`);
+		expectEqual(first, DELIVERY_ORDER.filter((mode) => first.includes(mode)), "the delivery modes, in the order push, poll, webhook, each once");
+		expect(first.includes("push"), `the server must serve push delivery, got ${JSON.stringify(first)}`);
+		if (options.transport === "stdio") expect(!first.includes("webhook"), "through stdio, the server must not serve webhook delivery");
+		if (options.webhook) expect(first.includes("webhook"), `webhook delivery is on, so the delivery must have webhook, got ${JSON.stringify(first)}`);
+		delivery = first;
+		for (const entry of entries) {
+			const name = String(entry.name);
+			expectEqual(entry.description, fixture.events?.[name]?.description, `description of ${name}`);
+			expectEqual(entry.delivery, first, `delivery of ${name}`);
+			expectEqual(memberOf(entry.inputSchema, "type"), "object", `the type of the inputSchema of ${name}`);
+			expectEqual(memberOf(entry.payloadSchema, "type"), "object", `the type of the payloadSchema of ${name}`);
+		}
+		expectEqual(result.resultType, "complete", "resultType");
+		expect(!("nextCursor" in result), "the result must have no nextCursor");
 	});
-	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);
+	for (const [name, params, code, kind] of [
+		[
+			"events/stream of an event outside the view is NotFound, with the kind event",
+			{
+				name: "fixture.secret",
+				arguments: {}
+			},
+			-32023,
+			"event"
+		],
+		[
+			"events/stream of the id of a capability is NotFound",
+			{
+				name: "fixture.echo",
+				arguments: { text: "x" }
+			},
+			-32023,
+			"event"
+		],
+		[
+			"events/stream with invalid input is the error -32602",
+			{
+				name: "fixture.ticks",
+				arguments: { count: 101 }
+			},
+			-32602,
+			void 0
+		]
+	]) await checks.run(name, RULE_EVENTS, async (signal) => {
+		const stream = await channel.stream(streamId(), params, signal);
+		try {
+			const error = errorOf(await stream.next());
+			expectEqual(error.code, code, "the JSON-RPC error code");
+			if (kind !== void 0) expectEqual(memberOf(error.data, "kind"), kind, "data.kind");
+		} finally {
+			await stream.cancel();
+		}
 	});
-	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("events/stream gives active, each occurrence in order, then the result", RULE_EVENTS, async (signal) => {
+		const id = streamId();
+		const stream = await channel.stream(id, {
+			name: "fixture.ticks",
+			arguments: { count: 3 }
+		}, signal);
+		try {
+			await active(stream, id);
+			for (const n of [
+				1,
+				2,
+				3
+			]) {
+				const each = await occurrence(stream, id, "fixture.ticks");
+				expectEqual(each.data, { n }, "data");
+				expectEqual([each.eventId, each.cursor], [String(n), String(n)], "the eventId and the cursor");
+			}
+			await complete(stream, id);
+		} finally {
+			await stream.cancel();
+		}
 	});
-	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("before an occurrence after a gap, notifications/events/active has truncated: true and its cursor", RULE_EVENTS, async (signal) => {
+		const id = streamId();
+		const stream = await channel.stream(id, {
+			name: "fixture.ticks",
+			arguments: {
+				count: 3,
+				gap: 2
+			}
+		}, signal);
+		try {
+			await active(stream, id);
+			expectEqual((await occurrence(stream, id, "fixture.ticks")).data, { n: 1 }, "data");
+			expectEqual(paramsOf(await notification(stream, id, "notifications/events/active")), {
+				truncated: true,
+				cursor: "2"
+			}, "the params of notifications/events/active before the gap");
+			const after = paramsOf(await notification(stream, id, "notifications/events/event"));
+			expect(!("truncated" in after), `the params of notifications/events/event must have no truncated, got ${JSON.stringify(after)}`);
+			expectEqual(expectOccurrence(after, "fixture.ticks").data, { n: 2 }, "data");
+			expectEqual((await occurrence(stream, id, "fixture.ticks")).data, { n: 3 }, "data");
+			await complete(stream, id);
+		} finally {
+			await stream.cancel();
+		}
 	});
-	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
-		]) }), 400);
+	await checks.run("events/stream with a cursor starts after it", RULE_EVENTS, async (signal) => {
+		const id = streamId();
+		const stream = await channel.stream(id, {
+			name: "fixture.ticks",
+			arguments: { count: 3 },
+			cursor: "1"
+		}, signal);
+		try {
+			await active(stream, id);
+			for (const n of [2, 3]) expectEqual((await occurrence(stream, id, "fixture.ticks")).data, { n }, "data");
+			await complete(stream, id);
+		} finally {
+			await stream.cancel();
+		}
+	});
+	await checks.run("a defect after an occurrence sends notifications/events/terminated, then the result", RULE_EVENTS, async (signal) => {
+		const id = streamId();
+		const stream = await channel.stream(id, {
+			name: "fixture.broken",
+			arguments: {}
+		}, signal);
+		try {
+			await active(stream, id);
+			expectEqual((await occurrence(stream, id, "fixture.broken")).data, { n: 1 }, "data");
+			const terminated = paramsOf(await notification(stream, id, "notifications/events/terminated"));
+			expectEqual(memberOf(terminated.error, "code"), -32603, "the error code of notifications/events/terminated");
+			expect(!/\n\s+at /.test(String(memberOf(terminated.error, "message"))), "the message must not contain a stack trace");
+			await complete(stream, id);
+		} finally {
+			await stream.cancel();
+		}
+	});
+	await checks.run("events/stream gets the things that happen, and cancelling it ends the subscription", RULE_EVENTS, async (signal) => {
+		const key = randomUUID();
+		const id = streamId();
+		const stream = await channel.stream(id, {
+			name: "fixture.watch",
+			arguments: { key }
+		}, signal);
+		try {
+			await active(stream, id);
+			await until("fixture.watching gives the key", () => watching(signal), (keys) => keys.includes(key), signal);
+			expectEqual(await signalKey(key, "first", signal), 1, "the subscriptions that fixture.signal reached");
+			expectEqual((await occurrence(stream, id, "fixture.watch")).data, {
+				key,
+				value: "first"
+			}, "data");
+			await stream.cancel();
+			await until("the key leaves fixture.watching", () => watching(signal), (keys) => !keys.includes(key), signal);
+		} finally {
+			await stream.cancel();
+		}
+	});
+	await checks.run("two subscriptions at the same time each get their own messages, and cancelling one leaves the other", RULE_EVENTS, async (signal) => {
+		const key = randomUUID();
+		const [firstId, secondId] = [streamId(), streamId()];
+		const first = await channel.stream(firstId, {
+			name: "fixture.watch",
+			arguments: { key }
+		}, signal);
+		const second = await channel.stream(secondId, {
+			name: "fixture.watch",
+			arguments: { key }
+		}, signal);
+		try {
+			await active(first, firstId);
+			await active(second, secondId);
+			await until("fixture.watching gives the key of both subscriptions", () => watching(signal), (keys) => count(keys, key) === 2, signal);
+			expectEqual(await signalKey(key, "both", signal), 2, "the subscriptions that fixture.signal reached");
+			expectEqual((await occurrence(first, firstId, "fixture.watch")).data, {
+				key,
+				value: "both"
+			}, "data of the first subscription");
+			expectEqual((await occurrence(second, secondId, "fixture.watch")).data, {
+				key,
+				value: "both"
+			}, "data of the second subscription");
+			await first.cancel();
+			await until("the cancelled subscription leaves fixture.watching", () => watching(signal), (keys) => count(keys, key) === 1, signal);
+			expectEqual(await signalKey(key, "after", signal), 1, "the subscriptions that fixture.signal reached");
+			expectEqual((await occurrence(second, secondId, "fixture.watch")).data, {
+				key,
+				value: "after"
+			}, "data of the second subscription");
+		} finally {
+			await first.cancel();
+			await second.cancel();
+		}
+	});
+	if (delivery.includes("poll")) await checkPoll(checks, channel, options.poll);
+	else {
+		await checks.should("the server serves poll delivery", `${RULE}#events`, () => {
+			throw new Error("events/list gives no poll delivery. A server that keeps no state between requests serves push only.");
+		});
+		await checks.run("events/poll is Unsupported, with the delivery mode poll", RULE_EVENTS, async (signal) => {
+			const error = errorOf(await channel.request("events/poll", {
+				name: "fixture.ticks",
+				arguments: { count: 1 }
+			}, signal));
+			expectEqual(error.code, -32026, "the JSON-RPC error code");
+			expectEqual(error.data, {
+				feature: "deliveryMode",
+				value: "poll"
+			}, "data");
+		});
+	}
+	if (!delivery.includes("webhook")) await checks.run("events/subscribe and events/unsubscribe are Unsupported, with the delivery mode webhook", `${RULE}#webhook`, async (signal) => {
+		const url = "https://webhook.acid-cat.invalid/hook";
+		const subscribe = {
+			name: "fixture.ticks",
+			arguments: { count: 1 },
+			delivery: {
+				mode: "webhook",
+				url,
+				secret: `whsec_${"A".repeat(32)}`
+			}
+		};
+		for (const [method, params] of [["events/subscribe", subscribe], ["events/unsubscribe", {
+			name: "fixture.ticks",
+			arguments: { count: 1 },
+			delivery: { url }
+		}]]) {
+			const error = errorOf(await channel.request(method, params, signal));
+			expectEqual(error.code, -32026, `the JSON-RPC error code of ${method}`);
+			expectEqual(error.data, {
+				feature: "deliveryMode",
+				value: "webhook"
+			}, `the data of ${method}`);
+		}
 	});
-	return checks;
 }
 //#endregion
-export { checkMcp, mcpClient };
+export { EVENTS_REVISION, META, checkEvents, checkMcp, checkTools, count, eventRequests, httpChannel, mcpClient, subscriptionOf };

package/dist/conform/poll.d.ts

@@ -0,0 +1,13 @@
+import { Checks } from "./check.js";
+import type { Channel } from "./mcp.js";
+/**
+ * The poll settings of the deployment that conform tests. Each one is optional. With a setting, conform also tests the
+ * rule that depends on it.
+ */
+export interface PollSettings {
+    /** The number of occurrences that a lease keeps. With it, conform tests the occurrences of a cursor older than the buffer. It must be 97 or less. */
+    readonly bufferLimit?: number | undefined;
+    /** The lease time, in milliseconds. With it, conform tests that a lease with no poll ends. It must be shorter than the deadline. */
+    readonly leaseMs?: number | undefined;
+}
+export declare function checkPoll(checks: Checks, channel: Channel, settings: PollSettings): Promise<void>;