@acid-cat/cli 0.1.0 → 0.2.0

package/dist/catalog.js

@@ -0,0 +1,111 @@
+import catalog_schema_default from "./json/catalog.schema.json.js";
+import { canonicalText } from "@acid-cat/catalog";
+import { REFERENCE, bundle, schemasOf, viewOf as viewOf$1, visitObjects } from "@acid-cat/spec-ts";
+import { Result, Schema, SchemaIssue, SchemaRepresentation } from "effect";
+//#region src/catalog.ts
+/**
+* The catalog operations that the specification defines: the catalog rules, views and bundling.
+* See spec/catalog.md and spec/conformance.md.
+*/
+const KNOWN_MEMBERS = {
+	catalog: [
+		"acidcat",
+		"title",
+		"description",
+		"targets",
+		"$defs",
+		"capabilities"
+	],
+	target: [
+		"bindings",
+		"description",
+		"options"
+	],
+	capability: [
+		"description",
+		"audience",
+		"input",
+		"output",
+		"failures",
+		"readOnly",
+		"state"
+	]
+};
+/** The catalog schema (schemas/catalog.schema.json), imported as an Effect schema. */
+const decodeCatalog = (() => {
+	const { $defs, $schema: _schema, $id: _id, ...root } = catalog_schema_default;
+	const schema = SchemaRepresentation.fromJsonSchemaDocument({
+		dialect: "draft-2020-12",
+		schema: root,
+		definitions: $defs ?? {}
+	}, { patterns: "apply" });
+	return Schema.decodeUnknownResult(schema);
+})();
+const formatIssues = SchemaIssue.makeFormatterStandardSchemaV1();
+/** Check a catalog. When `text` is given, the file must also be in canonical form. */
+function check(document, text) {
+	const decoded = decodeCatalog(document);
+	if (Result.isFailure(decoded)) return {
+		errors: formatIssues(decoded.failure.issue).issues.map((issue) => `${(issue.path ?? []).map((key) => `[${JSON.stringify(key)}]`).join("") || "the catalog"}: ${issue.message}`),
+		warnings: []
+	};
+	const catalog = document;
+	const errors = ruleErrors(catalog);
+	const warnings = [...unknownMembers(catalog), ...errors.length === 0 ? schemaWarnings(catalog) : []];
+	if (text !== void 0 && text !== canonicalText(catalog)) warnings.push("the file is not in canonical form: run `acid-cat format --write`");
+	return {
+		errors,
+		warnings
+	};
+}
+/** The catalog rules that the catalog schema cannot express. */
+function ruleErrors(catalog) {
+	const errors = [];
+	const types = catalog.$defs ?? {};
+	for (const [name, type] of Object.entries(types)) errors.push(...referenceErrors(type, types).map((error) => `type ${name} ${error}`));
+	for (const [id, capability] of Object.entries(catalog.capabilities)) {
+		for (const target of capability.audience ?? []) if (!(target in catalog.targets)) errors.push(`${id}: the audience names ${target}, which is not a target`);
+		for (const [member, schema] of schemasOf(capability)) {
+			const references = referenceErrors(schema, types);
+			errors.push(...references.map((error) => `${id} ${member} ${error}`));
+			if (member === "input" && references.length === 0 && bundle(schema, types).type !== "object") errors.push(`${id}: the input is not an object`);
+		}
+	}
+	return errors;
+}
+/** Members that the specification does not define and that have no `x-` prefix. */
+function unknownMembers(catalog) {
+	const unknown = (where, value, known) => Object.keys(value).filter((key) => !known.includes(key) && !key.startsWith("x-")).map((key) => `${where}: unknown member ${key}; give extensions an x- prefix`);
+	return [
+		...unknown("the catalog", catalog, KNOWN_MEMBERS.catalog),
+		...Object.entries(catalog.targets).flatMap(([name, target]) => unknown(`target ${name}`, target, KNOWN_MEMBERS.target)),
+		...Object.entries(catalog.capabilities).flatMap(([id, capability]) => unknown(id, capability, KNOWN_MEMBERS.capability))
+	];
+}
+/** Schemas that cannot be imported as Effect schemas. They can still be valid JSON Schema, so this is a warning. */
+function schemaWarnings(catalog) {
+	const definitions = catalog.$defs ?? {};
+	const warnings = [];
+	for (const [id, capability] of Object.entries(catalog.capabilities)) for (const [member, schema] of schemasOf(capability)) try {
+		SchemaRepresentation.fromJsonSchemaMultiDocument({
+			dialect: "draft-2020-12",
+			schemas: [schema],
+			definitions
+		}, { patterns: "ignore" });
+	} catch (cause) {
+		warnings.push(`${id} ${member}: cannot check this schema: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	return warnings;
+}
+function referenceErrors(schema, types) {
+	const errors = [];
+	visitObjects(schema, (node) => {
+		if ("$defs" in node) errors.push("has its own $defs; put shared types in the catalog's $defs");
+		if (node.$ref === void 0) return;
+		const name = typeof node.$ref === "string" ? REFERENCE.exec(node.$ref)?.[1] : void 0;
+		if (name === void 0 || !(name in types)) errors.push(`references ${String(node.$ref)}, which is not a type`);
+	});
+	return errors;
+}
+//#endregion
+export { bundle, check, viewOf$1 as viewOf };

package/dist/conform/check.js

@@ -0,0 +1,51 @@
+import fixture_acidcat_default from "../json/fixture.acidcat.json.js";
+import { viewOf } from "@acid-cat/spec-ts";
+//#region src/conform/check.ts
+/** The result of one conformance check, and helpers to write checks. */
+/** The conformance fixture: the catalog that each implementation serves. */
+const fixture = fixture_acidcat_default;
+/** The ids of the capabilities in the view of a target of the fixture. */
+const idsOf = (target) => Object.keys(viewOf(fixture, target).capabilities).sort();
+/** Collects checks for one binding. */
+var Checks = class {
+	results = [];
+	binding;
+	constructor(binding) {
+		this.binding = binding;
+	}
+	async run(name, rule, body) {
+		try {
+			await body();
+			this.results.push({
+				binding: this.binding,
+				name,
+				rule,
+				passed: true
+			});
+		} catch (error) {
+			this.results.push({
+				binding: this.binding,
+				name,
+				rule,
+				passed: false,
+				detail: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+};
+/** Fail a check unless `condition` is true. */
+function expect(condition, message) {
+	if (!condition) throw new Error(message);
+}
+/** Fail a check unless the two values have the same JSON. */
+function expectEqual(actual, expected, what) {
+	const a = JSON.stringify(actual);
+	const b = JSON.stringify(expected);
+	if (a !== b) throw new Error(`${what}: expected ${b}, got ${a}`);
+}
+/** A sorted copy of a list. */
+const sorted = (values) => [...values].sort();
+/** An origin that no deployment allows. */
+const FORBIDDEN_ORIGIN = "https://not-allowed.acid-cat.invalid";
+//#endregion
+export { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, fixture, idsOf, sorted };

package/dist/conform/cli.js

@@ -0,0 +1,112 @@
+import { Checks, expect, expectEqual, idsOf, sorted } from "./check.js";
+import { spawn } from "node:child_process";
+//#region src/conform/cli.ts
+/** Conformance checks for the CLI binding (spec/bindings/cli.md). Each check runs the command line as a process. */
+const RULE = "spec/bindings/cli.md";
+/** The time that a command line has to start before the interrupt, in milliseconds. */
+const INTERRUPT_AFTER = 2e3;
+/** Run the command line. If `interruptAfter` is given, send `SIGINT` after that many milliseconds. */
+function run(command, args, interruptAfter) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command[0], [...command.slice(1), ...args], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		const timer = interruptAfter === void 0 ? void 0 : setTimeout(() => child.kill("SIGINT"), interruptAfter);
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => stdout += chunk.toString());
+		child.stderr.on("data", (chunk) => stderr += chunk.toString());
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			clearTimeout(timer);
+			resolve({
+				code,
+				signal,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+async function checkCli(command) {
+	const checks = new Checks("cli");
+	const cli = (...args) => run(command, args);
+	await checks.run("a value goes to standard output with exit code 0", `${RULE}#outcomes`, async () => {
+		const result = await cli("fixture", "echo", "--text", "hello");
+		expectEqual(result.code, 0, "exit code");
+		expectEqual(JSON.parse(result.stdout), { text: "hello" }, "standard output");
+	});
+	await checks.run("a failure goes to standard output with exit code 1", `${RULE}#outcomes`, async () => {
+		const result = await cli("fixture", "refuse");
+		expectEqual(result.code, 1, "exit code");
+		expectEqual(JSON.parse(result.stdout)._tag, "Refused", "_tag");
+	});
+	await checks.run("a defect goes to standard error with exit code 5", `${RULE}#outcomes`, async () => {
+		const result = await cli("fixture", "crash");
+		expectEqual(result.code, 5, "exit code");
+		expect(/"kind":"internal"/.test(result.stderr), "standard error must contain the call failure");
+	});
+	for (const [name, args, code] of [
+		[
+			"an unknown command has exit code 2",
+			["fixture", "nothing"],
+			2
+		],
+		[
+			"a capability outside the view has exit code 2",
+			["call", "fixture.hidden"],
+			2
+		],
+		[
+			"a missing required flag has exit code 3",
+			["fixture", "echo"],
+			3
+		],
+		[
+			"a flag that is not valid has exit code 3",
+			[
+				"fixture",
+				"slow",
+				"--milliseconds",
+				"soon"
+			],
+			3
+		],
+		[
+			"invalid input through call has exit code 3",
+			[
+				"call",
+				"fixture.echo",
+				"{\"text\":1}"
+			],
+			3
+		]
+	]) await checks.run(name, `${RULE}#outcomes`, async () => {
+		expectEqual((await cli(...args)).code, code, "exit code");
+	});
+	await checks.run("an interrupt cancels the call with exit code 130", `${RULE}#commands`, async () => {
+		const result = await run(command, [
+			"fixture",
+			"slow",
+			"--milliseconds",
+			"60000"
+		], INTERRUPT_AFTER);
+		expect(result.signal === null, `the process must exit, not end by the signal ${result.signal}`);
+		expectEqual(result.code, 130, "exit code");
+		expectEqual(result.stdout, "", "standard output");
+	});
+	await checks.run("call gives the value of a capability", `${RULE}#commands`, async () => {
+		const result = await cli("call", "fixture.echo", "{\"text\":\"hello\"}");
+		expectEqual(result.code, 0, "exit code");
+		expectEqual(JSON.parse(result.stdout), { text: "hello" }, "standard output");
+	});
+	await checks.run("list gives the view", `${RULE}#commands`, async () => {
+		const result = await cli("list");
+		expectEqual(sorted(JSON.parse(result.stdout).map((entry) => entry.id)), idsOf("cli"), "ids");
+	});
+	return checks;
+}
+//#endregion
+export { checkCli };

