@colophon-claims/verify 0.0.0 → 0.2.0

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Keep this check ahead of every package import. A reader on an unsupported
+// machine should get one actionable answer, not a loader failure from the
+// verification dependency graph.
+const nodeMajor = Number(process.versions.node.split(".", 1)[0]);
+if (!Number.isInteger(nodeMajor) || nodeMajor < 22) {
+    process.stderr.write(`Colophon Verify requires Node 22 or newer; this machine is running Node ${process.versions.node}.\n`);
+    process.stderr.write("Install a current Node 22 LTS release, then run the same command again.\n");
+    process.exitCode = 2;
+}
+else {
+    const { runVerifierCli } = await import("./cli.js");
+    const result = await runVerifierCli(process.argv.slice(2));
+    if (result.stdout !== "")
+        process.stdout.write(result.stdout);
+    if (result.stderr !== "")
+        process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,14 @@
+import { type PublicBundleVerificationResult, type VerifyPublicBundleDeps } from "./verify.js";
+export { VERIFIER_VERSION } from "./version.js";
+export interface VerifierCliResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface VerifierCliDeps {
+    readonly verify?: (bundleDir: string, options?: VerifyPublicBundleDeps) => Promise<PublicBundleVerificationResult>;
+    /** Test seam for the trust-material files the flags name. Defaults to the real filesystem. */
+    readonly readFile?: (path: string) => Uint8Array;
+}
+export declare function renderVerifiedBundle(result: PublicBundleVerificationResult): string;
+export declare function runVerifierCli(args: readonly string[], deps?: VerifierCliDeps): Promise<VerifierCliResult>;

package/dist/cli.js

@@ -0,0 +1,205 @@
+import { readFileSync } from "node:fs";
+import { SUPPORTED_BUNDLE_FORMATS } from "./manifest.js";
+import { EVIDENCE_NATIVE_BUNDLE_V5_CHECKS } from "@jinn-network/benchmarking-evidence";
+import { PUBLIC_BUNDLE_VERIFICATION_CHECKS, PUBLIC_BUNDLE_V6_CHECKS } from "./reader-instructions.js";
+import { verifyPublicBundle } from "./verify.js";
+import { VERIFIER_VERSION } from "./version.js";
+export { VERIFIER_VERSION } from "./version.js";
+function usage() {
+    return "Usage: colophon-verify <bundle> [--json] [--tsa-root <file>]... [--ots-headers <file>]...\n"
+        + "  --tsa-root     RFC 3161 trust anchor, DER or PEM. Repeatable.\n"
+        + "  --ots-headers  Bitcoin block headers, one \"<height>:<80-byte-hex>\" per line. Repeatable.\n"
+        + "Trust material is yours, not the bundle's: with none supplied a well-formed anchor reports\n"
+        + "present rather than verified, and none ships with this tool.\n"
+        + "Exit 0: valid bundle; 1: invalid bundle; 2: usage or operational failure.\n"
+        + "Protocol identifiers name https://spec.jinn.network/…. That origin is not hosted yet. Verification uses exact platform bytes from npm.\n";
+}
+// ---------------------------------------------------------------------------
+// Human rendering
+// ---------------------------------------------------------------------------
+function anchoredValue(entry) {
+    const facts = entry.facts;
+    if (typeof facts?.genTime === "string")
+        return facts.genTime;
+    if (typeof facts?.blockHeight === "number")
+        return `block ${facts.blockHeight}`;
+    return undefined;
+}
+/** What THIS reader did about the time basis, stated separately from what the bytes say. §8: the
+ * verifier's own report always adds its evaluation — whose material validated the time basis, or
+ * that none was supplied. */
+function evaluationNote(entry) {
+    if (entry.status === "verified") {
+        // The evaluated instant is reported only where it adds something the head line does not: for a
+        // chain-time proof it is the block's own time, which the height alone never gives.
+        const evaluated = entry.time !== undefined && entry.time !== anchoredValue(entry)
+            ? ` — ${entry.time}`
+            : "";
+        return `time basis evaluated against trust material you supplied${evaluated}`;
+    }
+    if (entry.status === "pending")
+        return entry.reason ?? "no chain attestation yet";
+    if (entry.status === "invalid")
+        return entry.reason ?? "the proof does not verify";
+    // Exhaustive over the four proof statuses: `present` is the only one left. A fifth member of
+    // ANCHOR_PROOF_STATUSES fails here rather than silently inheriting this note.
+    entry.status;
+    // `present` with material supplied is a different disclosure from `present` with none: this
+    // reader did have material for the profile, and it did not carry this anchor to `verified`.
+    return entry.trustMaterial === "supplied"
+        ? "time basis not evaluated: the trust material you supplied does not verify this anchor"
+        : "time basis not evaluated: no trust material supplied";
+}
+function renderAnchor(entry) {
+    const value = anchoredValue(entry);
+    const head = [
+        `  ${entry.subject ?? "unresolved"} anchor`,
+        entry.timeBasis ?? "unknown time basis",
+        entry.status,
+        ...(value === undefined ? [] : [value]),
+    ].join(" · ");
+    return `${head}\n    ${evaluationNote(entry)}\n    record ${entry.recordSha256}`;
+}
+function renderSubject(subject) {
+    if (subject.outcome === "declared-but-absent") {
+        return `  ${subject.subject}: declared-but-absent — this run declared `
+            + `${subject.declaredProfiles?.join(", ") ?? "an anchor provider"} and the bundle carries no matching anchor`;
+    }
+    if (subject.outcome === "absent")
+        return `  ${subject.subject}: absent — no anchor was carried and none was declared`;
+    return `  ${subject.subject}: anchored`;
+}
+function renderAnchorReport(report) {
+    const anchors = report.anchors.length === 0
+        ? "  no anchor records carried"
+        : report.anchors.map(renderAnchor).join("\n");
+    return `\nAnchors\n${anchors}\n\nAnchor subjects\n${report.subjects.map(renderSubject).join("\n")}\n`;
+}
+export function renderVerifiedBundle(result) {
+    const checks = result.checks.map((check) => `${check.padEnd(24)}passed`).join("\n");
+    const totalChecks = result.format === "benchmark-product-public-bundle/5"
+        ? EVIDENCE_NATIVE_BUNDLE_V5_CHECKS.length
+        : result.format === "benchmark-product-public-bundle/6"
+            ? PUBLIC_BUNDLE_V6_CHECKS.length
+            : PUBLIC_BUNDLE_VERIFICATION_CHECKS.length;
+    const identity = result.identity.startsWith("sha256:") ? result.identity : `sha256:${result.identity}`;
+    const anchors = "anchors" in result && result.anchors !== undefined
+        ? renderAnchorReport(result.anchors)
+        : "";
+    const anchorLimits = anchors === ""
+        ? ""
+        : "\nAn anchor dates the bytes it covers and says nothing else about the run: not\nthat results were produced after it, and not that the anchoring authority is\nindependent of the bundle's owner.";
+    return `Verified: ${result.checks.length} of ${totalChecks} checks passed
+Bundle: ${identity}
+Format: ${result.format}
+
+${checks}
+${anchors}
+This checks the bundle's integrity, evidence closure, calculations, report,
+and claim consistency. It does not prove that the machine that produced the
+bundle was honest or that the compared identities are independent parties.${anchorLimits}
+No files were uploaded.
+Protocol identifiers name https://spec.jinn.network/…. That origin is not hosted yet.
+Verification uses the exact platform bytes installed from npm.
+`;
+}
+// ---------------------------------------------------------------------------
+// Verifier-side trust material (anchor-evidence design §8 step 3)
+// ---------------------------------------------------------------------------
+const PEM_BLOCK = /-----BEGIN CERTIFICATE-----([A-Za-z0-9+/=\s]+?)-----END CERTIFICATE-----/g;
+/** Accepts a DER file as-is, or one or more PEM blocks. Nothing here validates the certificate;
+ * that is the chain verifier's job, and an operator naming a file they chose is not an assertion
+ * this tool second-guesses. */
+function readTrustAnchors(bytes) {
+    const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+    const blocks = [...text.matchAll(PEM_BLOCK)];
+    if (blocks.length === 0)
+        return [bytes];
+    return blocks.map((block) => new Uint8Array(Buffer.from(block[1].replace(/\s+/g, ""), "base64")));
+}
+const HEADER_LINE = /^([0-9]+):([0-9a-fA-F]{160})$/;
+function readBlockHeaders(bytes, path) {
+    const lines = new TextDecoder("utf-8", { fatal: true }).decode(bytes)
+        .split("\n").map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#"));
+    return lines.map((line) => {
+        const match = HEADER_LINE.exec(line);
+        if (match === null) {
+            throw new Error(`${path}: expected "<height>:<160 hex characters>" per line, got "${line}"`);
+        }
+        return {
+            height: Number.parseInt(match[1], 10),
+            header: new Uint8Array(Buffer.from(match[2].toLowerCase(), "hex")),
+        };
+    });
+}
+function parseArguments(args) {
+    const positional = [];
+    const tsaRoots = [];
+    const otsHeaders = [];
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--tsa-root" || arg === "--ots-headers") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--"))
+                return undefined;
+            (arg === "--tsa-root" ? tsaRoots : otsHeaders).push(value);
+            index += 1;
+        }
+        else if (arg.startsWith("--")) {
+            return undefined;
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (positional.length !== 1)
+        return undefined;
+    return { bundleDir: positional[0], json, tsaRoots, otsHeaders };
+}
+function buildAnchorTrust(parsed, readFile) {
+    const trustAnchorsDer = parsed.tsaRoots.flatMap((path) => readTrustAnchors(readFile(path)));
+    const blockHeaders = parsed.otsHeaders.flatMap((path) => readBlockHeaders(readFile(path), path));
+    if (trustAnchorsDer.length === 0 && blockHeaders.length === 0)
+        return undefined;
+    return {
+        ...(trustAnchorsDer.length === 0 ? {} : { rfc3161: { trustAnchorsDer } }),
+        ...(blockHeaders.length === 0 ? {} : { opentimestamps: { blockHeaders } }),
+    };
+}
+export async function runVerifierCli(args, deps = {}) {
+    const parsed = parseArguments(args);
+    if (parsed === undefined)
+        return { exitCode: 2, stdout: "", stderr: usage() };
+    let anchorTrust;
+    try {
+        anchorTrust = buildAnchorTrust(parsed, deps.readFile ?? ((path) => new Uint8Array(readFileSync(path))));
+    }
+    catch (cause) {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: `colophon-verify: ${cause instanceof Error ? cause.message : String(cause)}\n`,
+        };
+    }
+    try {
+        const result = await (deps.verify ?? verifyPublicBundle)(parsed.bundleDir, anchorTrust === undefined ? {} : { anchorTrust });
+        const stdout = parsed.json
+            ? `${JSON.stringify({ ok: true, verifierVersion: VERIFIER_VERSION, supportedFormats: SUPPORTED_BUNDLE_FORMATS, ...result })}\n`
+            : renderVerifiedBundle(result);
+        return { exitCode: 0, stdout, stderr: "" };
+    }
+    catch (cause) {
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        const code = (cause !== null && typeof cause === "object" && "code" in cause)
+            ? String(cause.code) : "environment";
+        const stdout = parsed.json
+            ? `${JSON.stringify({ ok: false, verifierVersion: VERIFIER_VERSION, supportedFormats: SUPPORTED_BUNDLE_FORMATS, code, message: error.message })}\n`
+            : "";
+        const stderr = parsed.json ? "" : `colophon-verify: ${error.message}\n`;
+        return { exitCode: code === "record-integrity" ? 1 : 2, stdout, stderr };
+    }
+}

