@acid-cat/cli 0.3.1 → 0.5.0

package/dist/conform/serve.js

@@ -23,7 +23,8 @@ function serve(routes) {
 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) {
+	const handler = prefix === void 0 ? void 0 : routes[prefix];
+	if (handler === void 0) {
 		outgoing.writeHead(404).end();
 		return;
 	}
@@ -35,17 +36,19 @@ async function answer(incoming, outgoing, prefixes, routes) {
 	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, {
+	const init = {
 		method: incoming.method ?? "GET",
 		headers,
-		signal: abort.signal,
-		...hasBody ? {
-			body: incoming,
-			duplex: "half"
-		} : {}
+		signal: abort.signal
+	};
+	const withBody = () => ({
+		...init,
+		body: bodyOf(incoming),
+		duplex: "half"
 	});
+	const request = new Request(url, hasBody ? withBody() : init);
 	try {
-		const response = await routes[prefix](request);
+		const response = await handler(request);
 		outgoing.writeHead(response.status, Object.fromEntries(response.headers));
 		if (response.body === null) {
 			outgoing.end();
@@ -58,5 +61,39 @@ async function answer(incoming, outgoing, prefixes, routes) {
 		outgoing.end();
 	}
 }
+/**
+* The body of an incoming request, as a web stream. The stream reads the request only when the handler reads the body,
+* and the request pauses after each chunk until the handler reads again. A request that the handler does not read stays
+* unread, so that Node.js discards it after the response. When the handler cancels the stream, the request discards the
+* rest of its body.
+*/
+function bodyOf(incoming) {
+	let open = true;
+	let reading = false;
+	const close = (end) => {
+		if (open) end();
+		open = false;
+	};
+	return new ReadableStream({
+		pull(controller) {
+			if (!reading) {
+				reading = true;
+				incoming.on("data", (chunk) => {
+					if (!open) return;
+					if (!(chunk instanceof Uint8Array)) return close(() => controller.error(/* @__PURE__ */ new TypeError("a chunk of the request body is not bytes")));
+					controller.enqueue(chunk);
+					incoming.pause();
+				});
+				incoming.on("end", () => close(() => controller.close()));
+				incoming.on("error", (error) => close(() => controller.error(error)));
+			}
+			incoming.resume();
+		},
+		cancel() {
+			open = false;
+			incoming.resume();
+		}
+	}, { highWaterMark: 0 });
+}
 //#endregion
 export { serve };

package/dist/conform/webmcp.d.ts

@@ -5,6 +5,12 @@ export interface RecordedTool {
     readonly description: string;
     readonly inputSchema: unknown;
 }
+/** A tool, as a page gives it to `registerTool`. */
+export interface HostTool extends RecordedTool {
+    execute(input: unknown, options: {
+        readonly signal: AbortSignal;
+    }): Promise<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;
@@ -20,13 +26,15 @@ export type ToolCall = {
 /** The host that the checks give to the page. */
 export interface TestHost {
     readonly modelContext: {
-        registerTool(tool: object, options: {
+        registerTool(tool: HostTool, 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>;
+    /** Call a tool. With an `id`, `cancel` can abort the signal of the call. */
+    call(name: string, input: unknown, id?: string): Promise<ToolCall>;
+    /** Abort the signal of the call that has this `id`, if it runs. */
+    cancel(id: string): void;
 }
 /**
  * Make a test host. The function uses no imports and no outer variables, because the browser driver sends its
@@ -35,8 +43,15 @@ export interface TestHost {
 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>;
+    tools(signal: AbortSignal): Promise<RecordedTool[]>;
+    /**
+     * Call a tool. When `cancel` aborts, the host aborts the signal of the call, and the driver waits for what the tool
+     * gives. When `signal` aborts, the host aborts the signal of the call, and the driver stops waiting.
+     */
+    call(name: string, input: unknown, options?: {
+        readonly signal?: AbortSignal;
+        readonly cancel?: AbortSignal;
+    }): Promise<ToolCall>;
     close(): Promise<void>;
 }
 /**
@@ -48,4 +63,6 @@ export type WebMcpInstall = (modelContext: TestHost["modelContext"]) => void | (
 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>;
+export declare function checkWebMcp(driver: WebMcpDriver, options: {
+    readonly deadline: number;
+}): Promise<Checks>;

package/dist/conform/webmcp.js

@@ -1,4 +1,5 @@
-import { Checks, expect, expectEqual, fixture, idsOf, sorted } from "./check.js";
+import { isArrayOf, isObject, isStringArray, memberOf, parseJson } from "../json.js";
+import { Checks, abortable, expect, expectEqual, fixture, idsOf, sorted, until } from "./check.js";
 import { REFERENCE, visitObjects } from "@acid-cat/spec-ts";
 //#region src/conform/webmcp.ts
 /**
@@ -17,12 +18,12 @@ const TARGET = "app";
 */
 function createTestHost() {
 	const registered = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
 	return {
 		modelContext: { registerTool(tool, options) {
-			const recorded = tool;
-			registered.set(recorded.name, recorded);
+			registered.set(tool.name, tool);
 			options.signal.addEventListener("abort", () => {
-				if (registered.get(recorded.name) === recorded) registered.delete(recorded.name);
+				if (registered.get(tool.name) === tool) registered.delete(tool.name);
 			});
 		} },
 		tools: () => [...registered.values()].map((tool) => ({
@@ -30,36 +31,87 @@ function createTestHost() {
 			description: tool.description,
 			inputSchema: tool.inputSchema
 		})),
-		async call(name, input, cancelAfter) {
+		async call(name, input, id) {
 			const tool = registered.get(name);
 			if (tool === void 0) return { missing: true };
 			const controller = new AbortController();
-			if (cancelAfter !== void 0) setTimeout(() => controller.abort(), cancelAfter);
+			if (id !== void 0) calls.set(id, controller);
 			try {
 				return { resolved: await tool.execute(input, { signal: controller.signal }) };
 			} catch (error) {
-				const { name: errorName, kind, message } = error;
+				const hasMembers = typeof error === "object" && error !== null;
+				const errorName = hasMembers && "name" in error ? error.name : void 0;
+				const kind = hasMembers && "kind" in error ? error.kind : void 0;
+				const message = hasMembers && "message" in error ? error.message : void 0;
 				return { rejected: {
 					name: String(errorName),
 					kind,
 					message: String(message)
 				} };
+			} finally {
+				if (id !== void 0) calls.delete(id);
 			}
+		},
+		cancel(id) {
+			calls.get(id)?.abort();
 		}
 	};
 }
+/** The tools that a host gives, after they pass through JSON. The check fails when the value is not a list of tools. */
+function toolsOf(value) {
+	const isTool = (tool) => isObject(tool) && typeof tool.name === "string" && typeof tool.description === "string";
+	if (!isArrayOf(value, isTool)) throw new Error(`the host must give a list of tools, got ${JSON.stringify(value)}`);
+	return value.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputSchema
+	}));
+}
+/** A tool call that a host gives, after it passes through JSON. The check fails when the value is not a tool call. */
+function toolCallOf(value) {
+	if (isObject(value)) {
+		if (value.missing === true) return { missing: true };
+		if ("resolved" in value) return { resolved: value.resolved };
+		const rejected = value.rejected;
+		if (isObject(rejected) && typeof rejected.name === "string" && typeof rejected.message === "string") return { rejected: {
+			name: rejected.name,
+			kind: rejected.kind,
+			message: rejected.message
+		} };
+	}
+	throw new Error(`the host must give a tool call, got ${JSON.stringify(value)}`);
+}
+let lastCall = 0;
+function driverOf(host) {
+	return {
+		tools: (signal) => abortable(host.tools(), signal),
+		call: (name, input, { signal, cancel } = {}) => {
+			const id = String(++lastCall);
+			const stop = () => void host.cancel(id).catch(() => void 0);
+			signal?.addEventListener("abort", stop, { once: true });
+			cancel?.addEventListener("abort", stop, { once: true });
+			const call = host.call(name, input, id).finally(() => {
+				signal?.removeEventListener("abort", stop);
+				cancel?.removeEventListener("abort", stop);
+			});
+			return signal === void 0 ? call : abortable(call, signal);
+		},
+		close: () => host.close()
+	};
+}
 /** 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)),
+	const copy = (value) => parseJson(JSON.stringify(value));
+	return driverOf({
+		tools: async () => toolsOf(copy(host.tools())),
+		call: async (name, input, id) => toolCallOf(copy(await host.call(name, input, id))),
+		cancel: async (id) => host.cancel(id),
 		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) {
@@ -80,31 +132,22 @@ async function browserDriver(url) {
     }
   `);
 	await page.goto(url);
-	return {
+	const host = (method, ...args) => page.evaluate(`window.__acidCatConform.${method}(${args.map((arg) => JSON.stringify(arg) ?? "undefined").join(", ")})`);
+	return driverOf({
 		tools: async () => {
 			if (errors.length > 0) throw new Error(`The page has errors: ${errors.join("; ")}`);
-			return page.evaluate(() => window.__acidCatConform.tools());
+			return toolsOf(await host("tools"));
+		},
+		call: async (name, input, id) => toolCallOf(await host("call", name, input, id)),
+		cancel: async (id) => {
+			await host("cancel", id);
 		},
-		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 ?? {};
+	const types = isObject(schema.$defs) ? schema.$defs : {};
 	let bundled = true;
 	visitObjects(schema, (node) => {
 		if (typeof node.$ref !== "string") return;
@@ -113,35 +156,45 @@ function isBundled(schema) {
 	});
 	return bundled;
 }
-const names = async (driver) => sorted((await driver.tools()).map((tool) => tool.name));
-async function checkWebMcp(driver) {
-	const checks = new Checks("webmcp");
+const names = async (driver, signal) => sorted((await driver.tools(signal)).map((tool) => tool.name));
+/** The keys of the calls that hold now, as fixture.held gives them through the host. */
+async function heldKeys(driver, signal) {
+	const call = await driver.call("fixture.held", {}, { signal });
+	expect("resolved" in call, `fixture.held gave ${JSON.stringify(call)}`);
+	const keys = memberOf(memberOf(call.resolved, "value"), "keys");
+	expect(isStringArray(keys), `fixture.held gave ${JSON.stringify(call)}, with no list of keys`);
+	return keys;
+}
+async function checkWebMcp(driver, options) {
+	const checks = new Checks("webmcp", options.deadline);
 	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("each available capability of the view is a tool", `${RULE}#tools`, async (signal) => {
+		await until(`the tools are ${expected.join(", ")}`, () => names(driver, signal), (tools) => JSON.stringify(tools) === JSON.stringify(expected), signal);
 	});
-	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()) {
+	await checks.run("a tool has the description and the bundled input schema of its capability", `${RULE}#tools`, async (signal) => {
+		for (const tool of await driver.tools(signal)) {
 			expectEqual(tool.description, view[tool.name]?.description, `description of ${tool.name}`);
 			const schema = tool.inputSchema;
+			expect(isObject(schema), `the input schema of ${tool.name} must be an object`);
 			const input = view[tool.name]?.input ?? {};
+			const required = (object) => isStringArray(object.required) ? object.required : [];
 			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}`);
+			expectEqual(sorted(required(schema)), sorted(required(input)), `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: {
+	await checks.run("a value resolves as a result", `${RULE}#tools`, async (signal) => {
+		expectEqual(await driver.call("fixture.echo", { text: "hello" }, { signal }), { 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", {});
+	await checks.run("a failure resolves as a result", `${RULE}#tools`, async (signal) => {
+		const call = await driver.call("fixture.refuse", {}, { signal });
 		expect("resolved" in call, `the call must resolve, got ${JSON.stringify(call)}`);
-		expectEqual(call.resolved.error?._tag, "Refused", "_tag");
+		expectEqual(memberOf(memberOf(call.resolved, "error"), "_tag"), "Refused", "_tag");
 	});
 	for (const [name, capability, input, kind, errorName] of [[
 		"a defect rejects with the kind internal",
@@ -155,23 +208,39 @@ async function checkWebMcp(driver) {
 		{ text: 1 },
 		"invalid-input",
 		"TypeError"
-	]]) await checks.run(name, `${RULE}#tools`, async () => {
-		const call = await driver.call(capability, input);
+	]]) await checks.run(name, `${RULE}#tools`, async (signal) => {
+		const call = await driver.call(capability, input, { signal });
 		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("the signal of the host cancels a call, as an AbortError", `${RULE}#tools`, async (signal) => {
+		const key = "cancel";
+		const cancel = new AbortController();
+		const call = driver.call("fixture.hold", { key }, {
+			signal,
+			cancel: cancel.signal
+		});
+		call.catch(() => void 0);
+		const read = () => heldKeys(driver, signal);
+		try {
+			await until(`fixture.held gives ${key}`, read, (held) => held.includes(key), signal);
+			cancel.abort();
+			const result = await call;
+			expect("rejected" in result, `the call must reject, got ${JSON.stringify(result)}`);
+			expectEqual(result.rejected.kind, "cancelled", "kind");
+			expectEqual(result.rejected.name, "AbortError", "name");
+			await until("the cancelled call stops holding", read, (held) => !held.includes(key), signal);
+		} finally {
+			await driver.call("fixture.release", { key }, { signal: AbortSignal.timeout(options.deadline) }).catch(() => void 0);
+		}
 	});
-	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");
+	await checks.run("a tool is removed while its capability is unavailable, and registered again after", `${RULE}#tools`, async (signal) => {
+		const toggle = (present) => (tools) => tools.includes("fixture.toggle") === present;
+		await driver.call("fixture.switch.set", { on: false }, { signal });
+		await until("fixture.toggle is removed", () => names(driver, signal), toggle(false), signal);
+		await driver.call("fixture.switch.set", { on: true }, { signal });
+		await until("fixture.toggle is registered again", () => names(driver, signal), toggle(true), signal);
 	});
 	return checks;
 }

package/dist/json/fixture.acidcat.json.js

@@ -73,10 +73,50 @@ var fixture_acidcat_default = {
 				"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": [
@@ -97,8 +137,8 @@ var fixture_acidcat_default = {
 				"type": "object"
 			} }
 		},
-		"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",
@@ -106,8 +146,8 @@ var fixture_acidcat_default = {
 				"api"
 			],
 			"input": {
-				"properties": { "milliseconds": { "type": "number" } },
-				"required": ["milliseconds"],
+				"properties": { "key": { "type": "string" } },
+				"required": ["key"],
 				"type": "object"
 			}
 		},

package/dist/json/package.json.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.3.1";
+var version = "0.5.0";
 //#endregion
 export { version };

package/dist/json.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Checks of JSON values at run time. A value from a file, a process or a network is not trusted. These checks give it a
+ * type only after they examine it.
+ */
+import type { JsonObject } from "@acid-cat/spec-ts";
+export type { JsonObject };
+/** True if the value is a JSON object: not `null`, and not an array. */
+export declare const isObject: (value: unknown) => value is JsonObject;
+/** True if the value is an array of strings. */
+export declare const isStringArray: (value: unknown) => value is readonly string[];
+/** True if the value is a JSON object, and `isMember` is true for each of its member values. */
+export declare const isRecordOf: <T>(value: unknown, isMember: (member: unknown) => member is T) => value is {
+    readonly [key: string]: T;
+};
+/** The member `key` of a value, or `undefined` when the value is not an object. */
+export declare const memberOf: (value: unknown, key: string) => unknown;
+/** Parse JSON text. The value is not trusted, so its type is `unknown`. */
+export declare function parseJson(text: string): unknown;
+/** Read the body of a response as JSON. The value is not trusted, so its type is `unknown`. */
+export declare function readJson(response: Response): Promise<unknown>;
+/** True if the value is an array, and `isItem` is true for each of its items. */
+export declare const isArrayOf: <T>(value: unknown, isItem: (item: unknown) => item is T) => value is readonly T[];

package/dist/json.js

@@ -0,0 +1,21 @@
+//#region src/json.ts
+/** True if the value is a JSON object: not `null`, and not an array. */
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** True if the value is an array of strings. */
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+/** True if the value is a JSON object, and `isMember` is true for each of its member values. */
+const isRecordOf = (value, isMember) => isObject(value) && Object.values(value).every(isMember);
+/** The member `key` of a value, or `undefined` when the value is not an object. */
+const memberOf = (value, key) => isObject(value) ? value[key] : void 0;
+/** Parse JSON text. The value is not trusted, so its type is `unknown`. */
+function parseJson(text) {
+	return JSON.parse(text);
+}
+/** Read the body of a response as JSON. The value is not trusted, so its type is `unknown`. */
+async function readJson(response) {
+	return await response.json();
+}
+/** True if the value is an array, and `isItem` is true for each of its items. */
+const isArrayOf = (value, isItem) => Array.isArray(value) && value.every(isItem);
+//#endregion
+export { isArrayOf, isObject, isRecordOf, isStringArray, memberOf, parseJson, readJson };

package/dist/main.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
-import { check, viewOf } from "./catalog.js";
+import { parseJson } from "./json.js";
+import { check, isCatalog, viewOf } from "./catalog.js";
+import { DEADLINE } from "./conform/check.js";
 import { conform } from "./conform/index.js";
 import { version } from "./json/package.json.js";
 import { canonicalText } from "@acid-cat/catalog";
@@ -16,7 +18,7 @@ const readCatalog = Effect.fn("readCatalog")(function* (file) {
 	const text = yield* (yield* FileSystem.FileSystem).readFileString(file);
 	return {
 		text,
-		document: JSON.parse(text)
+		document: parseJson(text)
 	};
 });
 const fail = Effect.sync(() => {
@@ -54,8 +56,11 @@ const viewCommand = Command.make("view", {
 	file: Argument.String("catalog").pipe(Argument.withDescription("A catalog file")),
 	target: Argument.String("target").pipe(Argument.withDescription("The name of a target in the catalog"))
 }, Effect.fn(function* ({ file, target }) {
-	const { document } = yield* readCatalog(file);
-	const catalog = document;
+	const { document: catalog } = yield* readCatalog(file);
+	if (!isCatalog(catalog)) {
+		yield* Console.error(`${file}: error: the file is not a catalog; run \`acid-cat check ${file}\``);
+		return yield* fail;
+	}
 	if (!(target in catalog.targets)) {
 		yield* Console.error(`${file}: error: there is no target ${target}`);
 		return yield* fail;
@@ -68,7 +73,8 @@ const conformCommand = Command.make("conform", {
 	http: url("http", "The base URL of the HTTP API, before /capabilities"),
 	cli: url("cli", "The command that starts the command line, for example \"node fixture-cli.ts\""),
 	webmcp: url("webmcp", "The URL of a web page that serves the app target. It runs in Chromium, through Playwright"),
-	maximumBytes: Flag.Int("max-bytes").pipe(Flag.withDescription("The body limit of the remote bindings"), Flag.withDefault(1048576))
+	maximumBytes: Flag.Int("max-bytes").pipe(Flag.withDescription("The body limit of the remote bindings"), Flag.withDefault(1048576)),
+	deadline: Flag.Int("deadline").pipe(Flag.withDescription("The time, in milliseconds, that each check has to settle. A check that does not settle in this time fails"), Flag.withDefault(DEADLINE))
 }, Effect.fn(function* (options) {
 	const value = (option) => Option.isSome(option) ? option.value : void 0;
 	const command = value(options.cli)?.split(/\s+/).filter((word) => word !== "");
@@ -77,7 +83,8 @@ const conformCommand = Command.make("conform", {
 		http: value(options.http),
 		cli: command,
 		webmcp: value(options.webmcp),
-		maximumBytes: options.maximumBytes
+		maximumBytes: options.maximumBytes,
+		deadline: options.deadline
 	}));
 	if (results.length === 0) {
 		yield* Console.error("Give at least one binding: --mcp, --http, --cli or --webmcp.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acid-cat/cli",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "The AcidCat command line: check, format and view catalogs, and test implementations.",
   "keywords": [
     "acidcat",
@@ -37,12 +37,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@acid-cat/catalog": "0.3.1",
-    "@acid-cat/spec-ts": "0.3.1",
-    "@effect/platform-node": "4.0.4",
-    "@effect/platform-node-shared": "4.0.4",
+    "@acid-cat/catalog": "0.5.0",
+    "@acid-cat/spec-ts": "0.5.0",
+    "@effect/platform-node": "4.0.6",
+    "@effect/platform-node-shared": "4.0.6",
     "@modelcontextprotocol/client": "2.3.1",
-    "effect": "4.0.4",
+    "effect": "4.0.6",
     "fast-check": "4.10.2"
   },
   "peerDependencies": {