@acid-cat/cli 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-VZ6KDZEL.js

@@ -0,0 +1,1018 @@
+// src/catalog.ts
+import { canonicalText } from "@acid-cat/catalog";
+import { bundle, REFERENCE, schemasOf, viewOf, visitObjects } from "@acid-cat/spec-ts";
+import { Result, Schema, SchemaIssue, SchemaRepresentation } from "effect";
+
+// ../../schemas/catalog.schema.json
+var catalog_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://acid-cat.dev/schemas/0.1/catalog.schema.json",
+  title: "AcidCat catalog",
+  description: "One document that states what an application can do and which targets see it. See spec/catalog.md.",
+  type: "object",
+  required: [
+    "acidcat",
+    "targets",
+    "capabilities"
+  ],
+  properties: {
+    acidcat: {
+      description: "The version of the AcidCat specification this catalog follows.",
+      const: "0.1"
+    },
+    title: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    targets: {
+      description: "The targets, keyed by name.",
+      type: "object",
+      propertyNames: {
+        $ref: "#/$defs/targetName"
+      },
+      additionalProperties: {
+        $ref: "#/$defs/target"
+      }
+    },
+    $defs: {
+      description: "Shared types, keyed by name. Capability schemas reference them as #/$defs/<Name>.",
+      type: "object",
+      propertyNames: {
+        $ref: "#/$defs/typeName"
+      },
+      additionalProperties: {
+        $ref: "#/$defs/schema"
+      }
+    },
+    capabilities: {
+      description: "The capabilities, keyed by id.",
+      type: "object",
+      propertyNames: {
+        $ref: "#/$defs/id"
+      },
+      additionalProperties: {
+        $ref: "#/$defs/capability"
+      }
+    }
+  },
+  $defs: {
+    id: {
+      type: "string",
+      maxLength: 128,
+      pattern: "^[a-z][a-z0-9]*(-[a-z0-9]+)*(\\.[a-z][a-z0-9]*(-[a-z0-9]+)*)+$"
+    },
+    targetName: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]*(:[a-z][a-z0-9-]*)?$"
+    },
+    bindingName: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]*(:[a-z][a-z0-9-]*)?$"
+    },
+    typeName: {
+      type: "string",
+      pattern: "^[A-Za-z][A-Za-z0-9_]*$"
+    },
+    target: {
+      type: "object",
+      required: [
+        "bindings"
+      ],
+      properties: {
+        bindings: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/bindingName"
+          },
+          minItems: 1,
+          uniqueItems: true
+        },
+        description: {
+          type: "string"
+        },
+        options: {
+          type: "object"
+        }
+      }
+    },
+    schema: {
+      description: "A JSON Schema 2020-12 schema. Its $refs point into the catalog's $defs.",
+      type: [
+        "object",
+        "boolean"
+      ]
+    },
+    objectSchema: {
+      description: "An input schema: it states that the input is an object, or it references a type.",
+      type: "object",
+      anyOf: [
+        {
+          required: [
+            "type"
+          ],
+          properties: {
+            type: {
+              const: "object"
+            }
+          }
+        },
+        {
+          required: [
+            "$ref"
+          ],
+          properties: {
+            $ref: {
+              type: "string"
+            }
+          }
+        }
+      ]
+    },
+    capability: {
+      type: "object",
+      required: [
+        "description"
+      ],
+      properties: {
+        description: {
+          type: "string",
+          minLength: 1,
+          pattern: "\\S"
+        },
+        audience: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/targetName"
+          },
+          uniqueItems: true
+        },
+        input: {
+          $ref: "#/$defs/objectSchema"
+        },
+        output: {
+          $ref: "#/$defs/schema"
+        },
+        failures: {
+          type: "object",
+          propertyNames: {
+            type: "string",
+            minLength: 1
+          },
+          additionalProperties: {
+            $ref: "#/$defs/schema"
+          }
+        },
+        readOnly: {
+          type: "boolean"
+        },
+        state: {
+          $ref: "#/$defs/schema"
+        }
+      }
+    }
+  }
+};
+
+// src/catalog.ts
+var KNOWN_MEMBERS = {
+  catalog: ["acidcat", "title", "description", "targets", "$defs", "capabilities"],
+  target: ["bindings", "description", "options"],
+  capability: ["description", "audience", "input", "output", "failures", "readOnly", "state"]
+};
+var 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);
+})();
+var formatIssues = SchemaIssue.makeFormatterStandardSchemaV1();
+function check(document, text) {
+  const decoded = decodeCatalog(document);
+  if (Result.isFailure(decoded)) {
+    const errors2 = formatIssues(decoded.failure.issue).issues.map(
+      (issue) => `${(issue.path ?? []).map((key) => `[${JSON.stringify(key)}]`).join("") || "the catalog"}: ${issue.message}`
+    );
+    return { errors: errors2, 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 };
+}
+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;
+}
+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)
+    )
+  ];
+}
+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;
+}
+
+// conformance/fixture.acidcat.json
+var fixture_acidcat_default = {
+  acidcat: "0.1",
+  title: "AcidCat conformance fixture",
+  targets: {
+    api: {
+      bindings: [
+        "http"
+      ]
+    },
+    app: {
+      bindings: [
+        "typescript",
+        "webmcp"
+      ]
+    },
+    cli: {
+      bindings: [
+        "cli"
+      ]
+    },
+    mcp: {
+      bindings: [
+        "mcp"
+      ]
+    }
+  },
+  capabilities: {
+    "fixture.crash": {
+      description: "Always fail with a defect.",
+      audience: [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ]
+    },
+    "fixture.echo": {
+      description: "Return the input text.",
+      audience: [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      input: {
+        properties: {
+          text: {
+            type: "string"
+          }
+        },
+        required: [
+          "text"
+        ],
+        type: "object"
+      },
+      output: {
+        properties: {
+          text: {
+            type: "string"
+          }
+        },
+        required: [
+          "text"
+        ],
+        type: "object"
+      },
+      readOnly: true
+    },
+    "fixture.hidden": {
+      description: "Only the app target can use this capability.",
+      audience: [
+        "app"
+      ]
+    },
+    "fixture.refuse": {
+      description: "Always return the failure Refused.",
+      audience: [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      failures: {
+        Refused: {
+          properties: {
+            _tag: {
+              const: "Refused",
+              type: "string"
+            },
+            reason: {
+              type: "string"
+            }
+          },
+          required: [
+            "_tag",
+            "reason"
+          ],
+          type: "object"
+        }
+      }
+    },
+    "fixture.slow": {
+      description: "Wait for some milliseconds, then return null.",
+      audience: [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      input: {
+        properties: {
+          milliseconds: {
+            type: "number"
+          }
+        },
+        required: [
+          "milliseconds"
+        ],
+        type: "object"
+      }
+    },
+    "fixture.switch.set": {
+      description: "Turn the switch on or off. The switch controls the availability of fixture.toggle.",
+      audience: [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ],
+      input: {
+        properties: {
+          on: {
+            type: "boolean"
+          }
+        },
+        required: [
+          "on"
+        ],
+        type: "object"
+      }
+    },
+    "fixture.toggle": {
+      description: "Available only while the switch is on.",
+      audience: [
+        "app",
+        "mcp",
+        "cli",
+        "api"
+      ]
+    }
+  }
+};
+
+// src/conform/check.ts
+import { viewOf as viewOf2 } from "@acid-cat/spec-ts";
+var fixture = fixture_acidcat_default;
+var idsOf = (target) => Object.keys(viewOf2(fixture, target).capabilities).sort();
+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) });
+    }
+  }
+};
+function expect(condition, message) {
+  if (!condition) throw new Error(message);
+}
+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}`);
+}
+var sorted = (values) => [...values].sort();
+var FORBIDDEN_ORIGIN = "https://not-allowed.acid-cat.invalid";
+
+// src/conform/serve.ts
+import { createServer } from "node:http";
+function serve(routes) {
+  const prefixes = Object.keys(routes).sort((a, b) => b.length - a.length);
+  const server = createServer((incoming, outgoing) => {
+    void answer(incoming, outgoing, prefixes, routes);
+  });
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address !== null ? address.port : 0;
+      resolve({
+        url: `http://127.0.0.1:${port}`,
+        close: () => new Promise((done) => server.close(() => done()))
+      });
+    });
+  });
+}
+async function answer(incoming, outgoing, prefixes, routes) {
+  const url = new URL(incoming.url ?? "/", `http://${incoming.headers.host ?? "127.0.0.1"}`);
+  const prefix = prefixes.find((candidate) => url.pathname === candidate || url.pathname.startsWith(`${candidate}/`));
+  if (prefix === void 0) {
+    outgoing.writeHead(404).end();
+    return;
+  }
+  const abort = new AbortController();
+  outgoing.on("close", () => {
+    if (!outgoing.writableFinished) abort.abort();
+  });
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    if (Array.isArray(value)) value.forEach((item) => headers.append(name, item));
+    else if (value !== void 0) headers.set(name, value);
+  }
+  const hasBody = incoming.method !== "GET" && incoming.method !== "HEAD";
+  const request = new Request(url, {
+    method: incoming.method ?? "GET",
+    headers,
+    signal: abort.signal,
+    ...hasBody ? { body: incoming, duplex: "half" } : {}
+  });
+  try {
+    const response = await routes[prefix](request);
+    outgoing.writeHead(response.status, Object.fromEntries(response.headers));
+    if (response.body === null) {
+      outgoing.end();
+      return;
+    }
+    for await (const chunk of response.body) outgoing.write(chunk);
+    outgoing.end();
+  } catch {
+    if (!outgoing.headersSent) outgoing.writeHead(500);
+    outgoing.end();
+  }
+}
+
+// src/conform/cli.ts
+import { spawn } from "node:child_process";
+var RULE = "spec/bindings/cli.md";
+var INTERRUPT_AFTER = 2e3;
+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;
+}
+
+// src/conform/http.ts
+var RULE2 = "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", `${RULE2}#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", `${RULE2}#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", `${RULE2}#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, status2, 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, `${RULE2}#requests`, async () => {
+      const response = await post(id, input);
+      expectEqual(response.status, status2, "status");
+      expectEqual((await json(response)).kind, kind, "kind");
+    });
+  }
+  await checks.run("an unavailable capability has the status 503", `${RULE2}#requests`, async () => {
+    await post("fixture.switch.set", { on: false });
+    try {
+      const list = await (await fetch(`${base}/capabilities`)).json();
+      const toggle = list.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", `${RULE2}#requests`, async () => {
+    await status(await fetch(`${base}/capabilities`, { method: "PUT" }), 405);
+  });
+  await checks.run("an origin that is not allowed is rejected with 403", `${RULE2}#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", `${RULE2}#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", `${RULE2}#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", `${RULE2}#requests`, async () => {
+    await status(await post("fixture.echo", new Uint8Array([123, 255, 125])), 400);
+  });
+  return checks;
+}
+
+// src/conform/mcp.ts
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+var RULE3 = "spec/bindings/mcp.md";
+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;
+}
+var 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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#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", `${RULE3}#server`, async () => {
+    await rejection(await post({ body: "{" }), 400, -32700);
+  });
+  await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE3}#server`, async () => {
+    await rejection(await post({ body: new Uint8Array([123, 255, 125]) }), 400);
+  });
+  return checks;
+}
+
+// src/conform/properties.ts
+import fc from "fast-check";
+var RULE4 = "spec/invocation.md#cancellation-and-concurrency";
+function httpInvoke(base) {
+  return async (id, input, signal) => {
+    const response = await fetch(`${base}/capabilities/${id}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+      ...signal ? { signal } : {}
+    });
+    return await response.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()
+  };
+}
+var operation = fc.oneof(
+  fc.string({ maxLength: 40 }).map((text) => ({ kind: "echo", text })),
+  fc.constant({ kind: "refuse" }),
+  fc.constant({ kind: "crash" }),
+  fc.constant({ kind: "invalid" })
+);
+function agrees(operation2, outcome) {
+  switch (operation2.kind) {
+    case "echo":
+      return "ok" in outcome && outcome.ok && JSON.stringify(outcome.value) === JSON.stringify({ text: operation2.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";
+  }
+}
+var callFor = (invoke, operation2) => {
+  switch (operation2.kind) {
+    case "echo":
+      return invoke("fixture.echo", { text: operation2.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", RULE4, 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", RULE4, 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;
+}
+
+// src/conform/webmcp.ts
+import { REFERENCE as REFERENCE2, visitObjects as visitObjects2 } from "@acid-cat/spec-ts";
+var RULE5 = "spec/bindings/webmcp.md";
+var TARGET = "app";
+function createTestHost() {
+  const registered = /* @__PURE__ */ new Map();
+  return {
+    modelContext: {
+      registerTool(tool, options) {
+        const recorded = tool;
+        registered.set(recorded.name, recorded);
+        options.signal.addEventListener("abort", () => {
+          if (registered.get(recorded.name) === recorded) registered.delete(recorded.name);
+        });
+      }
+    },
+    tools: () => [...registered.values()].map((tool) => ({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema })),
+    async call(name, input, cancelAfter) {
+      const tool = registered.get(name);
+      if (tool === void 0) return { missing: true };
+      const controller = new AbortController();
+      if (cancelAfter !== void 0) setTimeout(() => controller.abort(), cancelAfter);
+      try {
+        return { resolved: await tool.execute(input, { signal: controller.signal }) };
+      } catch (error) {
+        const { name: errorName, kind, message } = error;
+        return { rejected: { name: String(errorName), kind, message: String(message) } };
+      }
+    }
+  };
+}
+async function processDriver(install) {
+  const host = createTestHost();
+  const remove = await install(host.modelContext);
+  const copy = (value) => JSON.parse(JSON.stringify(value));
+  return {
+    tools: async () => copy(host.tools()),
+    call: async (name, input, cancelAfter) => copy(await host.call(name, input, cancelAfter)),
+    close: async () => {
+      if (typeof remove === "function") await remove();
+    }
+  };
+}
+async function browserDriver(url) {
+  let playwright;
+  try {
+    playwright = await import("playwright");
+  } catch {
+    throw new Error(
+      "acid-cat conform --webmcp needs Playwright and Chromium: `pnpm add -D playwright`, then `pnpm exec playwright install chromium`."
+    );
+  }
+  const browser = await playwright.chromium.launch();
+  const page = await browser.newPage();
+  const errors = [];
+  page.on("pageerror", (error) => errors.push(error.message));
+  await page.addInitScript(`
+    window.__acidCatConform = (${createTestHost.toString()})();
+    for (const scope of [document, navigator]) {
+      Object.defineProperty(scope, "modelContext", { value: window.__acidCatConform.modelContext, configurable: true });
+    }
+  `);
+  await page.goto(url);
+  return {
+    tools: async () => {
+      if (errors.length > 0) throw new Error(`The page has errors: ${errors.join("; ")}`);
+      return page.evaluate(() => window.__acidCatConform.tools());
+    },
+    call: (name, input, cancelAfter) => page.evaluate(
+      ([name2, input2, cancelAfter2]) => window.__acidCatConform.call(name2, input2, cancelAfter2),
+      [name, input, cancelAfter]
+    ),
+    close: () => browser.close()
+  };
+}
+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));
+  }
+}
+function isBundled(schema) {
+  const types = schema.$defs ?? {};
+  let bundled = true;
+  visitObjects2(schema, (node) => {
+    if (typeof node.$ref !== "string") return;
+    const name = REFERENCE2.exec(node.$ref)?.[1];
+    if (name === void 0 || !(name in types)) bundled = false;
+  });
+  return bundled;
+}
+var names = async (driver) => sorted((await driver.tools()).map((tool) => tool.name));
+async function checkWebMcp(driver) {
+  const checks = new Checks("webmcp");
+  const view = fixture.capabilities;
+  const expected = idsOf(TARGET);
+  await checks.run("each available capability of the view is a tool", `${RULE5}#tools`, async () => {
+    await eventually(async () => JSON.stringify(await names(driver)) === JSON.stringify(expected), `the tools must be ${expected.join(", ")}`);
+  });
+  await checks.run("a tool has the description and the bundled input schema of its capability", `${RULE5}#tools`, async () => {
+    for (const tool of await driver.tools()) {
+      expectEqual(tool.description, view[tool.name]?.description, `description of ${tool.name}`);
+      const schema = tool.inputSchema;
+      const input = view[tool.name]?.input ?? {};
+      expectEqual(schema.type, "object", `type of the input schema of ${tool.name}`);
+      expectEqual(sorted(Object.keys(schema.properties ?? {})), sorted(Object.keys(input.properties ?? {})), `properties of ${tool.name}`);
+      expectEqual(sorted(schema.required ?? []), sorted(input.required ?? []), `required properties of ${tool.name}`);
+      expect(isBundled(schema), `the input schema of ${tool.name} must be bundled`);
+    }
+  });
+  await checks.run("a value resolves as a result", `${RULE5}#tools`, async () => {
+    expectEqual(await driver.call("fixture.echo", { text: "hello" }), { resolved: { ok: true, value: { text: "hello" } } }, "outcome");
+  });
+  await checks.run("a failure resolves as a result", `${RULE5}#tools`, async () => {
+    const call = await driver.call("fixture.refuse", {});
+    expect("resolved" in call, `the call must resolve, got ${JSON.stringify(call)}`);
+    expectEqual(call.resolved.error?._tag, "Refused", "_tag");
+  });
+  for (const [name, capability, input, kind, errorName] of [
+    ["a defect rejects with the kind internal", "fixture.crash", {}, "internal", void 0],
+    ["invalid input rejects with the kind invalid-input, as a TypeError", "fixture.echo", { text: 1 }, "invalid-input", "TypeError"]
+  ]) {
+    await checks.run(name, `${RULE5}#tools`, async () => {
+      const call = await driver.call(capability, input);
+      expect("rejected" in call, `the call must reject, got ${JSON.stringify(call)}`);
+      expectEqual(call.rejected.kind, kind, "kind");
+      if (errorName !== void 0) expectEqual(call.rejected.name, errorName, "name");
+    });
+  }
+  await checks.run("the signal of the host cancels a call, as an AbortError", `${RULE5}#tools`, async () => {
+    const call = await driver.call("fixture.slow", { milliseconds: 6e4 }, 50);
+    expect("rejected" in call, `the call must reject, got ${JSON.stringify(call)}`);
+    expectEqual(call.rejected.kind, "cancelled", "kind");
+    expectEqual(call.rejected.name, "AbortError", "name");
+  });
+  await checks.run("a tool is removed while its capability is unavailable, and registered again after", `${RULE5}#tools`, async () => {
+    await driver.call("fixture.switch.set", { on: false });
+    await eventually(async () => !(await names(driver)).includes("fixture.toggle"), "fixture.toggle must be removed");
+    await driver.call("fixture.switch.set", { on: true });
+    await eventually(async () => (await names(driver)).includes("fixture.toggle"), "fixture.toggle must be registered again");
+  });
+  return checks;
+}
+
+// src/conform/index.ts
+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;
+}
+
+export {
+  bundle,
+  viewOf,
+  check,
+  fixture,
+  serve,
+  conform
+};