package/dist/comparison.d.ts

@@ -0,0 +1,64 @@
+import { type BenchmarkRecord, type MatrixRecord } from "@jinn-network/benchmarking-records";
+import type { BundleAssemblyCell } from "./schema.js";
+export interface PublicComparisonTask {
+    readonly digest: string;
+    readonly profileUri: string;
+    readonly label: string;
+    readonly summary: string;
+    readonly evidencePath: string;
+}
+export interface PublicComparisonOutput {
+    readonly name: string;
+    readonly sha256: string;
+    readonly summary: string;
+    readonly evidencePath: string;
+}
+export interface PublicComparisonVerdict {
+    readonly evaluator: string;
+    readonly verdict: "pass" | "fail" | "inconclusive";
+    readonly measurements: Readonly<Record<string, string | number | boolean>>;
+    readonly evidencePath: string;
+}
+export interface PublicComparisonCell {
+    readonly cellKey: string;
+    readonly taskDigest: string;
+    readonly armId: string;
+    readonly replicate: number;
+    readonly outcome: MatrixRecord["cells"][number]["outcome"];
+    readonly outputSummary: string;
+    readonly primaryScore?: {
+        readonly name: "solverBrier";
+        readonly value: string;
+        readonly direction: "lower-is-better";
+    };
+    readonly outputs: readonly PublicComparisonOutput[];
+    readonly verdicts: readonly PublicComparisonVerdict[];
+    readonly evidencePaths: readonly string[];
+}
+export interface PublicDescriptiveComparison {
+    readonly kind: "paired-measurement";
+    readonly measurement: "solverBrier";
+    readonly direction: "lower-is-better";
+    readonly firstArm: string;
+    readonly secondArm: string;
+    readonly pairedCells: number;
+    readonly lowerByFirst: number;
+    readonly lowerBySecond: number;
+    readonly ties: number;
+    readonly formalWinner: false;
+}
+export interface PublicComparisonView {
+    readonly profile: "colophon-public-comparison/1";
+    readonly sampleKind?: "bundled-prediction";
+    readonly tasks: readonly PublicComparisonTask[];
+    readonly arms: readonly string[];
+    readonly cells: readonly PublicComparisonCell[];
+    readonly descriptiveComparison?: PublicDescriptiveComparison;
+}
+export interface DerivePublicComparisonInput {
+    readonly benchmark: BenchmarkRecord;
+    readonly matrix: MatrixRecord;
+    readonly assemblyCells: readonly BundleAssemblyCell[];
+    readonly recordBytes: ReadonlyMap<string, Uint8Array>;
+}
+export declare function derivePublicComparison(input: DerivePublicComparisonInput): PublicComparisonView;

