@colophon-claims/verify 0.1.0 → 0.2.1

package/dist/binding/report-face.js

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The report face for `beacon-binding/1` (issue #2976, acceptance criteria 3 and 4): which binding
+ * applied, in plain words, and what it does and does not establish.
+ *
+ * Two rules carried over from `../profile/anchor-claims.ts`, whose conditional honesty copy this
+ * mirrors:
+ *
+ * - **Single-sourced, never mirrored.** `@colophon-claims/core` already depends on this package, so
+ *   producer and reader render the same function rather than two copies that can drift.
+ * - **The words key on facts, not on configuration.** Every value in a sentence below comes from
+ *   the verified binding itself, so the text is identical for every reader.
+ *
+ * A third rule follows from issue #3322: **a sentence claims unchosen-ness only where the seal
+ * established it.** A beacon that merely postdates the seal makes the value unpredictable and
+ * leaves the operator choosing among the values that postdate it. So both sentences carry
+ * `roundChoiceClause`, which asserts the second property under `seal-derived` and retracts it under
+ * `operator-chosen` rather than letting either branch imply it.
+ *
+ * A fourth rule is this module's own, and is the whole point of the originating issue: **the census
+ * sentence says it is the weaker binding.** Ordering-only binding shows the run's order was fixed by
+ * randomness that postdates the seal; it does not show the population was, because with a census
+ * there was no population choice to make. Letting the two modes share one confident sentence would
+ * be the failure this feature exists to prevent. Issue #3425 subjects that sentence to the third
+ * rule as well: `censusOrderClause` asserts the postdating only under `proven-offline`, and concedes
+ * it under `attributive` in the register the sampled opening already uses, because the clauses on
+ * either side of it concede exactly that.
+ */
+import { BEACON_BINDING_PROCEDURE, BEACON_SOURCES, } from "./beacon-binding.js";
+export function runBindingClass(binding) {
+    if (binding === undefined)
+        return "none";
+    return binding.mode === "sampled" ? "beacon-drawn-slate" : "beacon-ordering-only";
+}
+/** `<source display name> round <n>`, the one rendering every sentence below uses. */
+function beaconName(binding) {
+    return `${BEACON_SOURCES[binding.beacon.source].displayName} round ${binding.beacon.round}`;
+}
+/**
+ * How the sentence may talk about the beacon postdating the seal. `proven-offline` asserts,
+ * because the source's own published schedule turns the round number into a time by arithmetic.
+ * `attributive` reports what the chain asserts and names what checking it takes -- the same
+ * assertive/attributive split `anchoredPreRegistrationSentence` draws between a timestamp token
+ * and an OpenTimestamps commitment.
+ */
+function postSealClause(binding) {
+    return binding.postSeal === "proven-offline"
+        ? `a value that did not exist until ${binding.beaconInstant}, after this run was sealed at ${binding.sealedAt}`
+        : `a value the chain places after this run's seal at ${binding.sealedAt} — establishing that ordering `
+            + "requires block headers on the reader's side, so it is what the chain asserts rather than something "
+            + "this bundle proves";
+}
+/**
+ * What the run's choice of ROUND does or does not add (issue #3322). A beacon that merely postdates
+ * the seal leaves the operator picking among realized values, and a sentence that names only the
+ * value's unpredictability reads as though it had ruled that out. So the clause is not decoration:
+ * under `seal-derived` it states the second property and then names the residue that survives it
+ * (the source choice), and under `operator-chosen` it retracts the property in the same plain
+ * register the census branch uses about its own weaker binding.
+ */
+function roundChoiceClause(binding) {
+    // Name the thing a chosen round would actually have moved. Saying "the result" for both modes
+    // made the census clause read as a retraction of a population claim a census never makes: with a
+    // census the population is the whole declared one whatever round applies, and only the ORDER
+    // moves. The residue named under `seal-derived` is likewise the SOURCE, not a count of sources:
+    // one admitted source is indexed by block height, where no round follows from a seal at all, so
+    // its alternatives are every height published since rather than a single candidate.
+    const derived = binding.mode === "sampled" ? "slate" : "order";
+    if (binding.roundBasis === "seal-derived") {
+        // Only a scheduled source reaches here: `requiredBeaconRound` derives nothing for a height, so
+        // an `attributive` binding is `operator-chosen` by construction.
+        return "The round was not the operator's to pick either: it is the first round this source publishes after "
+            + "the seal, so the seal instant alone fixes it. What choosing remains is the source — this procedure "
+            + "admits other beacons, one of them indexed by block height, where no round follows from a seal at all — "
+            + "so an operator could have bound a different source instead.";
+    }
+    if (binding.postSeal === "attributive") {
+        // Say no more here than the postdating clause two sentences earlier already conceded. Claiming
+        // the value was unpredictable would assert exactly what this branch cannot check: nothing in
+        // the bundle places this height after the seal, so nothing rules out a height that predates it.
+        return `No round follows from a seal on a height-indexed source, so this height was the operator's choice — `
+            + `and on the reader's side it is the chain, not this bundle, that places it after the seal at all. Any `
+            + `other height would have derived a different ${derived} from the same inputs.`;
+    }
+    return `Which post-seal value applied was still the operator's choice: this binding names a round selected after `
+        + `the seal, and every round the source published in between was an available alternative deriving a `
+        + `different ${derived} from the same inputs. The value could not have been predicted; this ${derived} is `
+        + `nonetheless one of several the operator could have realized by waiting.`;
+}
+/**
+ * What the census binding shows about the ORDER (issue #3425). The postdating half keys on
+ * `postSeal` for the same reason the sampled opening does: on a height-indexed source nothing in
+ * the bundle places the value after the seal, so asserting that the order was fixed by randomness
+ * postdating it would be conceded by `postSealClause` two clauses earlier and again by
+ * `roundChoiceClause` two clauses later. The population half is unconditional -- a census makes no
+ * population choice on any basis.
+ */
+function censusOrderClause(binding) {
+    const order = binding.postSeal === "proven-offline"
+        ? "It shows the run's order was fixed by randomness postdating the seal"
+        : "It shows the run's order was tied to a value this bundle cannot place after the seal";
+    return `${order}; it does not show the population was, because a census makes no population choice.`;
+}
+const RECOMPUTE_CLAUSE = `Any reader recomputes the derivation offline from the sealed digest, the published beacon value and the `
+    + `item identities alone, by procedure ${BEACON_BINDING_PROCEDURE}; the verifier fails the run when its `
+    + "recomputation disagrees.";
+/**
+ * The one sentence that states which binding applied. `undefined` yields the unbound statement,
+ * which is a claim about the run too: nothing about it was drawn from post-seal randomness.
+ */
+export function runBindingSentence(binding) {
+    if (binding === undefined) {
+        return "This run is bound to no public randomness: its seal shows the design existed by a given time, and "
+            + "nothing establishes that execution followed the seal rather than preceding it.";
+    }
+    if (binding.mode === "sampled") {
+        // The "could not have been selected after the fact" claim is the one issue #3322 exists to
+        // stop overstating, so it appears ONLY on the branch where the seal named the round. Under
+        // `operator-chosen` it is not merely unproven, it is false -- selecting the slate after the
+        // fact needed no prediction at all, only waiting for a round whose derivation the operator
+        // liked -- so it is dropped rather than hedged.
+        //
+        // The opening keys on `postSeal` as well, for the same reason `roundChoiceClause` does: under
+        // `attributive` nothing in the bundle places the height after the seal, so an opening that
+        // called the value unpredictable would assert what the branch cannot check -- and would be
+        // retracted two clauses later by the very postdating clause it introduces.
+        const opening = binding.roundBasis === "seal-derived"
+            ? "This run's slate was drawn, not chosen"
+            : binding.postSeal === "attributive"
+                ? "This run's slate was drawn from a value this bundle cannot place after the seal"
+                : "This run's slate was drawn from a value it could not have predicted";
+        const unpredictabilityClause = binding.roundBasis === "seal-derived"
+            ? "Selecting the slate after the fact would have required predicting that value. "
+            : "";
+        return `${opening}: its ${binding.sample.length} items were derived from a `
+            + `declared pool of ${binding.poolSize} by procedure ${BEACON_BINDING_PROCEDURE}, keyed on this run's sealed `
+            + `digest together with ${beaconName(binding)} — ${postSealClause(binding)}. `
+            + `${unpredictabilityClause}${roundChoiceClause(binding)} ${RECOMPUTE_CLAUSE}`;
+    }
+    return `This run evaluated its whole declared population of ${binding.poolSize} items, so no slate was selected `
+        + `and none could be selected after the fact. The beacon binds execution ORDER only: the order was derived by `
+        + `procedure ${BEACON_BINDING_PROCEDURE} from this run's sealed digest together with ${beaconName(binding)} — `
+        + `${postSealClause(binding)}. This is a weaker binding than a beacon-drawn slate. `
+        + `${censusOrderClause(binding)} ${roundChoiceClause(binding)} ${RECOMPUTE_CLAUSE}`;
+}
+/**
+ * The venue-limits list with the binding statement appended. Returns the list unchanged when the
+ * run carries no binding, so every run that predates this feature keeps its exact limits bytes --
+ * the same additive posture `anchoredVenueLimits` takes for an unanchored run.
+ */
+export function runBoundVenueLimits(limits, binding) {
+    return binding === undefined ? limits : [...limits, runBindingSentence(binding)];
+}

package/dist/cli.js

@@ -1,7 +1,6 @@
 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 { summarizeVerificationOutcome } from "./outcome.js";
 import { verifyPublicBundle } from "./verify.js";
 import { VERIFIER_VERSION } from "./version.js";
 export { VERIFIER_VERSION } from "./version.js";
@@ -75,29 +74,82 @@ function renderAnchorReport(report) {
         : report.anchors.map(renderAnchor).join("\n");
     return `\nAnchors\n${anchors}\n\nAnchor subjects\n${report.subjects.map(renderSubject).join("\n")}\n`;
 }
+const SIGNER_ROLE_NAMES = {
+    publisher: "publisher",
+    "automated-grader": "automated grader",
+    "human-reviewer": "human reviewer",
+    "label-admission": "label admission",
+};
+/** The role in plain words. `urn:`/`did:key` identifiers stay in `--json`, where they are the join
+ * key a reader actually needs them for; on this surface they are noise a reader has to decode.
+ * Undeclared custody is stated rather than left blank: a reader who has seen the same-operator
+ * suffix elsewhere would otherwise read its absence as an independence claim, which no bundle
+ * format can establish. The publisher takes no suffix -- it *is* the operator the others are
+ * measured against. */
+function renderSignerGroup(role, custody, count) {
+    const suffix = role === "publisher"
+        ? ""
+        : custody === "same-operator" ? " \u2014 same operator" : " \u2014 custody not declared";
+    return `  ${SIGNER_ROLE_NAMES[role]}${suffix} \u00b7 ${count} ${count === 1 ? "key" : "keys"}`;
+}
+function renderSigners(signers) {
+    const counts = new Map();
+    for (const signer of signers) {
+        const key = `${signer.role} ${signer.custody}`;
+        const group = counts.get(key);
+        if (group === undefined)
+            counts.set(key, { role: signer.role, custody: signer.custody, count: 1 });
+        else
+            group.count += 1;
+    }
+    // The role-name record's own key order is the print order; a second parallel list would drift.
+    const order = Object.keys(SIGNER_ROLE_NAMES);
+    const groups = [...counts.values()]
+        .sort((left, right) => order.indexOf(left.role) - order.indexOf(right.role));
+    return `\nSigned by\n${groups.map((group) => renderSignerGroup(group.role, group.custody, group.count)).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;
+    // A metadata-first bundle carries artifact digests without their bytes. Printing "passed" for a
+    // check that read nothing would be the one claim this format cannot afford, so the deferred check
+    // prints as not fetched and is counted out of the passed total.
+    const outcome = summarizeVerificationOutcome(result);
+    const artifactContent = outcome.artifactContent;
+    const checks = outcome.outcomes
+        .map(({ check, state }) => `${check.padEnd(24)}${state}`)
+        .join("\n");
+    const totalChecks = outcome.total;
     const identity = result.identity.startsWith("sha256:") ? result.identity : `sha256:${result.identity}`;
     const anchors = "anchors" in result && result.anchors !== undefined
         ? renderAnchorReport(result.anchors)
         : "";
+    const signers = result.signers === undefined || result.signers.length === 0
+        ? ""
+        : renderSigners(result.signers);
+    // Naming the digests is what makes the deferred check completable: they are the addresses to
+    // fetch and the expectations to check the fetched bytes against. Adding a body to this directory
+    // is not the completion path -- it would break the manifest closure the bundle is identified by,
+    // so the reader is pointed at the full-evidence bundle instead.
+    const artifactContentReport = artifactContent === undefined
+        ? ""
+        : `\nArtifact content\n  ${artifactContent.notFetched} artifact ${artifactContent.notFetched === 1 ? "body was" : "bodies were"} not fetched. This bundle carries their\n  exact digests, not their bytes:\n${artifactContent.notFetchedDigests.map((digest) => `    sha256:${digest}`).join("\n")}\n  Check fetched bytes against those digests yourself, or verify the\n  full-evidence bundle, which carries them.\n`;
+    const artifactContentLimit = artifactContent === undefined
+        ? ""
+        : "\nEverything above was checked against the bytes this bundle carries. The artifact\ncontents themselves were not read, so nothing here says what they contain.";
     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
+    const verdictLine = outcome.notFetched === 0
+        ? `Verified: ${outcome.passed} of ${totalChecks} checks passed`
+        : `Verified: ${outcome.passed} of ${totalChecks} checks passed, ${outcome.notFetched} not fetched`;
+    return `${verdictLine}
 Bundle: ${identity}
 Format: ${result.format}
 
 ${checks}
-${anchors}
+${signers}${artifactContentReport}${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}
+bundle was honest or that the compared identities are independent parties.${artifactContentLimit}${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.
@@ -132,6 +184,16 @@ function readBlockHeaders(bytes, path) {
         };
     });
 }