package/dist/conform/http.js

@@ -0,0 +1,97 @@
+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";
+async function checkHttp(base, options) {
+	const checks = new Checks("http");
+	const post = (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)
+	});
+	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();
+		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" });
+		expectEqual(response.status, 200, "status");
+		expectEqual(await json(response), {
+			ok: true,
+			value: { text: "hello" }
+		}, "body");
+	});
+	await checks.run("a failure has the status 200 and ok: false", `${RULE}#requests`, async () => {
+		const response = await post("fixture.refuse", {});
+		const body = await json(response);
+		expectEqual(response.status, 200, "status");
+		expect(body.ok === false && body.error?._tag === "Refused", `got ${JSON.stringify(body)}`);
+	});
+	for (const [name, id, input, status, kind] of [
+		[
+			"invalid input has the status 422",
+			"fixture.echo",
+			{ text: 1 },
+			422,
+			"invalid-input"
+		],
+		[
+			"a capability outside the view has the status 404",
+			"fixture.hidden",
+			{},
+			404,
+			"unknown-capability"
+		],
+		[
+			"a defect has the status 500",
+			"fixture.crash",
+			{},
+			500,
+			"internal"
+		]
+	]) await checks.run(name, `${RULE}#requests`, async () => {
+		const response = await post(id, input);
+		expectEqual(response.status, status, "status");
+		expectEqual((await json(response)).kind, kind, "kind");
+	});
+	await checks.run("an unavailable capability has the status 503", `${RULE}#requests`, async () => {
+		await post("fixture.switch.set", { on: false });
+		try {
+			const toggle = (await (await fetch(`${base}/capabilities`)).json()).find((entry) => entry.id === "fixture.toggle");
+			expect(toggle?.available === false && typeof toggle.reason === "string", "fixture.toggle must be unavailable, with a reason");
+			const response = await post("fixture.toggle", {});
+			expectEqual(response.status, 503, "status");
+			expectEqual((await json(response)).kind, "unavailable", "kind");
+		} finally {
+			await post("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("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("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 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 that is not UTF-8 is rejected with 400", `${RULE}#requests`, async () => {
+		await status(await post("fixture.echo", new Uint8Array([
+			123,
+			255,
+			125
+		])), 400);
+	});
+	return checks;
+}
+//#endregion
+export { checkHttp };

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.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.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 };