@sanning/proof 0.14.0 → 0.16.0

package/dist/witness-lookup.js

@@ -0,0 +1,300 @@
+// The public-record (witness) lookup the CLI runs with `--gateways`
+// (evidence-bundle.md §5.5.6, v1.20, A24, D7): re-fetch each pack's witness on
+// the public record and report what it said. Moved here from `cli.ts`
+// (proof#200) so the CLI and a consumer that is not the CLI, the verify page,
+// a browser app, call the SAME implementation rather than each keeping its
+// own copy that can drift.
+//
+// Pure by the kernel's own rule (specs/architecture.md §3): the network call
+// is the one exception this module exists to hold, and it never runs unless a
+// caller hands in a gateway to ask. `options.fetchImpl` is the seam: where a
+// caller supplies one (a browser page's own `fetch`, or a test's fake), that
+// is the ONE this module calls; where none is given, it falls back to the
+// ambient global `fetch`, the same fallback `cli.ts` already applied at its
+// own call site before this module existed.
+//
+// `onChainHalf` and `witnessLine` are the CLI's own building blocks,
+// UNCHANGED (proof#200 is additive: the CLI's `case` output and exit codes are
+// byte-for-byte what they were). `lookupPublicRecord` is the new export:
+// one pack (or several) in, one four-state result out, with a pack's
+// `witness-cache.json` read as part of the pack rather than as a side file a
+// caller must remember to also pass in.
+import { verifyEvidenceBundle } from "./evidence.js";
+import { WITNESS_NOT_LOOKED_UP, renderWitnessLine } from "./case.js";
+import { checkWitnessCache, readWitnessCache, renderWitnessTime, } from "./witness-cache.js";
+function witnessTimeRow(t) {
+    return {
+        stamp_ref: t.cached.stampRef,
+        cached: { block_height: t.cached.blockHeight, block_time: t.cached.blockTime },
+        outcome: t.outcome,
+        answers: t.answers.map((a) => ({
+            gateway: a.gateway,
+            outcome: a.outcome,
+            block_height: a.blockHeight,
+            block_time: a.blockTime,
+        })),
+    };
+}
+/**
+ * Each pack's witnesses, re-fetched through `verifyEvidenceBundle`. Outside
+ * the case reading on purpose: `readCase` makes no network call, and neither
+ * does the verify page's case reading, so the case verdict stays the one both
+ * surfaces compute. This adds the half the reading names as not checked.
+ *
+ * Moved from `cli.ts` unchanged, apart from taking `fetchImpl` directly
+ * instead of a `Cli` stream (`io.fetchImpl ?? fetch`, the same fallback the
+ * CLI already applied at its own call site).
+ */
+export async function onChainHalf(packs, gateways, options = {}) {
+    if (gateways.length === 0)
+        return { checked: false, gateways: [], packs: [], verdict: "not_checked" };
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const rows = [];
+    const answered = new Set();
+    for (const [ref, bundle, cached] of packs) {
+        const result = await verifyEvidenceBundle(bundle, { gateways: [...gateways], fetchImpl });
+        const witnesses = [...result.checkpoints, ...(result.stamps ?? [])];
+        const row = {
+            ref,
+            witnesses: witnesses.length,
+            confirmed: 0,
+            mismatched: 0,
+            unreachable: 0,
+            not_checked: 0,
+        };
+        for (const w of witnesses) {
+            const rollup = w.onChain?.rollup ?? null;
+            if (rollup === "confirm")
+                row.confirmed++;
+            else if (rollup === "mismatch")
+                row.mismatched++;
+            else if (rollup === "unreachable")
+                row.unreachable++;
+            else
+                row.not_checked++;
+        }
+        // The witness times the pack's witness-cache.json gives, looked up where
+        // it gives any (5.6.6, v1.25, A30). A pack with no cache gets no key and
+        // no request.
+        const times = await checkWitnessCache(cached, gateways, fetchImpl);
+        if (times.length > 0)
+            row.witness_times = times.map(witnessTimeRow);
+        rows.push(row);
+        for (const w of witnesses) {
+            for (const outcome of w.onChain?.perGateway ?? []) {
+                if (outcome.outcome === "confirm" || outcome.outcome === "mismatch") {
+                    answered.add(outcome.gateway);
+                }
+            }
+        }
+        for (const t of times) {
+            for (const a of t.answers) {
+                if (a.outcome === "matches" || a.outcome === "differs")
+                    answered.add(a.gateway);
+            }
+        }
+    }
+    const verdict = rows.some((r) => r.mismatched > 0 || (r.witness_times ?? []).some((t) => t.outcome === "differs"))
+        ? "failed"
+        : rows.some((r) => r.witnesses === 0 || r.unreachable > 0 || r.not_checked > 0)
+            ? "undetermined"
+            : "confirmed";
+    return {
+        answered: gateways.filter((g) => answered.has(g)),
+        checked: true,
+        gateways: [...gateways],
+        packs: rows,
+        verdict,
+    };
+}
+// Distinct `[blockHeight, blockTime]` pairs, in time order.
+function distinctTimes(times) {
+    const seen = new Map();
+    for (const [h, t] of times)
+        seen.set(`${h}:${t}`, [h, t]);
+    return [...seen.values()].sort((a, b) => a[1] - b[1] || a[0] - b[0]);
+}
+// Only the keys that carry something: a line with no cached or recorded time
+// is the line 0.13.0 printed, field for field.
+function withTimes(line, cached, recorded) {
+    return {
+        ...line,
+        ...(cached.length > 0 ? { cached } : {}),
+        ...(recorded.length > 0 ? { recorded } : {}),
+    };
+}
+/**
+ * `cached` is every witness time the packs cache (5.6.6, v1.25, A30). Where no
+ * lookup ran, each is printed labelled not checked. Where one ran, each time
+ * the public record matched is printed as the record's, each time no lookup
+ * settled stays labelled not checked, and a time the record contradicts is the
+ * reason the line reads `differs`.
+ *
+ * Moved from `cli.ts` unchanged: same inputs, same three states
+ * (`WitnessState`), same rendering. The CLI's `case` command still calls this
+ * exact function, so its witness line is unchanged.
+ */
+export function witnessLine(onChain, cached = []) {
+    if (!onChain.checked) {
+        return withTimes({
+            state: WITNESS_NOT_LOOKED_UP.state,
+            reasons: [...WITNESS_NOT_LOOKED_UP.reasons],
+            services: [...WITNESS_NOT_LOOKED_UP.services],
+        }, distinctTimes(cached.map((c) => [c.blockHeight, c.blockTime])), []);
+    }
+    const services = [...(onChain.answered ?? [])];
+    const rows = onChain.packs;
+    const times = rows.flatMap((r) => r.witness_times ?? []);
+    const unsettled = distinctTimes(times
+        .filter((t) => t.outcome === "not_checked")
+        .map((t) => [t.cached.block_height, t.cached.block_time]));
+    const recorded = distinctTimes(times
+        .filter((t) => t.outcome === "matches")
+        .flatMap((t) => t.answers.filter((a) => a.outcome === "matches"))
+        .map((a) => [a.block_height, a.block_time]));
+    const contradicted = [];
+    for (const t of times) {
+        if (t.outcome !== "differs")
+            continue;
+        const a = t.answers.find((x) => x.outcome === "differs");
+        const reason = `a pack dates the witness ${renderWitnessTime(t.cached.block_height, t.cached.block_time)}` +
+            `, and the public record dates it ${renderWitnessTime(a.block_height, a.block_time)}`;
+        if (!contradicted.includes(reason))
+            contradicted.push(reason);
+    }
+    if (onChain.verdict === "failed") {
+        return withTimes({ state: "differs", reasons: contradicted, services }, unsettled, recorded);
+    }
+    if (onChain.verdict === "confirmed") {
+        return withTimes({ state: "confirmed", reasons: [], services }, unsettled, recorded);
+    }
+    const reasons = [];
+    if (rows.some((r) => r.witnesses === 0))
+        reasons.push("a pack names no witness");
+    if (rows.some((r) => r.unreachable > 0)) {
+        reasons.push("a lookup did not settle: the service could not be reached, or it " + "holds no such witness yet");
+    }
+    if (rows.some((r) => r.not_checked > 0)) {
+        reasons.push("no lookup is made for a witness kind a pack names");
+    }
+    return withTimes({ state: "not_checked", reasons, services }, unsettled, recorded);
+}
+/**
+ * The public-record lookup the CLI runs with `--gateways`, exported so a
+ * consumer that is not the CLI can run the SAME lookup rather than copy it
+ * (proof#200; the copy this closes is verify-page#70's `src/lib/verify.ts`).
+ *
+ * `packs` is every pack in the drop being read; `gateways` is empty for an
+ * offline reading, which never makes a network call and always answers
+ * `not_checked` or `no_public_record`. `options.fetchImpl` is the one seam a
+ * network call goes through, a browser page supplies its own `fetchImpl`;
+ * with none given this falls back to the ambient global `fetch`, so a
+ * browser page and a test can each supply their own and Node's `fetch` is
+ * never assumed where a caller passed something else.
+ *
+ * `state` is `confirmed` only about the BYTES: the public record holds what a
+ * pack names. It says nothing about whether the pack itself verifies (its
+ * wrapper signature, its `body_hash`), and a caller must never show
+ * `confirmed` apart from the pack's own verdict (proof#201).
+ *
+ * Never throws. Every input, including a malformed pack, a non-string
+ * gateway, or a `fetchImpl` that itself misbehaves, is read as untrusted, and
+ * anything this function or what it calls cannot make sense of settles as
+ * `not_checked` rather than escape as an exception.
+ */
+export async function lookupPublicRecord(packs, gateways, options = {}) {
+    try {
+        // Nothing to look up: zero packs means the CALLER handed in nothing to
+        // check, which is not the same claim as "the packs it handed in name no
+        // witness" (`no_public_record`, below). Checked first, and unconditionally,
+        // so a caller than mishandles an empty drop never reads it as confirmed.
+        if (packs.length === 0) {
+            const reasons = [...WITNESS_NOT_LOOKED_UP.reasons];
+            return {
+                state: "not_checked",
+                reasons,
+                services: [],
+                rendered: renderWitnessLine({ state: "not_checked", reasons, services: [] }),
+            };
+        }
+        const caches = packs.map((p) => readWitnessCache(p.bundle, p.witnessCache ?? null));
+        const rows = packs.map((p, i) => [
+            p.ref,
+            p.bundle,
+            caches[i],
+        ]);
+        const onChain = await onChainHalfForWitnessCount(rows, gateways, options);
+        const line = witnessLine(onChain.half, caches.flat());
+        // "No public record yet": every pack this lookup was handed names ZERO
+        // witnesses, so there is nothing the public record could confirm or
+        // contradict. This holds independently of whether a lookup ran, an
+        // offline reading of a fresh, unstamped pack is exactly as much "nothing to
+        // check yet" as an online one, and it is computed from the SAME witness
+        // count `onChainHalf` derives from `verifyEvidenceBundle`'s own parse, never
+        // a second reading of the bundle.
+        //
+        // A pack that does NOT verify (a broken wrapper signature, `bundle: null`,
+        // garbage, an unrecognised body type) also names zero witnesses, by
+        // construction: `verifyEvidenceBundle` never reports a checkpoint or a
+        // stamp for a bundle it could not authenticate. That is not "nothing to
+        // check yet", it is a pack this lookup could not read, so `no_public_record`
+        // is reserved for a pack whose wrapper genuinely verifies
+        // (`signatureOk && bodyHashOk && status !== "failed"`) and that carries no
+        // cached witness time either (a cache entry names something to check).
+        // Anything else that would otherwise qualify reads `not_checked` instead.
+        const noWitnesses = onChain.witnessCounts.every((n) => n === 0);
+        const everyPackVerifies = onChain.verifies.every((v) => v);
+        const noCacheRead = caches.every((c) => c.length === 0);
+        const canBeNoPublicRecord = noWitnesses && everyPackVerifies && noCacheRead;
+        const state = line.state === "not_checked" && canBeNoPublicRecord ? "no_public_record" : line.state;
+        return {
+            state,
+            reasons: line.reasons,
+            services: line.services,
+            ...(line.cached ? { cached: line.cached } : {}),
+            // `recorded` is a claim about the public record confirming a cached
+            // time; it never rides alongside anything but a `confirmed` verdict, so
+            // a pack whose wrapper does not verify can never surface a cached time
+            // as though the record had confirmed it.
+            ...(state === "confirmed" && line.recorded ? { recorded: line.recorded } : {}),
+            rendered: renderWitnessLine({ ...line, state: state === "no_public_record" ? "not_checked" : state }),
+        };
+    }
+    catch (e) {
+        // Untrusted input all the way down: a gateway's answer, a pack's shape, a
+        // caller's `fetchImpl`. Anything this function or what it calls cannot
+        // make sense of settles `not_checked` rather than throw out of an export a
+        // browser page calls directly.
+        const reason = e instanceof Error ? `the lookup did not settle: ${e.message}` : "the lookup did not settle";
+        const reasons = [reason];
+        return {
+            state: "not_checked",
+            reasons,
+            services: [],
+            rendered: renderWitnessLine({ state: "not_checked", reasons, services: [] }),
+        };
+    }
+}
+// `onChainHalf` short-circuits to `{ checked: false, packs: [] }` with no
+// gateways, which is right for the CLI (nothing to print per pack) but leaves
+// `lookupPublicRecord` unable to tell "no gateways" from "no witnesses" for an
+// OFFLINE reading. This wrapper reads each pack's witness count, and whether
+// its wrapper verifies, the same way `onChainHalf` does, via
+// `verifyEvidenceBundle`: an OFFLINE parse (`gateways: []`), so it costs no
+// extra request whether or not a lookup runs, and `verifies` is never itself
+// a statement about the public record, only about the pack's own signature
+// and `body_hash`.
+async function onChainHalfForWitnessCount(packs, gateways, options) {
+    const witnessCounts = [];
+    const verifies = [];
+    for (const [, bundle] of packs) {
+        const result = await verifyEvidenceBundle(bundle, { gateways: [] });
+        witnessCounts.push(result.checkpoints.length + (result.stamps?.length ?? 0));
+        verifies.push(result.signatureOk && result.bodyHashOk && result.status !== "failed");
+    }
+    if (gateways.length > 0) {
+        const half = await onChainHalf(packs, gateways, options);
+        return { half, witnessCounts, verifies };
+    }
+    return { half: { checked: false, gateways: [], packs: [], verdict: "not_checked" }, witnessCounts, verifies };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanning/proof",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "TypeScript kernel of the Sanning verification stack: RFC 8785 (JCS) canonicalization, SHA-256, and Ed25519 verification for Verifiable Event Envelopes. Full-family verifier (inline + external commitment); accepts sanning.agent/v1 and sanning.events/v2. Conformance-gated byte-for-byte against the test-vectors corpus.",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
   "devDependencies": {
     "@types/node": "^20.19.41",
     "typescript": "^5.4.0",
-    "vitest": "^2.0.0"
+    "vitest": "^4.1.11"
   },
   "publishConfig": {
     "access": "public"

package/src/cli.ts

@@ -58,8 +58,6 @@ type ChainOutcome = ChainReading | { unreadable: string };
 import type { ChainReading } from "./chain.js";
 import {
   VERDICT_DISPLAY_TITLES,
-  WITNESS_NOT_LOOKED_UP,
-  type WitnessLine,
   caseReliance,
   readCase,
   renderCaseNote,
@@ -83,13 +81,15 @@ import { fileMatchToJson, matchCaseFiles, matchFiles, renderFileMatch } from "./
 import type { OfferedFile } from "./file-match.js";
 import {
   type CachedWitnessTime,
-  type WitnessTimeAnswer,
-  type WitnessTimeCheck,
   WITNESS_CACHE_NAME,
-  checkWitnessCache,
   readWitnessCache,
-  renderWitnessTime,
 } from "./witness-cache.js";
+// The public-record (witness) lookup this command runs with `--gateways`:
+// moved to its own pure module (proof#200) so a consumer that is not this CLI,
+// the verify page, can call the SAME implementation. `onChainHalf` and
+// `witnessLine` are this command's own two building blocks, unchanged; see
+// `./witness-lookup.ts` for the exported entry point, `lookupPublicRecord`.
+import { type OnChainHalf, onChainHalf, witnessLine } from "./witness-lookup.js";
 import type { AttestationRecord, EvidenceBundle, EvidenceBundleResult, ExportResult } from "./evidence.js";
 import { checkDeclaration, renderDeclarationSummary, renderNote } from "./declaration.js";
 import { completenessNotes, gradePack, renderCause } from "./grading.js";
@@ -2033,208 +2033,6 @@ function jsonText(v: unknown): string {
   return JSON.stringify(sortKeys(v), null, 2);
 }
 
-interface OnChainRow {
-  ref: string;
-  witnesses: number;
-  confirmed: number;
-  mismatched: number;
-  unreachable: number;
-  not_checked: number;
-  /** Present only where the pack caches a witness time (5.6.6, v1.25, A30). */
-  witness_times?: WitnessTimeRow[];
-}
-
-interface WitnessTimeRow {
-  stamp_ref: string;
-  cached: { block_height: number; block_time: number };
-  outcome: WitnessTimeCheck["outcome"];
-  answers: {
-    gateway: string;
-    outcome: WitnessTimeAnswer["outcome"];
-    block_height: number | null;
-    block_time: number | null;
-  }[];
-}
-
-function witnessTimeRow(t: WitnessTimeCheck): WitnessTimeRow {
-  return {
-    stamp_ref: t.cached.stampRef,
-    cached: { block_height: t.cached.blockHeight, block_time: t.cached.blockTime },
-    outcome: t.outcome,
-    answers: t.answers.map((a) => ({
-      gateway: a.gateway,
-      outcome: a.outcome,
-      block_height: a.blockHeight,
-      block_time: a.blockTime,
-    })),
-  };
-}
-
-interface OnChainHalf {
-  /** Present only where a lookup ran: each gateway that answered, in the order given. */
-  answered?: string[];
-  checked: boolean;
-  gateways: string[];
-  packs: OnChainRow[];
-  verdict: "not_checked" | "confirmed" | "failed" | "undetermined";
-}
-
-// Each pack's witnesses, re-fetched through `verifyEvidenceBundle`. Outside the
-// case reading on purpose: `readCase` makes no network call, and neither does
-// the verify page's case reading, so the case verdict stays the one both
-// surfaces compute. This adds the half the reading names as not checked.
-async function onChainHalf(
-  packs: readonly [string, unknown, readonly CachedWitnessTime[]][],
-  gateways: string[],
-  io: Cli,
-): Promise<OnChainHalf> {
-  if (gateways.length === 0) return { checked: false, gateways: [], packs: [], verdict: "not_checked" };
-  const rows: OnChainRow[] = [];
-  const answered = new Set<string>();
-  for (const [ref, bundle, cached] of packs) {
-    const result = await verifyEvidenceBundle(bundle, {
-      gateways,
-      ...(io.fetchImpl ? { fetchImpl: io.fetchImpl } : {}),
-    });
-    const witnesses = [...result.checkpoints, ...(result.stamps ?? [])];
-    const row: OnChainRow = {
-      ref,
-      witnesses: witnesses.length,
-      confirmed: 0,
-      mismatched: 0,
-      unreachable: 0,
-      not_checked: 0,
-    };
-    for (const w of witnesses) {
-      const rollup = w.onChain?.rollup ?? null;
-      if (rollup === "confirm") row.confirmed++;
-      else if (rollup === "mismatch") row.mismatched++;
-      else if (rollup === "unreachable") row.unreachable++;
-      else row.not_checked++;
-    }
-    // The witness times the pack's witness-cache.json gives, looked up where
-    // it gives any (5.6.6, v1.25, A30). A pack with no cache gets no key and
-    // no request.
-    const times = await checkWitnessCache(cached, gateways, io.fetchImpl ?? fetch);
-    if (times.length > 0) row.witness_times = times.map(witnessTimeRow);
-    rows.push(row);
-    for (const w of witnesses) {
-      for (const outcome of w.onChain?.perGateway ?? []) {
-        if (outcome.outcome === "confirm" || outcome.outcome === "mismatch") {
-          answered.add(outcome.gateway);
-        }
-      }
-    }
-    for (const t of times) {
-      for (const a of t.answers) {
-        if (a.outcome === "matches" || a.outcome === "differs") answered.add(a.gateway);
-      }
-    }
-  }
-  const verdict = rows.some(
-    (r) => r.mismatched > 0 || (r.witness_times ?? []).some((t) => t.outcome === "differs"),
-  )
-    ? "failed"
-    : rows.some((r) => r.witnesses === 0 || r.unreachable > 0 || r.not_checked > 0)
-      ? "undetermined"
-      : "confirmed";
-  return {
-    answered: gateways.filter((g) => answered.has(g)),
-    checked: true,
-    gateways: [...gateways],
-    packs: rows,
-    verdict,
-  };
-}
-
-/**
- * The witness line (evidence-bundle 5.5.6 v1.20, A24, D7) from the on-chain
- * half: `confirmed` is `confirmed`, `not_checked` and `undetermined` are
- * `not_checked` with the reason, and `failed` is `differs`. It never moves the
- * headline.
- */
-// Distinct `[blockHeight, blockTime]` pairs, in time order.
-function distinctTimes(times: Iterable<[number, number]>): [number, number][] {
-  const seen = new Map<string, [number, number]>();
-  for (const [h, t] of times) seen.set(`${h}:${t}`, [h, t]);
-  return [...seen.values()].sort((a, b) => a[1] - b[1] || a[0] - b[0]);
-}
-
-// Only the keys that carry something: a line with no cached or recorded time
-// is the line 0.13.0 printed, field for field.
-function withTimes(
-  line: WitnessLine,
-  cached: [number, number][],
-  recorded: [number, number][],
-): WitnessLine {
-  return {
-    ...line,
-    ...(cached.length > 0 ? { cached } : {}),
-    ...(recorded.length > 0 ? { recorded } : {}),
-  };
-}
-
-/**
- * `cached` is every witness time the packs cache (5.6.6, v1.25, A30). Where no
- * lookup ran, each is printed labelled not checked. Where one ran, each time
- * the public record matched is printed as the record's, each time no lookup
- * settled stays labelled not checked, and a time the record contradicts is the
- * reason the line reads `differs`.
- */
-export function witnessLine(onChain: OnChainHalf, cached: readonly CachedWitnessTime[] = []): WitnessLine {
-  if (!onChain.checked) {
-    return withTimes(
-      {
-        state: WITNESS_NOT_LOOKED_UP.state,
-        reasons: [...WITNESS_NOT_LOOKED_UP.reasons],
-        services: [...WITNESS_NOT_LOOKED_UP.services],
-      },
-      distinctTimes(cached.map((c): [number, number] => [c.blockHeight, c.blockTime])),
-      [],
-    );
-  }
-  const services = [...(onChain.answered ?? [])];
-  const rows = onChain.packs;
-  const times = rows.flatMap((r) => r.witness_times ?? []);
-  const unsettled = distinctTimes(
-    times
-      .filter((t) => t.outcome === "not_checked")
-      .map((t): [number, number] => [t.cached.block_height, t.cached.block_time]),
-  );
-  const recorded = distinctTimes(
-    times
-      .filter((t) => t.outcome === "matches")
-      .flatMap((t) => t.answers.filter((a) => a.outcome === "matches"))
-      .map((a): [number, number] => [a.block_height as number, a.block_time as number]),
-  );
-  const contradicted: string[] = [];
-  for (const t of times) {
-    if (t.outcome !== "differs") continue;
-    const a = t.answers.find((x) => x.outcome === "differs")!;
-    const reason =
-      `a pack dates the witness ${renderWitnessTime(t.cached.block_height, t.cached.block_time)}` +
-      `, and the public record dates it ${renderWitnessTime(a.block_height as number, a.block_time as number)}`;
-    if (!contradicted.includes(reason)) contradicted.push(reason);
-  }
-  if (onChain.verdict === "failed") {
-    return withTimes({ state: "differs", reasons: contradicted, services }, unsettled, recorded);
-  }
-  if (onChain.verdict === "confirmed") {
-    return withTimes({ state: "confirmed", reasons: [], services }, unsettled, recorded);
-  }
-  const reasons: string[] = [];
-  if (rows.some((r) => r.witnesses === 0)) reasons.push("a pack names no witness");
-  if (rows.some((r) => r.unreachable > 0)) {
-    reasons.push(
-      "a lookup did not settle: the service could not be reached, or it " +
-        "holds no such witness yet",
-    );
-  }
-  if (rows.some((r) => r.not_checked > 0)) {
-    reasons.push("no lookup is made for a witness kind a pack names");
-  }
-  return withTimes({ state: "not_checked", reasons, services }, unsettled, recorded);
-}
 
 /**
  * The case verdict's code, moved only by an on-chain half that was asked for:
@@ -2513,7 +2311,7 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
   const onChain = await onChainHalf(
     bundles.map(([p, bundle], i): [string, unknown, CachedWitnessTime[]] => [p.ref, bundle, caches[i]!]),
     gateways,
-    io,
+    { ...(io.fetchImpl ? { fetchImpl: io.fetchImpl } : {}) },
   );
   const witness = witnessLine(onChain, caches.flat());
   const code = caseExitCode(reading.verdict, onChain.verdict);