+/** `urn:…` and `did:key:z…` as they appear inside a refusal message. The base58btc class stops a
+ * `did:key` match before a trailing `:reason` suffix the message appended. */
+const RAW_IDENTIFIER = /urn:[^\s,;)"']+|did:key:z[1-9A-HJ-NP-Za-km-z]+/gu;
+/** A refusal names the signer it refused, and on the machine surface that identifier is the whole
+ * point. On the human surface it is a string a reader cannot act on, so the same rule as the
+ * verified report applies: the identifier lives in `--json` (issue #3024). What failed, and where,
+ * is untouched. */
+function withoutRawIdentifiers(message) {
+    return message.replace(RAW_IDENTIFIER, "<identifier: see --json>");
+}
 function parseArguments(args) {
     const positional = [];
     const tsaRoots = [];
@@ -199,7 +261,7 @@ export async function runVerifierCli(args, deps = {}) {
         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`;
+        const stderr = parsed.json ? "" : `colophon-verify: ${withoutRawIdentifiers(error.message)}\n`;
         return { exitCode: code === "record-integrity" ? 1 : 2, stdout, stderr };
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export { verifyPublicBundle, verifyPublicBundleSnapshot } from "./verify.js";
 export type { PublicBundleVerificationCheck, PublicBundleVerificationResult, VerifiedPublicBundleSnapshot, VerifyPublicBundleDeps, } from "./verify.js";
+export type { PublicBundleSigner, PublicBundleSignerRole } from "./signers.js";
 export { derivePublicComparison } from "./comparison.js";
 export type { DerivePublicComparisonInput, PublicComparisonCell, PublicComparisonOutput, PublicComparisonTask, PublicComparisonVerdict, PublicComparisonView, PublicDescriptiveComparison, } from "./comparison.js";
 export { buildPublicAssets } from "./assets.js";
+export { assertTaskSelectionConsistency, taskSelectionContradiction } from "./profile/task-selection.js";
 export type { PublicAssetInput } from "./assets.js";
 export { anchorCertificateReader, anchorChainVerifier, anchorSignatureVerifier, nodeCryptoAnchorPorts, } from "./anchor/ports.js";
 export { evaluateIntegrityAnchors } from "./anchor/check.js";
@@ -10,14 +12,23 @@ export type { AnchorProofStatus, AnchorSubjectOutcome, AnchorSubjectReport, Anch
 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 { BUNDLE_FORMAT, BUNDLE_V4_FORMAT, BUNDLE_V5_FORMAT, BUNDLE_V6_FORMAT, BUNDLE_V7_FORMAT, BUNDLE_V8_FORMAT, SUPPORTED_BUNDLE_FORMATS, } from "./manifest.js";
+export { ClaimDisclosureSectionSchema, DISCLOSURE_ROLE_BINDING, DISCLOSURE_SPECIFICATION_BUNDLE_ROLE, DisclosureProjectionError, assertDisclosureSpecification, deriveDisclosureSpecification, } from "./profile/disclosure.js";
+export type { AssertDisclosureSpecificationInput, ClaimDisclosureSection, DisclosureSpecificationReport, } from "./profile/disclosure.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 { ClaimPackageSchema, DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID } from "./profile/claim.js";
 export type { ClaimPackage } from "./profile/claim.js";
+export { firstDifference } from "./profile/claim-consistency.js";
+export { NOT_FETCHED_CHECK, summarizeVerificationOutcome } from "./outcome.js";
+export type { VerificationCheckOutcome, VerificationCheckState, VerificationOutcome, } from "./outcome.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";
+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_V7_CHECKS, PUBLIC_BUNDLE_V7_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V7_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V8_CHECKS, PUBLIC_BUNDLE_V8_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V8_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_INSTRUCTIONS, PUBLIC_BUNDLE_VERIFIER_MAJOR, PUBLIC_BUNDLE_V4_VERIFIER_MAJOR, } from "./reader-instructions.js";
+export { BEACON_BINDING_PROCEDURE, BEACON_SOURCES, BEACON_SOURCE_IDS, MAX_BEACON_ROUND, BeaconReferenceSchema, RunBindingError, RunBindingSchema, beaconRoundInstant, computeBeaconOrder, requiredBeaconRound, verifyRunBinding, } from "./binding/beacon-binding.js";
+export type { BeaconOrderParams, BeaconOrderResult, BeaconPostSealBasis, BeaconReference, BeaconRoundBasis, BeaconSourceDefinition, BeaconSourceId, BeaconSourceTimeBasis, RequiredBeaconRound, RunBinding, VerifiedRunBinding, } from "./binding/beacon-binding.js";
+export { runBindingClass, runBindingSentence, runBoundVenueLimits } from "./binding/report-face.js";
+export type { RunBindingClass } from "./binding/report-face.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export { verifyPublicBundle, verifyPublicBundleSnapshot } from "./verify.js";
 export { derivePublicComparison } from "./comparison.js";
 export { buildPublicAssets } from "./assets.js";
+export { assertTaskSelectionConsistency, taskSelectionContradiction } from "./profile/task-selection.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
@@ -13,11 +14,23 @@ export { evaluateIntegrityAnchors } from "./anchor/check.js";
 // 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 { BUNDLE_FORMAT, BUNDLE_V4_FORMAT, BUNDLE_V5_FORMAT, BUNDLE_V6_FORMAT, BUNDLE_V7_FORMAT, BUNDLE_V8_FORMAT, SUPPORTED_BUNDLE_FORMATS, } from "./manifest.js";
+// The disclosed-closure projection and check (disclosure-specification-record design §6.4/§6.6/§7,
+// issue #2839). Single-sourced here for exactly the reason the anchored projection above is: the
+// product core imports this package, so the producer's claim section and the verifier's rebuild of
+// it are one function, and the byte-compare is a comparison of outputs rather than of guesses.
+export { ClaimDisclosureSectionSchema, DISCLOSURE_ROLE_BINDING, DISCLOSURE_SPECIFICATION_BUNDLE_ROLE, DisclosureProjectionError, assertDisclosureSpecification, deriveDisclosureSpecification, } from "./profile/disclosure.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 { ClaimPackageSchema, DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID } from "./profile/claim.js";
+export { firstDifference } from "./profile/claim-consistency.js";
+export { NOT_FETCHED_CHECK, summarizeVerificationOutcome } from "./outcome.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";
+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_V7_CHECKS, PUBLIC_BUNDLE_V7_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V7_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V8_CHECKS, PUBLIC_BUNDLE_V8_COMPATIBLE_VERIFICATION_COMMAND, PUBLIC_BUNDLE_V8_VERIFICATION_COMMAND, PUBLIC_BUNDLE_VERIFICATION_INSTRUCTIONS, PUBLIC_BUNDLE_VERIFIER_MAJOR, PUBLIC_BUNDLE_V4_VERIFIER_MAJOR, } from "./reader-instructions.js";
+// `beacon-binding/1` (issue #2976): the post-seal public-randomness binding, and the report face
+// that states which binding a run carries. Single-sourced here for the same reason the anchored
+// projection is -- the product core imports this package, so producer and reader run one function.
+export { BEACON_BINDING_PROCEDURE, BEACON_SOURCES, BEACON_SOURCE_IDS, MAX_BEACON_ROUND, BeaconReferenceSchema, RunBindingError, RunBindingSchema, beaconRoundInstant, computeBeaconOrder, requiredBeaconRound, verifyRunBinding, } from "./binding/beacon-binding.js";
+export { runBindingClass, runBindingSentence, runBoundVenueLimits } from "./binding/report-face.js";

package/dist/manifest.d.ts

@@ -6,7 +6,33 @@ export declare const BUNDLE_V5_FORMAT: "benchmark-product-public-bundle/5";
  * 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"];
+/**
+ * The anchored binary-qualification closure (issue #3205): v4's member list — `qualification.json`,
+ * the v4 evidence catalog, the v4 trust document — plus v6's `anchors/` member and its
+ * `integrity-anchors` check. Additive in exactly the same way v6 was: v2, v4, v5, and v6 keep their
+ * member lists, check lists, and bytes, and only a run that is BOTH anchored and
+ * qualification-projecting emits this one.
+ */
+export declare const BUNDLE_V7_FORMAT: "benchmark-product-public-bundle/7";
+/**
+ * The disclosed anchored binary-qualification closure (issue #2839, disclosure-specification-record
+ * design §6.5): v7's complete member list plus one `records/<sha256>.bin` member carrying the sealed
+ * disclosure-specification record, and the `disclosure-specification` check.
+ *
+ * **Why it stacks on v7 rather than on v4.** The design reserved this closure for the UNANCHORED
+ * qualified branch, on the premise (its §12.2) that anchoring and qualification could never
+ * combine. Issue #3205 dissolved that premise: the published official bundle IS anchored and
+ * qualified, on v7. Allocating disclosure on the unanchored branch would have forced the flagship to
+ * choose between its anchor and its disclosure record, so the allocation follows the real material.
+ * Anything narrower — a second, unanchored disclosed cell — would double the enumeration that
+ * #2889 exists to kill, and is deliberately not built.
+ *
+ * Additive in exactly the way v6 and v7 were: v2, v4, v5, v6, and v7 keep their member lists, check
+ * lists, and bytes, and only a run that is anchored AND qualification-projecting AND carrying a
+ * sealed disclosure declaration emits this one.
+ */
+export declare const BUNDLE_V8_FORMAT: "benchmark-product-public-bundle/8";
+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", "benchmark-product-public-bundle/7", "benchmark-product-public-bundle/8"];
 export declare const BUNDLE_MANIFEST_FILENAME: "bundle.json";
 export declare const BundleManifestFileSchema: z.ZodObject<{
     path: z.ZodString;
@@ -14,7 +40,7 @@ export declare const BundleManifestFileSchema: z.ZodObject<{
     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">]>;
+    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">, z.ZodLiteral<"benchmark-product-public-bundle/7">, z.ZodLiteral<"benchmark-product-public-bundle/8">]>;
     files: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         sha256: z.ZodString;
@@ -22,7 +48,7 @@ export declare const BundleManifestSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, 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">;
+    profile: z.ZodUnion<readonly [z.ZodLiteral<"https://spec.jinn.network/profiles/benchmark-product-public-bundle/5">, z.ZodLiteral<"https://spec.jinn.network/profiles/benchmark-product-public-bundle/5/metadata-first">]>;
     files: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         sha256: z.ZodString;
@@ -45,7 +71,7 @@ export interface VerifyBundleSnapshotDeps {
 }
 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;
+    readonly format?: typeof BUNDLE_FORMAT | typeof BUNDLE_V4_FORMAT | typeof BUNDLE_V6_FORMAT | typeof BUNDLE_V7_FORMAT | typeof BUNDLE_V8_FORMAT;
 }
 export declare function buildBundleManifest(bundleDir: string, filePaths: readonly string[], options?: BuildBundleManifestOptions): BuiltBundleManifest;
 export declare function verifyBundleManifest(bundleDir: string): BuiltBundleManifest;

package/dist/manifest.js

@@ -12,11 +12,39 @@ export const BUNDLE_V5_FORMAT = "benchmark-product-public-bundle/5";
  * lists, byte shapes, and values; the `anchors/` member and the `integrity-anchors` check exist
  * only here. */
 export const BUNDLE_V6_FORMAT = "benchmark-product-public-bundle/6";
+/**
+ * The anchored binary-qualification closure (issue #3205): v4's member list — `qualification.json`,
+ * the v4 evidence catalog, the v4 trust document — plus v6's `anchors/` member and its
+ * `integrity-anchors` check. Additive in exactly the same way v6 was: v2, v4, v5, and v6 keep their
+ * member lists, check lists, and bytes, and only a run that is BOTH anchored and
+ * qualification-projecting emits this one.
+ */
+export const BUNDLE_V7_FORMAT = "benchmark-product-public-bundle/7";
+/**
+ * The disclosed anchored binary-qualification closure (issue #2839, disclosure-specification-record
+ * design §6.5): v7's complete member list plus one `records/<sha256>.bin` member carrying the sealed
+ * disclosure-specification record, and the `disclosure-specification` check.
+ *
+ * **Why it stacks on v7 rather than on v4.** The design reserved this closure for the UNANCHORED
+ * qualified branch, on the premise (its §12.2) that anchoring and qualification could never
+ * combine. Issue #3205 dissolved that premise: the published official bundle IS anchored and
+ * qualified, on v7. Allocating disclosure on the unanchored branch would have forced the flagship to
+ * choose between its anchor and its disclosure record, so the allocation follows the real material.
+ * Anything narrower — a second, unanchored disclosed cell — would double the enumeration that
+ * #2889 exists to kill, and is deliberately not built.
+ *
+ * Additive in exactly the way v6 and v7 were: v2, v4, v5, v6, and v7 keep their member lists, check
+ * lists, and bytes, and only a run that is anchored AND qualification-projecting AND carrying a
+ * sealed disclosure declaration emits this one.
+ */
+export const BUNDLE_V8_FORMAT = "benchmark-product-public-bundle/8";
 export const SUPPORTED_BUNDLE_FORMATS = [
     BUNDLE_FORMAT,
     BUNDLE_V4_FORMAT,
     BUNDLE_V5_FORMAT,
     BUNDLE_V6_FORMAT,
+    BUNDLE_V7_FORMAT,
+    BUNDLE_V8_FORMAT,
 ];
 export const BUNDLE_MANIFEST_FILENAME = "bundle.json";
 const SHA256_HEX = /^[a-f0-9]{64}$/;
@@ -30,6 +58,8 @@ const LegacyBundleManifestSchema = z.object({
         z.literal(BUNDLE_FORMAT),
         z.literal(BUNDLE_V4_FORMAT),
         z.literal(BUNDLE_V6_FORMAT),
+        z.literal(BUNDLE_V7_FORMAT),
+        z.literal(BUNDLE_V8_FORMAT),
     ]),
     files: z.array(BundleManifestFileSchema).min(1),
 });

package/dist/materialize.d.ts

@@ -2,3 +2,10 @@
 export declare const PUBLIC_BUNDLE_FILES: readonly ["static-bundle.json", "benchmark.json", "run.json", "matrix.json", "report.json", "report-envelope.json", "claim-package.json", "verdicts.json", "evidence.json", "verification/assembly.jsonl", "trust/public-keys.json", "index.html", "badge.svg", "social-card.svg", "README.md", "share.txt"];
 /** V4 is the fixed v2 graph with exactly one canonical qualification projection added. */
 export declare const PUBLIC_BUNDLE_V4_FILES: readonly ("benchmark.json" | "run.json" | "matrix.json" | "report.json" | "report-envelope.json" | "claim-package.json" | "qualification.json" | "static-bundle.json" | "evidence.json" | "verdicts.json" | "verification/assembly.jsonl" | "trust/public-keys.json" | "index.html" | "badge.svg" | "social-card.svg" | "README.md" | "share.txt")[];
+/**
+ * V8 (issue #2839) adds no mandatory MEMBER. The disclosure-specification record travels at the
+ * already-allowlisted `records/<sha256>.bin` path, driven by the evidence catalog exactly like every
+ * other sealed record, so v8's mandatory list is v7's — which is v4's. The alias exists so the
+ * equality is stated in the file that owns member lists rather than inferred at the call site.
+ */
+export declare const PUBLIC_BUNDLE_V8_FILES: readonly ("benchmark.json" | "run.json" | "matrix.json" | "report.json" | "report-envelope.json" | "claim-package.json" | "qualification.json" | "static-bundle.json" | "evidence.json" | "verdicts.json" | "verification/assembly.jsonl" | "trust/public-keys.json" | "index.html" | "badge.svg" | "social-card.svg" | "README.md" | "share.txt")[];

package/dist/materialize.js

@@ -11,3 +11,10 @@ export const PUBLIC_BUNDLE_V4_FILES = [
     "qualification.json",
     ...PUBLIC_BUNDLE_FILES.slice(7),
 ];
+/**
+ * V8 (issue #2839) adds no mandatory MEMBER. The disclosure-specification record travels at the
+ * already-allowlisted `records/<sha256>.bin` path, driven by the evidence catalog exactly like every
+ * other sealed record, so v8's mandatory list is v7's — which is v4's. The alias exists so the
+ * equality is stated in the file that owns member lists rather than inferred at the call site.
+ */
+export const PUBLIC_BUNDLE_V8_FILES = PUBLIC_BUNDLE_V4_FILES;

package/dist/outcome.d.ts

@@ -0,0 +1,31 @@
+import type { PublicBundleVerificationResult } from "./verify.js";
+/**
+ * The one check a metadata-first `benchmark-product-public-bundle/5` defers (issue #2986): its
+ * artifact digests are carried, its artifact bodies are not.
+ */
+export declare const NOT_FETCHED_CHECK: "artifact-integrity";
+export type VerificationCheckState = "passed" | "not fetched";
+export interface VerificationCheckOutcome {
+    readonly check: string;
+    readonly state: VerificationCheckState;
+}
+export interface VerificationOutcome {
+    readonly outcomes: readonly VerificationCheckOutcome[];
+    /** Checks that actually passed. A deferred check is never counted here. */
+    readonly passed: number;
+    readonly notFetched: number;
+    /** The check count the bundle's declared format promises. */
+    readonly total: number;
+    /** Present exactly when the bundle deferred artifact content. */
+    readonly artifactContent?: {
+        readonly notFetched: number;
+        readonly notFetchedDigests: readonly string[];
+    };
+}
+/**
+ * The single derivation of what a verification result may be said to have proved. Every reader
+ * surface -- the standalone CLI, the product CLI, the local viewer, the web action -- reads this
+ * rather than counting `checks` itself, because a surface that counts for itself is a surface that
+ * can print a pass over bytes nobody read (issue #2986).
+ */
+export declare function summarizeVerificationOutcome(result: PublicBundleVerificationResult): VerificationOutcome;

package/dist/outcome.js

@@ -0,0 +1,45 @@
+import { EVIDENCE_NATIVE_BUNDLE_V5_CHECKS } from "@jinn-network/benchmarking-evidence";
+import { PUBLIC_BUNDLE_VERIFICATION_CHECKS, PUBLIC_BUNDLE_V6_CHECKS, PUBLIC_BUNDLE_V7_CHECKS, PUBLIC_BUNDLE_V8_CHECKS, } from "./reader-instructions.js";
+/**
+ * The one check a metadata-first `benchmark-product-public-bundle/5` defers (issue #2986): its
+ * artifact digests are carried, its artifact bodies are not.
+ */
+export const NOT_FETCHED_CHECK = "artifact-integrity";
+/**
+ * The single derivation of what a verification result may be said to have proved. Every reader
+ * surface -- the standalone CLI, the product CLI, the local viewer, the web action -- reads this
+ * rather than counting `checks` itself, because a surface that counts for itself is a surface that
+ * can print a pass over bytes nobody read (issue #2986).
+ */
+export function summarizeVerificationOutcome(result) {
+    const total = 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
+            : result.format === "benchmark-product-public-bundle/7"
+                ? PUBLIC_BUNDLE_V7_CHECKS.length
+                : result.format === "benchmark-product-public-bundle/8"
+                    ? PUBLIC_BUNDLE_V8_CHECKS.length
+                    : PUBLIC_BUNDLE_VERIFICATION_CHECKS.length;
+    const deferred = result.format === "benchmark-product-public-bundle/5"
+        && result.artifactContent.status === "not-fetched"
+        ? result.artifactContent
+        : undefined;
+    const outcomes = result.checks.map((check) => ({
+        check,
+        state: (deferred !== undefined && check === NOT_FETCHED_CHECK ? "not fetched" : "passed"),
+    }));
+    const notFetched = outcomes.filter((outcome) => outcome.state === "not fetched").length;
+    return {
+        outcomes,
+        passed: outcomes.length - notFetched,
+        notFetched,
+        total,
+        ...(deferred === undefined ? {} : {
+            artifactContent: {
+                notFetched: deferred.notFetched,
+                notFetchedDigests: deferred.notFetchedDigests,
+            },
+        }),
+    };
+}

package/dist/profile/binary-qualification.js

@@ -1,4 +1,5 @@
 import { validateBinaryInstrumentParameters } from "@jinn-network/benchmarking-aggregate";
+import { PROMPTED_SCREENING_LIMITATIONS, PROMPTED_SCREENING_PROFILE, } from "../admission/contracts.js";
 export const BINARY_INSTRUMENT_REPORT_LIMITATIONS = {
     mutableModelAlias: "The gpt-5.6-luna identifier is a mutable provider alias; this evidence does not prove invariant model weights across calls.",
     reviewerKeyPerson: "Distinct reviewer signing keys prove key control, not that the controllers are distinct people.",
@@ -48,5 +49,10 @@ export function binaryInstrumentReportLimitations(parameters) {
         ...(parameters["truthAdmission"] === "screened-operator-sampled"
             ? [BINARY_INSTRUMENT_REPORT_LIMITATIONS.screenedNotIndependentlyLabeled]
             : []),
+        // Appended only for an authenticated screening-table/v2 closure. Legacy parameter sets omit
+        // the profile and therefore retain their exact limitation arrays and sealed Report bytes.
+        ...(parameters["promptedScreeningProfile"] === PROMPTED_SCREENING_PROFILE
+            ? PROMPTED_SCREENING_LIMITATIONS
+            : []),
     ];
 }

package/dist/profile/claim-consistency.d.ts

@@ -1,6 +1,7 @@
 import { type BenchmarkRecord, type MatrixRecord, type ReportRecord, type RunRecord } from "@jinn-network/benchmarking-records";
 import { type ClaimPackage } from "./claim.js";
 import type { ClaimAnchor } from "./anchor-claims.js";
+import type { ClaimDisclosureSection } from "./disclosure.js";
 export interface ClaimRecordIdentities {
     readonly benchmarkSha256: string;
     readonly runSha256: string;
@@ -8,6 +9,11 @@ export interface ClaimRecordIdentities {
     readonly reportSha256: string | undefined;
     readonly reportEnvelopeSha256: string;
 }
+/** The path of the first field that actually differs, or `undefined` when the two values are
+ * equal — equal leaves must report NO difference, or the object branch returns on its first key
+ * and every mismatch names the first key in sorted order instead of the edited field. Single
+ * implementation: product core imports this helper rather than keeping a second copy. */
+export declare function firstDifference(actual: unknown, expected: unknown, path?: string): string | undefined;
 export declare function assertClaimConsistency(input: {
     readonly claim: ClaimPackage;
     readonly identities: ClaimRecordIdentities;
@@ -22,5 +28,6 @@ export declare function assertClaimConsistency(input: {
         readonly previewCount: number;
         readonly timestamps: readonly string[];
     }; /** anchor-evidence §7.4: the anchors section re-derived from the carried AnchorEvidence bytes, never read from the claim under test. */
-    readonly anchors?: readonly ClaimAnchor[];
+    readonly anchors?: readonly ClaimAnchor[]; /** disclosure-specification-record design §7 step 10: the disclosure section re-derived from the carried record's own bytes, never read from the claim under test. */
+    readonly disclosure?: ClaimDisclosureSection;
 }): void;