@acid-cat/cli 0.3.1 → 0.5.0

package/README.md

@@ -6,7 +6,7 @@ The AcidCat command line. npm package: `@acid-cat/cli`. It gives the `acid-cat`
 acid-cat check [--strict] <catalog.json ...>  # check catalogs
 acid-cat format [--write] <catalog.json ...>  # write catalogs in canonical form
 acid-cat view <catalog.json> <target>         # write the view of one target
-acid-cat conform --mcp <url> --http <url> --cli "<command>" --webmcp <url>  # test an implementation
+acid-cat conform --mcp <url> --http <url> --cli "<command>" --webmcp <url> [--deadline <ms>]  # test an implementation
 ```
 
 Install it as a development dependency, and run it with `pnpm exec acid-cat …`:
@@ -35,10 +35,12 @@ The exit code is 0 if there are no errors. It is 1 if there are errors. With `--
 `conform` tests a running implementation of the [conformance fixture](conformance/fixture.pkl) through its bindings (see [Conformance](../../spec/conformance.md#acid-cat-conform)):
 
 - **MCP:** the official MCP client, with revision `2026-07-28`, for tools and outcomes; raw requests for rejections.
-- **HTTP** and **CLI:** each outcome, each kind of call failure, availability, and rejections. For the CLI, an interrupt (`SIGINT`) during a call gives exit code 130.
+- **HTTP** and **CLI:** each outcome, each kind of call failure, availability, and rejections. For the CLI, an interrupt (`SIGINT`) during a call that holds gives exit code 130.
 - **WebMCP:** the checks act as the WebMCP host. `--webmcp <url>` opens a page that serves the `app` target in Chromium, through [Playwright](https://playwright.dev), with a test `modelContext`. Install Playwright to use it: `pnpm add -D playwright`, then `pnpm exec playwright install chromium`. In code, `webmcp` can also be a function that installs the implementation on a host in the same process.
 - **Properties:** with fast-check, through each remote binding: concurrent calls each get exactly their own outcome, and a cancellation changes only its own call.
 
+The checks wait for states that they can observe, not for times. Before a check cancels a call to `fixture.hold`, it waits until `fixture.held` gives the key of the call, or, for the CLI, until the marker file of the call exists. Each check has one deadline: `--deadline`, or `deadline` in code, in milliseconds. The default is 30 000. A check that does not settle before its deadline fails with "did not settle", and the check stops what it started. This cleanup has a deadline of the same length, so `conform` always returns. The deadline never makes a check pass.
+
 The exit code is 1 if a check fails. Both AcidCat cores run `conform` in their tests. In code, use `conform()` and `serve()` from `@acid-cat/cli`. `createTestHost()` gives the WebMCP host of the checks.
 
 ## Implementation
@@ -52,5 +54,6 @@ The command line is an [Effect](https://effect.website) program that uses `effec
 | `src/conform/` | The conformance checks, and `serve`, which serves web handlers on a local port |
 | `conformance/` | The conformance fixture, in Pkl and in JSON |
 | `test/` | Tests. Run them with `moon run cli:test` |
+| `test/fixtures/` | The catalog of the tests: a bakery, in canonical form |
 
 The canonical writer comes from [`@acid-cat/catalog`](../catalog/typescript).

package/conformance/fixture.acidcat.json

@@ -133,12 +133,70 @@
         "type": "object"
       }
     },
+    "fixture.held": {
+      "description": "Return the keys of the calls to fixture.hold that hold now.",
+      "audience": [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      "output": {
+        "properties": {
+          "keys": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "keys"
+        ],
+        "type": "object"
+      },
+      "readOnly": true
+    },
     "fixture.hidden": {
       "description": "Only the app target can use this capability.",
       "audience": [
         "app"
       ]
     },
+    "fixture.hold": {
+      "description": "Hold until fixture.release releases the key, then return the key. While the call holds, fixture.held gives the key. With a marker, the call writes a file at that path when it starts to hold.",
+      "audience": [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      "input": {
+        "properties": {
+          "key": {
+            "type": "string"
+          },
+          "marker": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "key"
+        ],
+        "type": "object"
+      },
+      "output": {
+        "properties": {
+          "key": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "key"
+        ],
+        "type": "object"
+      }
+    },
     "fixture.refuse": {
       "description": "Always return the failure Refused.",
       "audience": [
@@ -166,8 +224,8 @@
         }
       }
     },
-    "fixture.slow": {
-      "description": "Wait for some milliseconds, then return null.",
+    "fixture.release": {
+      "description": "Release the calls to fixture.hold that hold the key.",
       "audience": [
         "app",
         "mcp",
@@ -176,12 +234,12 @@
       ],
       "input": {
         "properties": {
-          "milliseconds": {
-            "type": "number"
+          "key": {
+            "type": "string"
           }
         },
         "required": [
-          "milliseconds"
+          "key"
         ],
         "type": "object"
       }

package/dist/catalog.d.ts

@@ -7,5 +7,10 @@ export interface Report {
     readonly errors: readonly string[];
     readonly warnings: readonly string[];
 }
+/**
+ * True if the value has the members and the member types of a catalog. It does not check the catalog rules: `check`
+ * does that.
+ */
+export declare const isCatalog: (value: unknown) => value is Catalog;
 /** Check a catalog. When `text` is given, the file must also be in canonical form. */
 export declare function check(document: unknown, text?: string): Report;

package/dist/catalog.js

@@ -1,4 +1,5 @@
 import catalog_schema_default from "./json/catalog.schema.json.js";
+import { isObject, isRecordOf, isStringArray } from "./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";
@@ -34,13 +35,24 @@ const KNOWN_MEMBERS = {
 /** 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 definitions = $defs;
 	const schema = SchemaRepresentation.fromJsonSchemaDocument({
 		dialect: "draft-2020-12",
 		schema: root,
-		definitions: $defs ?? {}
+		definitions
 	}, { patterns: "apply" });
-	return Schema.decodeUnknownResult(schema);
+	return Schema.decodeUnknownResult(Schema.toType(schema));
 })();
+/** True if `key` is absent from the object, or if `isMember` is true for its value. */
+const optional = (object, key, isMember) => !(key in object) || isMember(object[key]);
+const isString = (value) => typeof value === "string";
+const isTarget = (value) => isObject(value) && isStringArray(value.bindings);
+const isCapability = (value) => isObject(value) && typeof value.description === "string" && optional(value, "audience", isStringArray) && optional(value, "input", isObject) && optional(value, "output", isObject) && optional(value, "state", isObject) && optional(value, "failures", (failures) => isRecordOf(failures, isObject)) && optional(value, "readOnly", (readOnly) => typeof readOnly === "boolean");
+/**
+* True if the value has the members and the member types of a catalog. It does not check the catalog rules: `check`
+* does that.
+*/
+const isCatalog = (value) => isObject(value) && typeof value.acidcat === "string" && optional(value, "title", isString) && optional(value, "description", isString) && isRecordOf(value.targets, isTarget) && optional(value, "$defs", (types) => isRecordOf(types, isObject)) && isRecordOf(value.capabilities, isCapability);
 const formatIssues = SchemaIssue.makeFormatterStandardSchemaV1();
 /** Check a catalog. When `text` is given, the file must also be in canonical form. */
 function check(document, text) {
@@ -49,6 +61,10 @@ function check(document, text) {
 		errors: formatIssues(decoded.failure.issue).issues.map((issue) => `${(issue.path ?? []).map((key) => `[${JSON.stringify(key)}]`).join("") || "the catalog"}: ${issue.message}`),
 		warnings: []
 	};
+	if (!isCatalog(document)) return {
+		errors: ["the catalog: the members do not have the types of a catalog"],
+		warnings: []
+	};
 	const catalog = document;
 	const errors = ruleErrors(catalog);
 	const warnings = [...unknownMembers(catalog), ...errors.length === 0 ? schemaWarnings(catalog) : []];
@@ -103,9 +119,12 @@ function referenceErrors(schema, types) {
 		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`);
+		if (name === void 0 || !(name in types)) {
+			const reference = typeof node.$ref === "string" ? node.$ref : JSON.stringify(node.$ref);
+			errors.push(`references ${reference}, which is not a type`);
+		}
 	});
 	return errors;
 }
 //#endregion
-export { bundle, check, viewOf$1 as viewOf };
+export { bundle, check, isCatalog, viewOf$1 as viewOf };

package/dist/conform/check.d.ts

@@ -1,4 +1,4 @@
-import type { CatalogDocument } from "@acid-cat/spec-ts";
+import type { CatalogDocument, Outcome } from "@acid-cat/spec-ts";
 export interface Check {
     readonly binding: string;
     readonly name: string;
@@ -9,15 +9,35 @@ export interface Check {
 }
 /** The conformance fixture: the catalog that each implementation serves. */
 export declare const fixture: CatalogDocument;
+/**
+ * True if the value is an outcome (spec/invocation.md): `{ ok: true, value }`, `{ ok: false, error }`, or a call
+ * failure `{ kind, message }` with no `ok`.
+ */
+export declare const isOutcome: (value: unknown) => value is Outcome<unknown, unknown>;
 /** The ids of the capabilities in the view of a target of the fixture. */
 export declare const idsOf: (target: string) => string[];
-/** Collects checks for one binding. */
+/** The time, in milliseconds, that each check has to settle when `conform` gets no other time. */
+export declare const DEADLINE = 30000;
+/**
+ * Collects checks for one binding. Each check has one deadline. The check gives its signal to each operation, and the
+ * signal aborts at the deadline. Then each operation stops, and the check fails with "did not settle". The deadline
+ * never makes a check pass. The cleanup of a check, which releases what the check holds, gets its own signal with the
+ * same time, so that `conform` always returns.
+ */
 export declare class Checks {
     readonly results: Check[];
     readonly binding: string;
-    constructor(binding: string);
-    run(name: string, rule: string, body: () => Promise<void> | void): Promise<void>;
+    readonly deadline: number;
+    constructor(binding: string, deadline: number);
+    run(name: string, rule: string, body: (signal: AbortSignal) => Promise<void> | void): Promise<void>;
 }
+/**
+ * Read a state until `done` is true for it, and give that value. The read and the pause between two reads stop when the
+ * signal of the check aborts.
+ */
+export declare function until<T>(what: string, read: () => Promise<T>, done: (value: T) => boolean, signal: AbortSignal): Promise<T>;
+/** Settle as the promise does, or reject with the reason of the signal when it aborts first. */
+export declare function abortable<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
 /** Fail a check unless `condition` is true. */
 export declare function expect(condition: unknown, message: string): asserts condition;
 /** Fail a check unless the two values have the same JSON. */

package/dist/conform/check.js

@@ -1,21 +1,44 @@
+import { isObject } from "../json.js";
 import fixture_acidcat_default from "../json/fixture.acidcat.json.js";
-import { viewOf } from "@acid-cat/spec-ts";
+import { CALL_FAILURE_KINDS, viewOf } from "@acid-cat/spec-ts";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#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;
+/**
+* True if the value is an outcome (spec/invocation.md): `{ ok: true, value }`, `{ ok: false, error }`, or a call
+* failure `{ kind, message }` with no `ok`.
+*/
+const isOutcome = (value) => {
+	if (!isObject(value)) return false;
+	if (value.ok === true) return "value" in value;
+	if (value.ok === false) return "error" in value;
+	return !("ok" in value) && CALL_FAILURE_KINDS.some((kind) => kind === value.kind) && typeof value.message === "string";
+};
 /** 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. */
+/** The time, in milliseconds, that each check has to settle when `conform` gets no other time. */
+const DEADLINE = 3e4;
+/**
+* Collects checks for one binding. Each check has one deadline. The check gives its signal to each operation, and the
+* signal aborts at the deadline. Then each operation stops, and the check fails with "did not settle". The deadline
+* never makes a check pass. The cleanup of a check, which releases what the check holds, gets its own signal with the
+* same time, so that `conform` always returns.
+*/
 var Checks = class {
 	results = [];
 	binding;
-	constructor(binding) {
+	deadline;
+	constructor(binding, deadline) {
 		this.binding = binding;
+		this.deadline = deadline;
 	}
 	async run(name, rule, body) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.deadline);
 		try {
-			await body();
+			await body(controller.signal);
 			this.results.push({
 				binding: this.binding,
 				name,
@@ -23,16 +46,44 @@ var Checks = class {
 				passed: true
 			});
 		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const detail = controller.signal.aborted ? `did not settle within ${this.deadline} ms: ${message}` : message;
 			this.results.push({
 				binding: this.binding,
 				name,
 				rule,
 				passed: false,
-				detail: error instanceof Error ? error.message : String(error)
+				detail
 			});
+		} finally {
+			clearTimeout(timer);
 		}
 	}
 };
+/**
+* Read a state until `done` is true for it, and give that value. The read and the pause between two reads stop when the
+* signal of the check aborts.
+*/
+async function until(what, read, done, signal) {
+	let last;
+	try {
+		for (;;) {
+			last = await read();
+			if (done(last)) return last;
+			await setTimeout$1(10, void 0, { signal });
+		}
+	} catch (error) {
+		throw signal.aborted ? /* @__PURE__ */ new Error(`waiting until ${what}; the last value was ${JSON.stringify(last)}`) : error;
+	}
+}
+/** Settle as the promise does, or reject with the reason of the signal when it aborts first. */
+function abortable(promise, signal) {
+	const aborted = new Promise((_, reject) => {
+		signal.throwIfAborted();
+		signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+	});
+	return Promise.race([promise, aborted]);
+}
 /** Fail a check unless `condition` is true. */
 function expect(condition, message) {
 	if (!condition) throw new Error(message);
@@ -48,4 +99,4 @@ 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 };
+export { Checks, DEADLINE, FORBIDDEN_ORIGIN, abortable, expect, expectEqual, fixture, idsOf, isOutcome, sorted, until };

package/dist/conform/cli.d.ts

@@ -1,2 +1,4 @@
 import { Checks } from "./check.js";
-export declare function checkCli(command: readonly string[]): Promise<Checks>;
+export declare function checkCli(command: readonly string[], options: {
+    readonly deadline: number;
+}): Promise<Checks>;

package/dist/conform/cli.js

@@ -1,5 +1,10 @@
-import { Checks, expect, expectEqual, idsOf, sorted } from "./check.js";
+import { isArrayOf, isObject, memberOf, parseJson } from "../json.js";
+import { Checks, expect, expectEqual, idsOf, sorted, until } from "./check.js";
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 //#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";
@@ -8,53 +13,71 @@ const USAGES = {
 	"fixture.crash": "fixture crash",
 	"fixture.echo": "fixture echo --text <string>",
 	"fixture.flags": "fixture flags --mode <fast|slow> [--count <integer>] [--extra <json>] [--label <string>] [--ratio <number>] [--verbose]",
+	"fixture.held": "fixture held",
+	"fixture.hold": "fixture hold --key <string> [--marker <string>]",
 	"fixture.refuse": "fixture refuse",
-	"fixture.slow": "fixture slow --milliseconds <number>",
+	"fixture.release": "fixture release --key <string>",
 	"fixture.switch.set": "fixture switch set --on",
 	"fixture.toggle": "fixture toggle"
 };
-/** 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: [
+const isEntry = (value) => isObject(value) && typeof value.id === "string";
+/** The list that the `list` command writes to standard output. The check fails when it is not a list of entries. */
+function entriesOf(stdout) {
+	const list = parseJson(stdout);
+	if (!isArrayOf(list, isEntry)) throw new Error(`list must give a list of objects with an id, got ${JSON.stringify(list)}`);
+	return list;
+}
+/**
+* Start the command line. When the signal aborts, the process is killed, and its run rejects. The rejection is observed
+* here too, so that a check that stops waiting first, for example at the deadline, records a failure and does not end
+* the process with an unhandled rejection.
+*/
+function start(command, args, signal) {
+	const [program, ...programArgs] = command;
+	if (program === void 0) throw new Error("the command that starts the command line is empty");
+	const child = spawn(program, [...programArgs, ...args], {
+		stdio: [
 			"ignore",
 			"pipe",
 			"pipe"
-		] });
-		const timer = interruptAfter === void 0 ? void 0 : setTimeout(() => child.kill("SIGINT"), interruptAfter);
+		],
+		signal,
+		killSignal: "SIGKILL"
+	});
+	const run = new Promise((resolve, reject) => {
 		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
-			});
-		});
+		child.on("error", (error) => reject(signal.aborted ? /* @__PURE__ */ new Error(`waiting until the command line exits: ${args.join(" ")}`) : error));
+		child.on("close", (code, exitSignal) => resolve({
+			code,
+			signal: exitSignal,
+			stdout,
+			stderr
+		}));
 	});
+	run.catch(() => void 0);
+	return {
+		child,
+		run
+	};
 }
-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");
+async function checkCli(command, options) {
+	const checks = new Checks("cli", options.deadline);
+	const run = (signal, ...args) => start(command, args, signal).run;
+	await checks.run("a value goes to standard output with exit code 0", `${RULE}#outcomes`, async (signal) => {
+		const result = await run(signal, "fixture", "echo", "--text", "hello");
 		expectEqual(result.code, 0, "exit code");
-		expectEqual(JSON.parse(result.stdout), { text: "hello" }, "standard output");
+		expectEqual(parseJson(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");
+	await checks.run("a failure goes to standard output with exit code 1", `${RULE}#outcomes`, async (signal) => {
+		const result = await run(signal, "fixture", "refuse");
 		expectEqual(result.code, 1, "exit code");
-		expectEqual(JSON.parse(result.stdout)._tag, "Refused", "_tag");
+		expectEqual(memberOf(parseJson(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");
+	await checks.run("a defect goes to standard error with exit code 5", `${RULE}#outcomes`, async (signal) => {
+		const result = await run(signal, "fixture", "crash");
 		expectEqual(result.code, 5, "exit code");
 		expect(/"kind":"internal"/.test(result.stderr), "standard error must contain the call failure");
 	});
@@ -78,8 +101,10 @@ async function checkCli(command) {
 			"a flag that is not valid has exit code 3",
 			[
 				"fixture",
-				"slow",
-				"--milliseconds",
+				"flags",
+				"--mode",
+				"fast",
+				"--ratio",
 				"soon"
 			],
 			3
@@ -93,31 +118,47 @@ async function checkCli(command) {
 			],
 			3
 		]
-	]) await checks.run(name, `${RULE}#outcomes`, async () => {
-		expectEqual((await cli(...args)).code, code, "exit code");
+	]) await checks.run(name, `${RULE}#outcomes`, async (signal) => {
+		expectEqual((await run(signal, ...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("an interrupt cancels the call with exit code 130", `${RULE}#commands`, async (signal) => {
+		const directory = await mkdtemp(join(tmpdir(), "acid-cat-conform-"));
+		const marker = join(directory, "held");
+		try {
+			const { child, run } = start(command, [
+				"fixture",
+				"hold",
+				"--key",
+				"interrupt",
+				"--marker",
+				marker
+			], signal);
+			const ended = () => child.exitCode !== null || child.signalCode !== null;
+			await until("the call writes its marker file", async () => existsSync(marker) || ended(), (ready) => ready, signal);
+			if (!ended()) child.kill("SIGINT");
+			const result = await run;
+			expect(existsSync(marker), `the call must hold before the interrupt, but the command line ended with ${result.code}: ${result.stderr}`);
+			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");
+		} finally {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			});
+		}
 	});
-	await checks.run("call gives the value of a capability", `${RULE}#commands`, async () => {
-		const result = await cli("call", "fixture.echo", "{\"text\":\"hello\"}");
+	await checks.run("call gives the value of a capability", `${RULE}#commands`, async (signal) => {
+		const result = await run(signal, "call", "fixture.echo", "{\"text\":\"hello\"}");
 		expectEqual(result.code, 0, "exit code");
-		expectEqual(JSON.parse(result.stdout), { text: "hello" }, "standard output");
+		expectEqual(parseJson(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");
+	await checks.run("list gives the view", `${RULE}#commands`, async (signal) => {
+		const result = await run(signal, "list");
+		expectEqual(sorted(entriesOf(result.stdout).map((entry) => entry.id)), idsOf("cli"), "ids");
 	});
-	await checks.run("list gives the usage of each capability, with its flags", `${RULE}#commands`, async () => {
-		const entries = JSON.parse((await cli("list")).stdout);
+	await checks.run("list gives the usage of each capability, with its flags", `${RULE}#commands`, async (signal) => {
+		const entries = entriesOf((await run(signal, "list")).stdout);
 		for (const { id, usage } of entries) {
 			expect(typeof usage === "string", `${id} must have a usage`);
 			const [program, ...rest] = usage.split(" ");

package/dist/conform/http.d.ts

@@ -1,5 +1,5 @@
-/** Conformance checks for the HTTP binding (spec/bindings/http.md). */
 import { Checks } from "./check.js";
 export declare function checkHttp(base: string, options: {
     readonly maximumBytes: number;
+    readonly deadline: number;
 }): Promise<Checks>;