@mikeargento/bitgraph-player 0.8.1 → 0.9.0

package/src/__tests__/domain.test.ts

@@ -1,321 +0,0 @@
-// Copyright (c) 2024-2026 Mike Argento. Licensed under the MIT License. See LICENSE.
-
-/**
- * BitGraph Domain: parseDomainFile, fingerprints, the pin store, the
- * fetch, and check --from's "domain" line.
- *
- * The invariants under test:
- *   - The domain line is TRUE or UNDETERMINED, never FALSE: absence of
- *     domain evidence contradicts nothing (SPEC §9.3's open-world rule).
- *   - Fingerprints are always derived from key material, never read from
- *     the file; for es256 the fingerprint IS the actor keyId, proved
- *     against the real declared recording (fixtures/declared-12010).
- *   - A malformed file is refused at the pin, and a redirect cannot store
- *     one party's file under another party's name (the `domain` field
- *     must equal the domain the reader asked for).
- *   - A report without --from stays bitgraph-check/1 with no `from` key.
- *
- * Everything runs in memory or under a temp dir. The fetch is injected;
- * no network, no ledger writes, ever.
- */
-
-import { strict as assert } from "node:assert";
-import { createHash, generateKeyPairSync, sign as cryptoSign } from "node:crypto";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { ingestEntries } from "@mikeargento/bitgraph-audit";
-import type { CheckRecording, CheckReport } from "../check.js";
-import { checkIngest } from "../check.js";
-import {
-  checkDomain,
-  diffDomainFiles,
-  DomainFileError,
-  domainKeyRefs,
-  isDomainName,
-  keyFingerprint,
-  parseDomainFile,
-} from "../domain.js";
-import { fetchDomainFile, forgetPin, listPins, readPin, writePin } from "../pin.js";
-import type { FetchLike } from "../pin.js";
-import { sigMessage } from "../sig.js";
-
-// ---------------------------------------------------------------------------
-// The real declared recording: actor key ee0c6517…, provider passkey
-// ---------------------------------------------------------------------------
-
-const proofBytes = readFileSync(new URL("../../src/__tests__/fixtures/declared-12010/proof.json", import.meta.url));
-const proofJson = JSON.parse(proofBytes.toString("utf8")) as {
-  agency: { actor: { publicKeyB64: string; keyId: string } };
-  artifact: { digestB64: string };
-};
-const ACTOR_KEY_B64 = proofJson.agency.actor.publicKeyB64;
-const ACTOR_KEY_ID = proofJson.agency.actor.keyId;
-const DIGEST_HEX = Buffer.from(proofJson.artifact.digestB64, "base64").toString("hex");
-
-function domainText(overrides?: Record<string, unknown>): string {
-  return JSON.stringify({
-    version: "bitgraph-domain/1",
-    domain: "acme.com",
-    party: "Acme Corp",
-    keys: { studio: { alg: "es256", publicKey: ACTOR_KEY_B64 } },
-    ...overrides,
-  });
-}
-
-async function ingestProof(bytes: Uint8Array = proofBytes) {
-  return ingestEntries([{ path: "proof.json", open: () => Promise.resolve(new Uint8Array(bytes)) }]);
-}
-
-function onlyRecording(report: CheckReport): CheckRecording {
-  assert.equal(report.recordings.length, 1);
-  return report.recordings[0] as CheckRecording;
-}
-
-function domainLineOf(recording: CheckRecording) {
-  const line = recording.lines.find((l) => l.name === "domain");
-  assert.notEqual(line, undefined, "expected a domain line");
-  return line as NonNullable<typeof line>;
-}
-
-// ---------------------------------------------------------------------------
-// Parsing and fingerprints
-// ---------------------------------------------------------------------------
-
-test("parseDomainFile accepts a valid file and derives the party/keys", () => {
-  const file = parseDomainFile(domainText(), "acme.com");
-  assert.equal(file.domain, "acme.com");
-  assert.equal(file.party, "Acme Corp");
-  assert.deepEqual(Object.keys(file.keys), ["studio"]);
-});
-
-test("isDomainName: lowercase dotted hostnames only", () => {
-  assert.equal(isDomainName("acme.com"), true);
-  assert.equal(isDomainName("sub.acme-corp.co.uk"), true);
-  assert.equal(isDomainName("ACME.com"), false);
-  assert.equal(isDomainName("acme"), false);
-  assert.equal(isDomainName("acme.com/path"), false);
-  assert.equal(isDomainName("https://acme.com"), false);
-  assert.equal(isDomainName("acme.com:443"), false);
-  assert.equal(isDomainName(""), false);
-});
-
-test("parseDomainFile refuses malformed files with every issue named", () => {
-  const bad = (text: string, expected?: string): string[] => {
-    try {
-      parseDomainFile(text, expected);
-    } catch (err) {
-      assert.ok(err instanceof DomainFileError);
-      return [...err.issues];
-    }
-    assert.fail("expected DomainFileError");
-  };
-  assert.match(bad(domainText({ version: "bitgraph-domain/2" })).join(" "), /"version" must be exactly/);
-  assert.match(bad(domainText({ extra: 1 })).join(" "), /unknown field "extra"/);
-  assert.match(bad(domainText(), "other.example").join(" "), /refusing to store one party's file/);
-  assert.match(bad(domainText({ party: "  " })).join(" "), /"party" is required/);
-  assert.match(bad(domainText({ keys: {} })).join(" "), /at least one key/);
-  assert.match(bad(domainText({ keys: { "1234": { alg: "es256", publicKey: ACTOR_KEY_B64 } } })).join(" "), /non-digit/);
-  assert.match(
-    bad(domainText({ keys: { studio: { alg: "es256", publicKey: ACTOR_KEY_B64, note: "x" } } })).join(" "),
-    /unknown field "note"/
-  );
-  assert.match(bad(domainText({ keys: { studio: { alg: "rsa", publicKey: ACTOR_KEY_B64 } } })).join(" "), /"alg" must be/);
-  assert.match(bad(domainText({ keys: { studio: { alg: "es256", publicKey: "!!!" } } })).join(" "), /does not decode/);
-  assert.match(
-    bad(domainText({ keys: { press: { alg: "ed25519", publicKey: Buffer.alloc(16).toString("base64") } } })).join(" "),
-    /does not decode/
-  );
-  assert.match(bad(domainText({ domain: "https://acme.com" })).join(" "), /lowercase hostname/);
-  // Oversize input is refused before parsing.
-  const big = new Uint8Array(70_000);
-  assert.throws(() => parseDomainFile(big), DomainFileError);
-});
-
-test("an es256 fingerprint IS the actor keyId (derived, never assigned)", () => {
-  assert.equal(keyFingerprint({ alg: "es256", publicKey: ACTOR_KEY_B64 }), ACTOR_KEY_ID);
-  const refs = domainKeyRefs(parseDomainFile(domainText()));
-  assert.deepEqual(refs.map((r) => [r.name, r.fingerprint]), [["studio", ACTOR_KEY_ID]]);
-});
-
-test("checkDomain resolves actor keyIds case-insensitively, es256 only", () => {
-  const from = checkDomain(parseDomainFile(domainText()));
-  assert.equal(from.actorKeyName(ACTOR_KEY_ID), "studio");
-  assert.equal(from.actorKeyName(ACTOR_KEY_ID.toUpperCase()), "studio");
-  assert.equal(from.actorKeyName("00".repeat(32)), undefined);
-  // An ed25519 key never actor-matches: actors are P-256.
-  const edPub = generateKeyPairSync("ed25519").publicKey.export({ type: "spki", format: "der" }) as Buffer;
-  const edOnly = parseDomainFile(
-    domainText({ keys: { press: { alg: "ed25519", publicKey: edPub.subarray(edPub.length - 32).toString("base64") } } })
-  );
-  const edFingerprint = keyFingerprint(edOnly.keys["press"] as { alg: "ed25519"; publicKey: string });
-  assert.equal(checkDomain(edOnly).actorKeyName(edFingerprint as string), undefined);
-});
-
-// ---------------------------------------------------------------------------
-// check --from: the domain line
-// ---------------------------------------------------------------------------
-
-test("check --from: the real declared recording reads TRUE under its published key", async () => {
-  const report = await checkIngest(await ingestProof(), { from: checkDomain(parseDomainFile(domainText())) });
-  assert.equal(report.check, "bitgraph-check/2");
-  assert.deepEqual(report.from, { domain: "acme.com", party: "Acme Corp" });
-  const line = domainLineOf(onlyRecording(report));
-  assert.equal(line.result, "TRUE");
-  assert.match(line.detail, /actor key "studio" · published by acme\.com \(Acme Corp\)/);
-  assert.ok(report.notChecked.some((n) => n.includes("pinned")));
-});
-
-test("check --from: a domain that never published the key reads UNDETERMINED, never FALSE", async () => {
-  const otherKey = generateKeyPairSync("ec", { namedCurve: "P-256" })
-    .publicKey.export({ type: "spki", format: "der" }) as Buffer;
-  const from = checkDomain(
-    parseDomainFile(domainText({ keys: { invoices: { alg: "es256", publicKey: otherKey.toString("base64") } } }))
-  );
-  const report = await checkIngest(await ingestProof(), { from });
-  const line = domainLineOf(onlyRecording(report));
-  assert.equal(line.result, "UNDETERMINED");
-  assert.match(line.detail, /is not among the 1 key\(s\) acme\.com publishes/);
-});
-
-test("check --from: a recording that does not verify gets an UNDETERMINED domain line", async () => {
-  const stripped = JSON.parse(proofBytes.toString("utf8")) as Record<string, unknown>;
-  delete stripped["agency"];
-  const report = await checkIngest(await ingestProof(Buffer.from(JSON.stringify(stripped))), {
-    from: checkDomain(parseDomainFile(domainText())),
-  });
-  const recording = onlyRecording(report);
-  assert.equal(recording.lines.find((l) => l.name === "signature")?.result, "FALSE");
-  const line = domainLineOf(recording);
-  assert.equal(line.result, "UNDETERMINED");
-  assert.match(line.detail, /is not verified here/);
-});
-
-test("check --from: a detached bitgraph-sig/1 under a published ed25519 key reads TRUE", async () => {
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
-  const spki = publicKey.export({ type: "spki", format: "der" }) as Buffer;
-  const rawB64 = spki.subarray(spki.length - 32).toString("base64");
-  const signature = cryptoSign(null, sigMessage(DIGEST_HEX), privateKey).toString("base64");
-  const sigBytes = Buffer.from(
-    JSON.stringify({
-      sig: "bitgraph-sig/1",
-      over: `sha256:${DIGEST_HEX}`,
-      alg: "ed25519",
-      publicKey: rawB64,
-      signature,
-    })
-  );
-  const from = checkDomain(parseDomainFile(domainText({ keys: { press: { alg: "ed25519", publicKey: rawB64 } } })));
-  const sigEvidence = new Map([[createHash("sha256").update(sigBytes).digest("hex"), new Uint8Array(sigBytes)]]);
-  const report = await checkIngest(await ingestProof(), { from, sigEvidence });
-  const line = domainLineOf(onlyRecording(report));
-  assert.equal(line.result, "TRUE");
-  assert.match(line.detail, /signature by "press" · published by acme\.com/);
-});
-
-test("without --from the report stays bitgraph-check/1 with no from key and no domain line", async () => {
-  const report = await checkIngest(await ingestProof());
-  assert.equal(report.check, "bitgraph-check/1");
-  assert.equal("from" in report, false);
-  assert.equal(onlyRecording(report).lines.some((l) => l.name === "domain"), false);
-});
-
-// ---------------------------------------------------------------------------
-// The pin store
-// ---------------------------------------------------------------------------
-
-test("pin store: write, read, list, forget; malformed pins are refused at read", () => {
-  const dir = mkdtempSync(join(tmpdir(), "bitgraph-pins-"));
-  try {
-    const path = writePin("acme.com", Buffer.from(domainText()), dir);
-    assert.ok(path.endsWith("acme.com"));
-    const pin = readPin("acme.com", dir);
-    assert.equal(pin?.file.party, "Acme Corp");
-    assert.equal(pin?.bytes.toString("utf8"), domainText());
-
-    // A stored file naming a different domain is refused: the store binds
-    // name to statement, so a bad write cannot impersonate.
-    writePin("evil.example", Buffer.from(domainText()), dir);
-    assert.throws(() => readPin("evil.example", dir), DomainFileError);
-
-    writePin("broken.example", Buffer.from("{"), dir);
-    assert.throws(() => readPin("broken.example", dir), DomainFileError);
-
-    const listed = listPins(dir);
-    assert.deepEqual(listed.map((p) => [p.domain, p.malformed]), [
-      ["acme.com", false],
-      ["broken.example", true],
-      ["evil.example", true],
-    ]);
-    assert.equal(listed[0]?.party, "Acme Corp");
-    assert.equal(listed[0]?.keyCount, 1);
-
-    assert.equal(forgetPin("acme.com", dir), true);
-    assert.equal(readPin("acme.com", dir), undefined);
-    assert.equal(forgetPin("acme.com", dir), false);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// The fetch (injected; the only networked verb)
-// ---------------------------------------------------------------------------
-
-function fakeFetch(body: string | Buffer, status = 200): { impl: FetchLike; urls: string[] } {
-  const urls: string[] = [];
-  const impl: FetchLike = (url) => {
-    urls.push(url);
-    return Promise.resolve({
-      ok: status >= 200 && status < 300,
-      status,
-      headers: { get: () => null },
-      arrayBuffer: () => {
-        const buf = Buffer.from(body);
-        return Promise.resolve(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
-      },
-    });
-  };
-  return { impl, urls };
-}
-
-test("fetchDomainFile: fixed well-known path, verbatim bytes, strict domain binding", async () => {
-  const { impl, urls } = fakeFetch(domainText());
-  const fetched = await fetchDomainFile("acme.com", impl);
-  assert.deepEqual(urls, ["https://acme.com/.well-known/bitgraph"]);
-  assert.equal(fetched.file.party, "Acme Corp");
-  assert.equal(fetched.bytes.toString("utf8"), domainText());
-
-  // The served file names acme.com; pinning it as another.example must
-  // refuse: a redirect cannot repoint the name.
-  await assert.rejects(fetchDomainFile("another.example", fakeFetch(domainText()).impl), DomainFileError);
-  await assert.rejects(fetchDomainFile("acme.com", fakeFetch("nope", 404).impl), /HTTP 404/);
-  await assert.rejects(fetchDomainFile("acme.com", fakeFetch(Buffer.alloc(70_000)).impl), /the cap is/);
-  await assert.rejects(fetchDomainFile("https://acme.com", fakeFetch(domainText()).impl), /bare hostname/);
-});
-
-// ---------------------------------------------------------------------------
-// Re-pin diffs
-// ---------------------------------------------------------------------------
-
-test("diffDomainFiles reports added, removed, changed, and a renamed party", () => {
-  const edPub = generateKeyPairSync("ed25519").publicKey.export({ type: "spki", format: "der" }) as Buffer;
-  const edB64 = edPub.subarray(edPub.length - 32).toString("base64");
-  const before = parseDomainFile(domainText());
-  const after = parseDomainFile(
-    domainText({
-      party: "Acme Corporation",
-      keys: {
-        studio: { alg: "ed25519", publicKey: edB64 },
-        press: { alg: "ed25519", publicKey: edB64 },
-      },
-    })
-  );
-  const diff = diffDomainFiles(before, after);
-  assert.deepEqual(diff.partyChanged, { before: "Acme Corp", after: "Acme Corporation" });
-  assert.deepEqual(diff.added.map((r) => r.name), ["press"]);
-  assert.deepEqual(diff.removed.map((r) => r.name), []);
-  assert.deepEqual(diff.changed.map((c) => c.name), ["studio"]);
-  assert.equal(diff.unchanged, 0);
-});

package/src/domain.ts

@@ -1,245 +0,0 @@
-// Copyright (c) 2024-2026 Mike Argento. Licensed under the MIT License. See LICENSE.
-
-/**
- * BitGraph Domain: a party's own domain publishing the keys that record
- * for it. The file (`bitgraph-domain/1`) is served at
- * `https://<domain>/.well-known/bitgraph` and is the party speaking for
- * itself, never BitGraph speaking about the party: parsing enforces
- * well-formedness only, and adopting the statement is the reader's act
- * (see pin.ts). The format is DOMAIN.md; evaluation semantics (SPEC.md
- * sections 1 through 9) are untouched by everything in this module.
- *
- * The file shares SPEC section 9.1's trusted-key grammar, so an entry
- * pastes into a format 2 rule's `trustedKeys` unchanged, and a key's
- * fingerprint is the lowercase hex SHA-256 of the decoded key bytes,
- * which for es256 is exactly the `keyId` actor proofs carry. Fingerprints
- * are always derived here and never read from the file, so a domain
- * cannot claim a key it does not show.
- */
-
-import { createHash } from "node:crypto";
-import type { CheckDomain } from "./check.js";
-import { decodeDigestBytes } from "./rule.js";
-import type { TrustedKey } from "./sig.js";
-import { decodeB64Strict, keyObjectFor, parseSigFile, verifySigFile } from "./sig.js";
-
-export const DOMAIN_FILE_VERSION = "bitgraph-domain/1";
-export const DOMAIN_WELL_KNOWN_PATH = "/.well-known/bitgraph";
-export const DOMAIN_FILE_MAX_BYTES = 65_536;
-
-export interface DomainFile {
-  version: "bitgraph-domain/1";
-  /** Lowercase hostname; the binding. Must equal the domain the reader asked for. */
-  domain: string;
-  /** The name the domain gives itself. Display only. */
-  party: string;
-  /** SPEC §9.1 trusted-key bodies, named. */
-  keys: Record<string, TrustedKey>;
-}
-
-export class DomainFileError extends Error {
-  readonly issues: readonly string[];
-  constructor(issues: string[]) {
-    super(issues[0] ?? "invalid domain file");
-    this.name = "DomainFileError";
-    this.issues = issues;
-  }
-}
-
-/**
- * Lowercase registrable hostname: dot-separated LDH labels, at least two,
- * no scheme, no port, no path. Also the safety property the pin store
- * rests on: a name this grammar accepts contains no path separators.
- */
-const LABEL = "[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?";
-const DOMAIN_RE = new RegExp(`^${LABEL}(?:\\.${LABEL})+$`);
-
-export function isDomainName(s: string): boolean {
-  return s.length > 0 && s.length <= 253 && DOMAIN_RE.test(s);
-}
-
-function isPlainObject(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-/**
- * Parse and validate a bitgraph-domain/1 file. Strict: unknown fields are
- * errors (additions are a new format version), and key material that does
- * not decode is refused here rather than stored, so a pin can never hold
- * keys that silently match nothing. Throws DomainFileError with every
- * issue found.
- */
-export function parseDomainFile(input: Uint8Array | string, expectedDomain?: string): DomainFile {
-  const issues: string[] = [];
-  const text = typeof input === "string" ? input : Buffer.from(input).toString("utf8");
-  if (typeof input !== "string" && input.length > DOMAIN_FILE_MAX_BYTES) {
-    throw new DomainFileError([`file is ${input.length} bytes; the cap is ${DOMAIN_FILE_MAX_BYTES}`]);
-  }
-
-  let raw: unknown;
-  try {
-    raw = JSON.parse(text);
-  } catch (err) {
-    throw new DomainFileError([`not JSON: ${(err as Error).message}`]);
-  }
-  if (!isPlainObject(raw)) throw new DomainFileError(["not a JSON object"]);
-
-  for (const k of Object.keys(raw)) {
-    if (!["version", "domain", "party", "keys"].includes(k)) {
-      issues.push(`unknown field "${k}" (additions are a new format version)`);
-    }
-  }
-
-  if (raw["version"] !== DOMAIN_FILE_VERSION) {
-    issues.push(`"version" must be exactly "${DOMAIN_FILE_VERSION}"`);
-  }
-
-  const domain = raw["domain"];
-  if (typeof domain !== "string" || !isDomainName(domain)) {
-    issues.push(`"domain" must be a lowercase hostname (no scheme, no port, no path)`);
-  } else if (expectedDomain !== undefined && domain !== expectedDomain) {
-    issues.push(
-      `the file names domain "${domain}" but was requested for "${expectedDomain}"; refusing to store one party's file under another party's name`
-    );
-  }
-
-  const party = raw["party"];
-  if (typeof party !== "string" || party.trim().length === 0) {
-    issues.push(`"party" is required: the name the domain gives itself`);
-  }
-
-  const keys = Object.create(null) as Record<string, TrustedKey>;
-  const rawKeys = raw["keys"];
-  if (!isPlainObject(rawKeys) || Object.keys(rawKeys).length === 0) {
-    issues.push(`"keys" must be an object naming at least one key`);
-  } else {
-    for (const [name, entry] of Object.entries(rawKeys)) {
-      const where = `keys.${name}`;
-      if (!/^[A-Za-z0-9_.-]+$/.test(name) || /^[0-9]+$/.test(name)) {
-        issues.push(`${where}: key name must match [A-Za-z0-9_.-]+ with at least one non-digit`);
-        continue;
-      }
-      if (!isPlainObject(entry)) {
-        issues.push(`${where}: must be an object`);
-        continue;
-      }
-      for (const k of Object.keys(entry)) {
-        if (k !== "alg" && k !== "publicKey") issues.push(`${where}: unknown field "${k}"`);
-      }
-      const alg = entry["alg"];
-      const publicKey = entry["publicKey"];
-      if (alg !== "ed25519" && alg !== "es256") {
-        issues.push(`${where}: "alg" must be "ed25519" or "es256"`);
-        continue;
-      }
-      if (typeof publicKey !== "string" || publicKey.length === 0) {
-        issues.push(`${where}: "publicKey" is required and must be a non-empty string`);
-        continue;
-      }
-      const key: TrustedKey = { alg, publicKey };
-      if (keyObjectFor(key) === undefined) {
-        issues.push(
-          `${where}: key material does not decode as ${alg} (${alg === "es256" ? "SPKI DER for P-256" : "raw 32-byte key"}, standard base64)`
-        );
-        continue;
-      }
-      keys[name] = key;
-    }
-  }
-
-  if (issues.length > 0) throw new DomainFileError(issues);
-  return { version: DOMAIN_FILE_VERSION, domain: domain as string, party: (party as string).trim(), keys };
-}
-
-/**
- * Lowercase hex SHA-256 of the decoded publicKey bytes. For es256 this is
- * exactly the actor keyId (hex SHA-256 of the SPKI DER). Undefined when
- * the material does not decode, which parseDomainFile refuses anyway.
- */
-export function keyFingerprint(key: TrustedKey): string | undefined {
-  const material = decodeB64Strict(key.publicKey);
-  if (material === undefined) return undefined;
-  return createHash("sha256").update(material).digest("hex");
-}
-
-export interface DomainKeyRef {
-  name: string;
-  key: TrustedKey;
-  fingerprint: string;
-}
-
-/** Every key with its derived fingerprint, name order. */
-export function domainKeyRefs(file: DomainFile): DomainKeyRef[] {
-  const refs: DomainKeyRef[] = [];
-  for (const name of Object.keys(file.keys).sort()) {
-    const key = file.keys[name] as TrustedKey;
-    const fingerprint = keyFingerprint(key);
-    if (fingerprint !== undefined) refs.push({ name, key, fingerprint });
-  }
-  return refs;
-}
-
-export interface DomainDiff {
-  partyChanged?: { before: string; after: string };
-  added: DomainKeyRef[];
-  removed: DomainKeyRef[];
-  changed: { name: string; before: DomainKeyRef; after: DomainKeyRef }[];
-  unchanged: number;
-}
-
-/** What a re-pin would change, for showing before asking. */
-export function diffDomainFiles(before: DomainFile, after: DomainFile): DomainDiff {
-  const beforeRefs = new Map(domainKeyRefs(before).map((r) => [r.name, r]));
-  const afterRefs = new Map(domainKeyRefs(after).map((r) => [r.name, r]));
-  const diff: DomainDiff = { added: [], removed: [], changed: [], unchanged: 0 };
-  if (before.party !== after.party) diff.partyChanged = { before: before.party, after: after.party };
-  for (const [name, ref] of afterRefs) {
-    const prior = beforeRefs.get(name);
-    if (prior === undefined) diff.added.push(ref);
-    else if (prior.key.alg !== ref.key.alg || prior.key.publicKey !== ref.key.publicKey) {
-      diff.changed.push({ name, before: prior, after: ref });
-    } else diff.unchanged += 1;
-  }
-  for (const [name, ref] of beforeRefs) {
-    if (!afterRefs.has(name)) diff.removed.push(ref);
-  }
-  return diff;
-}
-
-/**
- * The check-report adapter: what `check --from` consults per recording.
- * Defined as an interface in check.ts so the check module (which also
- * builds verify.html) never imports the crypto this module uses; the CLI
- * hands the report builder this object.
- */
-export function checkDomain(file: DomainFile): CheckDomain {
-  const actorNames = new Map<string, string>();
-  for (const ref of domainKeyRefs(file)) {
-    if (ref.key.alg !== "es256") continue;
-    if (!actorNames.has(ref.fingerprint)) actorNames.set(ref.fingerprint, ref.name);
-  }
-  const sigKeys = domainKeyRefs(file)
-    .map((ref) => ({ name: ref.name, key: ref.key, keyObject: keyObjectFor(ref.key) }))
-    .filter((k) => k.keyObject !== undefined);
-
-  return {
-    domain: file.domain,
-    party: file.party,
-    keyCount: Object.keys(file.keys).length,
-    actorKeyName: (keyId: string): string | undefined => actorNames.get(keyId.toLowerCase()),
-    signatureKeyName: (targetSha256Hex: string, evidence: ReadonlyMap<string, Uint8Array>): string | undefined => {
-      // Deterministic: candidates in ascending content-hash order, keys in
-      // name order; the first verifying pair decides (SPEC §9.4 discipline).
-      for (const sha256Hex of [...evidence.keys()].sort()) {
-        const sig = parseSigFile(evidence.get(sha256Hex) as Uint8Array);
-        if (sig === undefined) continue;
-        for (const k of sigKeys) {
-          if (verifySigFile(sig, k.key, k.keyObject as NonNullable<typeof k.keyObject>, targetSha256Hex, decodeDigestBytes)) {
-            return k.name;
-          }
-        }
-      }
-      return undefined;
-    },
-  };
-}