package/dist/comparison.js

@@ -0,0 +1,235 @@
+import { itemTaskDigest } from "@jinn-network/benchmarking-records";
+import { PREDICTION_FORECAST_PROFILE_URI, REPOSITORY_WORK_PROFILE_URI, } from "@jinn-network/task-execution-profiles";
+import { TaskSpecificationSchema } from "@jinn-network/task-execution-protocol";
+import { INSPECT_TASK_PROFILE_URI } from "./profile/artifacts.js";
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const SHA256 = /^[a-f0-9]{64}$/u;
+const SAMPLE_BENCHMARK_NAME = "bundled-prediction-sample";
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function bounded(value, maximum = 480) {
+    const normalized = value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, " ").replace(/\s+/gu, " ").trim();
+    const points = Array.from(normalized);
+    return points.length <= maximum ? normalized : `${points.slice(0, maximum - 1).join("")}…`;
+}
+function exactJson(bytes, label) {
+    try {
+        return JSON.parse(decoder.decode(bytes));
+    }
+    catch {
+        throw new TypeError(`${label} is not valid UTF-8 JSON`);
+    }
+}
+function requiredRecord(records, sha256, role) {
+    if (!SHA256.test(sha256))
+        throw new TypeError(`${role} has an invalid digest`);
+    const bytes = records.get(sha256);
+    if (bytes === undefined)
+        throw new TypeError(`${role} ${sha256} is absent from the authenticated record closure`);
+    return bytes;
+}
+function percentage(probability) {
+    const numeric = Number(probability);
+    if (!Number.isFinite(numeric))
+        return probability;
+    const percent = numeric * 100;
+    return `${Number.isInteger(percent) ? String(percent) : percent.toFixed(1)}% Yes`;
+}
+function taskProjection(digest, bytes, bundledPredictionSample) {
+    const parsed = TaskSpecificationSchema.parse(exactJson(bytes, `Task ${digest}`));
+    const profileUri = parsed.profile.uri ?? "unprofiled";
+    const payload = isObject(parsed.payload) ? parsed.payload : {};
+    if (profileUri === PREDICTION_FORECAST_PROFILE_URI) {
+        const forecast = isObject(payload["forecast"]) ? payload["forecast"] : {};
+        const question = typeof forecast["question"] === "string" ? forecast["question"] : `Prediction task ${digest.slice(0, 12)}`;
+        const consensus = typeof forecast["consensusProbabilityYes"] === "string" ? forecast["consensusProbabilityYes"] : undefined;
+        const syntheticOutcome = bundledPredictionSample && consensus !== undefined
+            ? (Number(consensus) >= 0.5 ? "Yes" : "No")
+            : undefined;
+        const summary = consensus === undefined
+            ? "Forecast a probability for the declared outcome."
+            : bundledPredictionSample
+                ? `Sample consensus input: ${percentage(consensus)}. Synthetic sample resolution: ${syntheticOutcome}.`
+                : `Consensus reference at observation: ${percentage(consensus)}.`;
+        return {
+            task: {
+                digest,
+                profileUri,
+                label: bounded(question, 180),
+                summary,
+                evidencePath: `records/${digest}.bin`,
+            },
+            profileUri,
+        };
+    }
+    if (profileUri === REPOSITORY_WORK_PROFILE_URI) {
+        const instance = typeof payload["instance_id"] === "string" ? payload["instance_id"] : digest.slice(0, 12);
+        const language = typeof payload["language"] === "string" ? payload["language"] : "repository";
+        return {
+            task: {
+                digest,
+                profileUri,
+                label: bounded(instance, 180),
+                summary: bounded(`${language} task — ${parsed.instructions}`, 480),
+                evidencePath: `records/${digest}.bin`,
+            },
+            profileUri,
+        };
+    }
+    if (profileUri === INSPECT_TASK_PROFILE_URI) {
+        const selection = typeof payload["selectionManifestSha256"] === "string"
+            ? payload["selectionManifestSha256"]
+            : undefined;
+        return {
+            task: {
+                digest,
+                profileUri,
+                label: `Inspect evaluation ${digest.slice(0, 12)}`,
+                summary: selection === undefined
+                    ? "Inspect evaluation with bundle-carried scoring evidence."
+                    : `Inspect selection ${selection.slice(0, 12)} is sealed into this task.`,
+                evidencePath: `records/${digest}.bin`,
+            },
+            profileUri,
+        };
+    }
+    return {
+        task: {
+            digest,
+            profileUri,
+            label: `Task ${digest.slice(0, 12)}`,
+            summary: "This task profile has no plain-language Colophon projector; verified identities and measurements remain available below.",
+            evidencePath: `records/${digest}.bin`,
+        },
+        profileUri,
+    };
+}
+function outputProjection(profileUri, name, sha256, bytes) {
+    let summary = `${name} — ${bytes.length} authenticated bytes`;
+    if (profileUri === PREDICTION_FORECAST_PROFILE_URI && name === "prediction") {
+        const value = exactJson(bytes, `prediction output ${sha256}`);
+        if (isObject(value) && typeof value["probabilityYes"] === "string") {
+            summary = `Forecast ${percentage(value["probabilityYes"])}`;
+        }
+    }
+    else if (profileUri === REPOSITORY_WORK_PROFILE_URI && name === "patch") {
+        summary = `Unified-diff patch — ${bytes.length} authenticated bytes`;
+    }
+    else if (profileUri === INSPECT_TASK_PROFILE_URI) {
+        summary = `Inspect ${name} — ${bytes.length} authenticated bytes`;
+    }
+    return { name, sha256, summary, evidencePath: `records/${sha256}.bin` };
+}
+function commonBrier(verdicts) {
+    const values = verdicts.map((verdict) => verdict.measurements["solverBrier"]);
+    if (values.length === 0 || values.some((value) => typeof value !== "string"))
+        return undefined;
+    return values.every((value) => value === values[0]) ? values[0] : undefined;
+}
+function descriptiveComparison(arms, cells) {
+    if (arms.length !== 2)
+        return undefined;
+    const [firstArm, secondArm] = arms;
+    const first = new Map();
+    const second = new Map();
+    for (const cell of cells) {
+        if (cell.primaryScore?.name !== "solverBrier")
+            continue;
+        const key = `${cell.taskDigest}\u001f${cell.replicate}`;
+        const value = Number(cell.primaryScore.value);
+        if (!Number.isFinite(value))
+            continue;
+        if (cell.armId === firstArm)
+            first.set(key, value);
+        if (cell.armId === secondArm)
+            second.set(key, value);
+    }
+    let lowerByFirst = 0;
+    let lowerBySecond = 0;
+    let ties = 0;
+    for (const key of [...first.keys()].sort()) {
+        const left = first.get(key);
+        const right = second.get(key);
+        if (right === undefined)
+            continue;
+        if (left < right)
+            lowerByFirst += 1;
+        else if (right < left)
+            lowerBySecond += 1;
+        else
+            ties += 1;
+    }
+    const pairedCells = lowerByFirst + lowerBySecond + ties;
+    if (pairedCells === 0)
+        return undefined;
+    return {
+        kind: "paired-measurement",
+        measurement: "solverBrier",
+        direction: "lower-is-better",
+        firstArm,
+        secondArm,
+        pairedCells,
+        lowerByFirst,
+        lowerBySecond,
+        ties,
+        formalWinner: false,
+    };
+}
+export function derivePublicComparison(input) {
+    const bundledPredictionSample = input.benchmark.name === SAMPLE_BENCHMARK_NAME;
+    const taskDigests = [...new Set(input.benchmark.items.map(itemTaskDigest))];
+    const taskByDigest = new Map();
+    const tasks = taskDigests.map((digest) => {
+        const projected = taskProjection(digest, requiredRecord(input.recordBytes, digest, "Task"), bundledPredictionSample);
+        taskByDigest.set(digest, projected);
+        return projected.task;
+    });
+    const arms = [...new Set(input.matrix.cells.map((cell) => cell.armId))];
+    const assemblyByKey = new Map(input.assemblyCells.map((cell) => [cell.cellKey, cell]));
+    const cells = input.matrix.cells.map((matrixCell) => {
+        const assembly = assemblyByKey.get(matrixCell.cellKey);
+        if (assembly === undefined)
+            throw new TypeError(`comparison cell ${matrixCell.cellKey} is absent from the verified assembly`);
+        const profileUri = taskByDigest.get(matrixCell.taskDigest)?.profileUri;
+        if (profileUri === undefined)
+            throw new TypeError(`comparison cell ${matrixCell.cellKey} names an unknown Task`);
+        const outputs = (assembly.solveOutputs ?? []).map((output) => outputProjection(profileUri, output.name, output.sha256, requiredRecord(input.recordBytes, output.sha256, "solve output")));
+        const verdicts = assembly.verdicts.map((verdict) => ({
+            evaluator: verdict.evaluator,
+            verdict: verdict.verdict,
+            measurements: verdict.measurements,
+            evidencePath: `records/${verdict.sha256}.bin`,
+        }));
+        const brier = commonBrier(verdicts);
+        const outputSummary = outputs.length === 0
+            ? "No solve output is present for this accounted cell."
+            : outputs.map((output) => output.summary).join("; ");
+        return {
+            cellKey: matrixCell.cellKey,
+            taskDigest: matrixCell.taskDigest,
+            armId: matrixCell.armId,
+            replicate: matrixCell.replicate,
+            outcome: matrixCell.outcome,
+            outputSummary,
+            ...(brier === undefined ? {} : { primaryScore: { name: "solverBrier", value: brier, direction: "lower-is-better" } }),
+            outputs,
+            verdicts,
+            evidencePaths: [
+                `records/${matrixCell.taskDigest}.bin`,
+                ...(assembly.deliverySha256 === undefined ? [] : [`records/${assembly.deliverySha256}.bin`]),
+                ...outputs.map((output) => output.evidencePath),
+                ...verdicts.map((verdict) => verdict.evidencePath),
+            ],
+        };
+    });
+    const comparison = descriptiveComparison(arms, cells);
+    return {
+        profile: "colophon-public-comparison/1",
+        ...(bundledPredictionSample ? { sampleKind: "bundled-prediction" } : {}),
+        tasks,
+        arms,
+        cells,
+        ...(comparison === undefined ? {} : { descriptiveComparison: comparison }),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { verifyPublicBundle, verifyPublicBundleSnapshot } from "./verify.js";
+export type { PublicBundleVerificationCheck, PublicBundleVerificationResult, VerifiedPublicBundleSnapshot, VerifyPublicBundleDeps, } from "./verify.js";
+export { derivePublicComparison } from "./comparison.js";
+export type { DerivePublicComparisonInput, PublicComparisonCell, PublicComparisonOutput, PublicComparisonTask, PublicComparisonVerdict, PublicComparisonView, PublicDescriptiveComparison, } from "./comparison.js";
+export { buildPublicAssets } from "./assets.js";
+export type { PublicAssetInput } from "./assets.js";
+export { anchorCertificateReader, anchorChainVerifier, anchorSignatureVerifier, nodeCryptoAnchorPorts, } from "./anchor/ports.js";
+export { evaluateIntegrityAnchors } from "./anchor/check.js";
+export type { AnchorProofStatus, AnchorSubjectOutcome, AnchorSubjectReport, AnchorVerificationEntry, EvaluateIntegrityAnchorsInput, IntegrityAnchorsReport, PublicBundleAnchorTrustMaterial, } from "./anchor/check.js";
+export type { InspectRuntimeMethodDisclosure, InspectScoringProjectionDisclosure, } from "./profile/inspect-disclosure.js";
+export { ANCHORED_PRE_REGISTRATION, ANCHORED_TRUST_ROOT, ClaimAnchorProjectionError, ClaimAnchorSchema, SELF_RUN_TRUST_ROOT, STRUCTURAL_PRE_REGISTRATION, additionalLockAnchorLine, anchoredPreRegistration, anchoredPreRegistrationSentence, anchoredTrustRoot, anchoredVenueLimits, carriedMatrixAnchors, deriveClaimAnchors, governingLockAnchors, matrixAnchorLine, } from "./profile/anchor-claims.js";
+export type { CarriedAnchorRecord, ClaimAnchor, ClaimAnchorFacts, ClaimAnchorSubject, DeriveClaimAnchorsInput, OpenTimestampsClaimAnchorFacts, Rfc3161ClaimAnchorFacts, } from "./profile/anchor-claims.js";
+export { BUNDLE_FORMAT, BUNDLE_V4_FORMAT, BUNDLE_V5_FORMAT, BUNDLE_V6_FORMAT, SUPPORTED_BUNDLE_FORMATS, } from "./manifest.js";
+export type { BundleManifest, VerifiedBundleSnapshot } from "./manifest.js";
+export * from "./admission/index.js";
+export * from "./schema.js";
+export * from "./profile/binary-judge-manifest.js";
+export * from "./profile/binary-qualification.js";
+export { ClaimPackageSchema } from "./profile/claim.js";
+export type { ClaimPackage } from "./profile/claim.js";
+export { VERIFIER_VERSION, renderVerifiedBundle, runVerifierCli } from "./cli.js";
+export type { VerifierCliDeps, VerifierCliResult } from "./cli.js";
+export { PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_CHECKS, PUBLIC_BUNDLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V4_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V4_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V5_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V5_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_CHECKS, PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_INSTRUCTIONS, PUBLIC_BUNDLE_VERIFIER_MAJOR, PUBLIC_BUNDLE_V4_VERIFIER_MAJOR, } from "./reader-instructions.js";

package/dist/index.js

@@ -0,0 +1,23 @@
+export { verifyPublicBundle, verifyPublicBundleSnapshot } from "./verify.js";
+export { derivePublicComparison } from "./comparison.js";
+export { buildPublicAssets } from "./assets.js";
+// The three node:crypto ports the RFC 3161 anchor rule engine injects
+// (anchor-evidence design §6.1 "Placement"). They live here, in the standalone
+// verifier, and are reused by the product core -- which already depends on this
+// package, so the split matches the real dependency direction.
+export { anchorCertificateReader, anchorChainVerifier, anchorSignatureVerifier, nodeCryptoAnchorPorts, } from "./anchor/ports.js";
+// The `integrity-anchors` check (anchor-evidence design §8), shared by `bundle verify` and the
+// workspace-side `run.verify` so the two cannot become two implementations.
+export { evaluateIntegrityAnchors } from "./anchor/check.js";
+// The anchored-closure projection (anchor-evidence design §7.4, §9.2). Single-sourced here rather
+// than mirrored into the product core, so the producer's claim section and the verifier's rebuild
+// of it cannot drift -- the byte-compare depends on them being one function.
+export { ANCHORED_PRE_REGISTRATION, ANCHORED_TRUST_ROOT, ClaimAnchorProjectionError, ClaimAnchorSchema, SELF_RUN_TRUST_ROOT, STRUCTURAL_PRE_REGISTRATION, additionalLockAnchorLine, anchoredPreRegistration, anchoredPreRegistrationSentence, anchoredTrustRoot, anchoredVenueLimits, carriedMatrixAnchors, deriveClaimAnchors, governingLockAnchors, matrixAnchorLine, } from "./profile/anchor-claims.js";
+export { BUNDLE_FORMAT, BUNDLE_V4_FORMAT, BUNDLE_V5_FORMAT, BUNDLE_V6_FORMAT, SUPPORTED_BUNDLE_FORMATS, } from "./manifest.js";
+export * from "./admission/index.js";
+export * from "./schema.js";
+export * from "./profile/binary-judge-manifest.js";
+export * from "./profile/binary-qualification.js";
+export { ClaimPackageSchema } from "./profile/claim.js";
+export { VERIFIER_VERSION, renderVerifiedBundle, runVerifierCli } from "./cli.js";
+export { PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_CHECKS, PUBLIC_BUNDLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V4_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V4_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V5_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V5_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_CHECKS, PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_INSTRUCTIONS, PUBLIC_BUNDLE_VERIFIER_MAJOR, PUBLIC_BUNDLE_V4_VERIFIER_MAJOR, } from "./reader-instructions.js";

package/dist/manifest.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const BUNDLE_FORMAT: "benchmark-product-public-bundle/2";
+export declare const BUNDLE_V4_FORMAT: "benchmark-product-public-bundle/4";
+export declare const BUNDLE_V5_FORMAT: "benchmark-product-public-bundle/5";
+/** The anchored closure (anchor-evidence design §7.4). Additive: v2, v4, and v5 keep their check
+ * lists, byte shapes, and values; the `anchors/` member and the `integrity-anchors` check exist
+ * only here. */
+export declare const BUNDLE_V6_FORMAT: "benchmark-product-public-bundle/6";
+export declare const SUPPORTED_BUNDLE_FORMATS: readonly ["benchmark-product-public-bundle/2", "benchmark-product-public-bundle/4", "benchmark-product-public-bundle/5", "benchmark-product-public-bundle/6"];
+export declare const BUNDLE_MANIFEST_FILENAME: "bundle.json";
+export declare const BundleManifestFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BundleManifestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    format: z.ZodUnion<readonly [z.ZodLiteral<"benchmark-product-public-bundle/2">, z.ZodLiteral<"benchmark-product-public-bundle/4">, z.ZodLiteral<"benchmark-product-public-bundle/6">]>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    format: z.ZodLiteral<"benchmark-product-public-bundle/5">;
+    profile: z.ZodLiteral<"https://spec.jinn.network/profiles/benchmark-product-public-bundle/5">;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type BundleManifest = z.infer<typeof BundleManifestSchema>;
+export interface BuiltBundleManifest {
+    readonly manifest: BundleManifest;
+    readonly bytes: Uint8Array;
+    readonly identity: string;
+}
+export interface VerifiedBundleSnapshot extends BuiltBundleManifest {
+    /** Every authenticated file byte string, including bundle.json. Never backed by a pathname. */
+    readonly fileBytes: ReadonlyMap<string, Uint8Array>;
+}
+export interface VerifyBundleSnapshotDeps {
+    /** Deterministic adversarial boundary: every byte is already authenticated before this runs. */
+    readonly afterManifestValidated?: () => void;
+}
+export interface BuildBundleManifestOptions {
+    /** Defaults to v2 so existing producer and golden bytes remain immutable. */
+    readonly format?: typeof BUNDLE_FORMAT | typeof BUNDLE_V4_FORMAT | typeof BUNDLE_V6_FORMAT;
+}
+export declare function buildBundleManifest(bundleDir: string, filePaths: readonly string[], options?: BuildBundleManifestOptions): BuiltBundleManifest;
+export declare function verifyBundleManifest(bundleDir: string): BuiltBundleManifest;
+/** Authenticates the complete tree once and returns the exact immutable byte snapshot used by
+ * every semantic verifier. No consumer may reopen a pathname after this boundary. */
+export declare function verifyBundleSnapshot(bundleDir: string, deps?: VerifyBundleSnapshotDeps): VerifiedBundleSnapshot;