@colophon-claims/verify 0.2.0 → 0.2.1

package/dist/admission/verification.d.ts

@@ -40,6 +40,7 @@ export interface VerifiedBinaryJudgmentAdmissionExclusion {
     readonly stratum: string;
     readonly reason: "review-disagreement" | "review-indeterminate" | "review-incomplete" | "screening-disagreement" | "screening-indeterminate" | "screening-hand-excluded";
     readonly replacementItemSha256: AdmissionSha256;
+    readonly receivingSlotId?: string;
 }
 export interface VerifiedBinaryJudgmentAdmissionClosure {
     readonly manifestSha256: AdmissionSha256;

package/dist/admission/verification.js

@@ -3,7 +3,9 @@ import { z } from "zod";
 import { VERDICT_DSSE_PAYLOAD_TYPE, canonicalJsonBytes, compareCodeUnitStrings, parseBinaryJudgmentAnalysisContext, parseBinaryJudgmentInstrument, parseBinaryJudgmentLabelResolution, parseBinaryJudgmentPayload, recordDigest, sealBinaryJudgmentInstrument, } from "@jinn-network/task-execution-profiles";
 import { parseExactDsseEnvelope } from "@jinn-network/trust-core";
 import { BINARY_JUDGMENT_HUMAN_REVIEW_EVALUATION_SPEC_SEALED, HUMAN_REVIEW_FORM_SEALED, } from "./application.js";
-import { BinaryJudgmentAdmissionManifestSchema, HUMAN_REVIEW_OPERATOR_ASSERTION_MEDIA_TYPE, HUMAN_REVIEW_PACKET_MEDIA_TYPE, HUMAN_REVIEW_RESPONSE_MEDIA_TYPE, HUMAN_REVIEW_REVEAL_RECEIPT_MEDIA_TYPE, HUMAN_REVIEW_ROSTER_MEDIA_TYPE, HUMAN_REVIEW_VISIBILITY_RECEIPT_MEDIA_TYPE, SCREENING_REVEAL_RECEIPT_MEDIA_TYPE, SCREENING_TABLE_MEDIA_TYPE, SCREENING_TABLE_V2_MEDIA_TYPE, HumanReviewOperatorAssertionSchema, HumanReviewPacketSchema, HumanReviewReplacementLedgerSchema, HumanReviewResponseSchema, HumanReviewRevealReceiptSchema, HumanReviewRosterSchema, HumanReviewVisibilityReceiptSchema, ScreeningRevealReceiptSchema, ScreeningTableSchema, ScreeningTableV2Schema, PromptedScreeningProcedureV1Schema, ScreeningPoolV1Schema, ScreeningSampleCommitmentV1Schema, PROMPTED_SCREENING_LIMITATIONS, PROMPTED_SCREENING_PROFILE, } from "./contracts.js";
+import { BinaryJudgmentAdmissionManifestSchema, HUMAN_REVIEW_OPERATOR_ASSERTION_MEDIA_TYPE, HUMAN_REVIEW_PACKET_MEDIA_TYPE, HUMAN_REVIEW_RESPONSE_MEDIA_TYPE, HUMAN_REVIEW_REVEAL_RECEIPT_MEDIA_TYPE, HUMAN_REVIEW_ROSTER_MEDIA_TYPE, HUMAN_REVIEW_VISIBILITY_RECEIPT_MEDIA_TYPE, SCREENING_REVEAL_RECEIPT_MEDIA_TYPE, SCREENING_TABLE_MEDIA_TYPE, SCREENING_TABLE_V2_MEDIA_TYPE, HumanReviewOperatorAssertionSchema, HumanReviewPacketSchema, HumanReviewReplacementLedgerSchema, HumanReviewResponseSchema, HumanReviewRevealReceiptSchema, HumanReviewRosterSchema, HumanReviewVisibilityReceiptSchema, ScreeningRevealReceiptSchema, ScreeningTableSchema, ScreeningTableV2Schema, PromptedScreeningProcedureV1Schema, ScreeningPoolSchema, SCREENING_POOL_V2_PROTOCOL, PROMPTED_SCREENING_LIMITATIONS, PROMPTED_SCREENING_PROFILE, } from "./contracts.js";
+import { selectPromptedScreeningPool, PromptedScreeningSelectionError } from "./prompted-selection.js";
+import { parseScreeningSampleCommitmentBytes, promptedScreeningCommitmentView, } from "./prompted-commitment.js";
 import { readOrderedAdmissionVerdictMeasurements, readAdmissionVerdictEnvelope } from "./result-evaluation.js";
 import { computeScreeningPoolDigest, computeScreeningSample, ScreeningSampleError } from "./screening-sample.js";
 // Verbatim duplicate of `schema.ts`'s `BUNDLE_V4_ADMISSION_EVIDENCE_ROLES`, hand-kept in sync
@@ -432,22 +434,36 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
             if (tableEvidence.mediaType !== SCREENING_TABLE_V2_MEDIA_TYPE)
                 fail("screeningTable", "v2 table protocol must use the v2 media type");
             const procedure = exactCanonical(PromptedScreeningProcedureV1Schema, resolve(state, screeningTable.procedureSha256, "screeningTable.procedureSha256", "screening-procedure"), "screeningProcedure");
-            const pool = exactCanonical(ScreeningPoolV1Schema, resolve(state, screeningTable.poolSha256, "screeningTable.poolSha256", "screening-pool"), "screeningPool");
-            const commitment = exactCanonical(ScreeningSampleCommitmentV1Schema, resolve(state, screeningTable.sampleCommitmentSha256, "screeningTable.sampleCommitmentSha256", "screening-sample-commitment"), "screeningSampleCommitment");
+            const pool = exactCanonical(ScreeningPoolSchema, resolve(state, screeningTable.poolSha256, "screeningTable.poolSha256", "screening-pool"), "screeningPool");
+            let commitment;
+            try {
+                commitment = parseScreeningSampleCommitmentBytes(resolve(state, screeningTable.sampleCommitmentSha256, "screeningTable.sampleCommitmentSha256", "screening-sample-commitment"));
+            }
+            catch (cause) {
+                fail("screeningSampleCommitment", cause instanceof Error ? cause.message : "screening sample commitment is invalid", cause);
+            }
+            const commitmentView = promptedScreeningCommitmentView(commitment);
             resolve(state, screeningTable.coordinatorPromptSha256, "screeningTable.coordinatorPromptSha256", "screening-prompt");
             resolve(state, screeningTable.samplingScriptSha256, "screeningTable.samplingScriptSha256", "screening-sampling-script");
             resolve(state, screeningTable.transcriptSha256, "screeningTable.transcriptSha256", "screening-transcript");
             if (procedure.coordinatorPromptSha256 !== screeningTable.coordinatorPromptSha256
                 || procedure.transcriptSha256 !== screeningTable.transcriptSha256
                 || pool.draftId !== input.expectedDraftId
-                || commitment.draftId !== input.expectedDraftId
-                || commitment.poolSha256 !== screeningTable.poolSha256
-                || commitment.poolIdentityCommitmentSha256 !== pool.identityCommitmentSha256
+                || (commitmentView.draftId !== undefined && commitmentView.draftId !== input.expectedDraftId)
+                || (commitmentView.poolSha256 !== undefined && commitmentView.poolSha256 !== screeningTable.poolSha256)
+                || commitmentView.poolIdentityCommitmentSha256 !== pool.identityCommitmentSha256
+                || (commitmentView.samplingScriptSha256 !== undefined && commitmentView.samplingScriptSha256 !== screeningTable.samplingScriptSha256)
                 || Date.parse(procedure.sealedAt) > Date.parse(screeningTable.sealedAt)
-                || Date.parse(pool.sealedAt) > Date.parse(commitment.committedAt)
-                || Date.parse(commitment.committedAt) > Date.parse(screeningTable.sealedAt))
+                || Date.parse(pool.sealedAt) > Date.parse(screeningTable.sealedAt)
+                || (commitmentView.poolSha256 !== undefined && Date.parse(pool.sealedAt) > Date.parse(commitmentView.committedAt))
+                || Date.parse(commitmentView.committedAt) > Date.parse(screeningTable.sealedAt))
                 fail("screeningTable", "prompted procedure, prompt, transcript, pool, commitment, draft, or timestamps do not join");
-            const poolIdentities = pool.items.map((item) => item.itemSha256);
+            const poolIdentities = pool.protocol === SCREENING_POOL_V2_PROTOCOL
+                ? pool.items.map((item) => item.screeningIdentitySha256)
+                : pool.items.map((item) => item.itemSha256);
+            if (commitmentView.registeredIdentitySha256s !== undefined
+                && !sameStrings([...poolIdentities].sort(compareCodeUnitStrings), commitmentView.registeredIdentitySha256s))
+                fail("screeningSampleCommitment.candidateItemDigests", "registered identities do not exactly cover the later pool bridge");
             if (computeScreeningPoolDigest(poolIdentities) !== pool.identityCommitmentSha256)
                 fail("screeningPool.identityCommitmentSha256", "identity commitment does not match the sorted unique pool identities");
             const itemIds = new Set();
@@ -458,24 +474,24 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
                 itemIds.add(item.itemId);
             }
             const rowIdentities = screeningTable.rows.map((row) => row.itemSha256);
-            const sortedPoolIdentities = [...poolIdentities].sort(compareCodeUnitStrings);
-            if (!sameStrings(rowIdentities, sortedPoolIdentities))
-                fail("screeningTable.rows", "v2 table must cover all 664 pool identities in sorted order");
+            const sortedPoolItemSha256s = pool.items.map((item) => item.itemSha256).sort(compareCodeUnitStrings);
+            if (!sameStrings(rowIdentities, sortedPoolItemSha256s))
+                fail("screeningTable.rows", "v2 table must cover all 664 pool item digests in sorted order");
             const poolByItem = new Map(pool.items.map((item) => [item.itemSha256, item]));
             for (const row of screeningTable.rows) {
                 const poolItem = poolByItem.get(row.itemSha256);
                 if (row.intendedLabel !== poolItem.intendedLabel)
                     fail("screeningTable.rows", `row ${row.itemSha256} intended label differs from the sealed pool`);
-                if (row.ritsuDecision.checked && (Date.parse(row.ritsuDecision.decidedAt) < Date.parse(commitment.committedAt)
+                if (row.ritsuDecision.checked && (Date.parse(row.ritsuDecision.decidedAt) < Date.parse(commitmentView.committedAt)
                     || Date.parse(row.ritsuDecision.decidedAt) > Date.parse(screeningTable.sealedAt)))
                     fail("screeningTable.rows", `row ${row.itemSha256} has a Ritsu decision outside the committed-sample-to-table interval`);
             }
-            sampleSeed = commitment.sampleSeed;
-            sampleSize = commitment.sampleSize;
+            sampleSeed = commitmentView.sampleSeed;
+            sampleSize = commitmentView.sampleSize;
             sampleIdentities = poolIdentities;
             promptedScreeningProcedureSha256 = screeningTable.procedureSha256;
             promptedScreeningPool = pool;
-            promptedCommittedSample = commitment.sampleItemSha256s;
+            promptedCommittedSample = commitmentView.sampleItemSha256s;
         }
         screeningRowsByItem = new Map(screeningTable.rows.map((row) => [row.itemSha256, row]));
         // (1) Sample membership: recomputed by screening-sample/1, never by executing the sealed
@@ -497,21 +513,26 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
         screeningSample = new Set(sampleResult.sample);
         if (promptedCommittedSample !== undefined && !sameStrings([...sampleResult.sample].sort(compareCodeUnitStrings), promptedCommittedSample))
             fail("screeningSampleCommitment.sampleItemSha256s", "public sample membership differs from screening-sample/1 recomputation");
+        const sampledItemSha256s = promptedScreeningPool?.protocol === SCREENING_POOL_V2_PROTOCOL
+            ? new Set(promptedScreeningPool.items
+                .filter((item) => screeningSample.has(item.screeningIdentitySha256))
+                .map((item) => item.itemSha256))
+            : screeningSample;
         // (2) Required hand checks: flagged := rows where NOT agreed. Every row in flagged ∪ sample
         // must carry handChecked === true.
         for (const row of screeningTable.rows) {
             const flagged = !screeningRowAgreed(row);
-            if ((flagged || screeningSample.has(row.itemSha256)) && !screeningRowChecked(row)) {
+            if ((flagged || sampledItemSha256s.has(row.itemSha256)) && !screeningRowChecked(row)) {
                 fail("screeningTable.rows", `row ${row.itemSha256} is flagged or sampled but was never hand-checked`);
             }
         }
         // (3) Sample agreement rate -- the one definition (spec §6.5(3)), symmetric on purpose. Every
         // row in `screeningSample` is hand-checked by check (2) above, so `handVerdict` is defined.
-        const sampleMatches = [...screeningSample].filter((sampledItemSha256) => {
+        const sampleMatches = [...sampledItemSha256s].filter((sampledItemSha256) => {
             const row = screeningRowsByItem.get(sampledItemSha256);
             return screeningRowAgreed(row) === (screeningRowHandVerdict(row) === "confirm");
         }).length;
-        screeningSampleAgreementRate = sampleMatches / screeningSample.size;
+        screeningSampleAgreementRate = sampleMatches / sampledItemSha256s.size;
     }
     const resolutions = manifest.labelResolutionSha256s.map((digest, index) => ({
         digest,
@@ -647,20 +668,19 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
     }
     const promptedExpectedReplacements = new Map();
     if (promptedScreeningPool !== undefined) {
-        const slotIds = [...new Set(promptedScreeningPool.items.map((item) => item.slotId))].sort(compareCodeUnitStrings);
-        const expectedAccepted = new Set();
-        for (const slotId of slotIds) {
-            const slotItems = promptedScreeningPool.items.filter((item) => item.slotId === slotId);
-            const main = slotItems.find((item) => item.poolKind === "main");
-            const reserves = slotItems
-                .filter((item) => item.poolKind === "reserve")
-                .sort((left, right) => left.reserveOrder - right.reserveOrder);
-            const winner = [main, ...reserves].find((item) => screeningRowAdmitted(screeningRowsByItem.get(item.itemSha256)));
-            if (winner === undefined)
-                fail("screeningPool.items", `${slotId} has no admissible main or reserve candidate`);
-            expectedAccepted.add(winner.itemSha256);
-            if (winner.itemSha256 !== main.itemSha256)
-                promptedExpectedReplacements.set(main.itemSha256, winner.itemSha256);
+        let selection;
+        try {
+            selection = selectPromptedScreeningPool(promptedScreeningPool, screeningRowsByItem);
+        }
+        catch (cause) {
+            fail("screeningPool.items", cause instanceof PromptedScreeningSelectionError ? cause.message : "prompted reserve selection failed", cause);
+        }
+        const expectedAccepted = new Set(selection.winners.map((item) => item.itemSha256));
+        for (const replacement of selection.replacements) {
+            promptedExpectedReplacements.set(replacement.excludedMain.itemSha256, {
+                replacementItemSha256: replacement.replacement.itemSha256,
+                receivingSlotId: replacement.receivingSlotId,
+            });
         }
         const actualAccepted = [...acceptedItems].sort(compareCodeUnitStrings);
         if (!sameStrings(actualAccepted, [...expectedAccepted].sort(compareCodeUnitStrings)))
@@ -687,7 +707,14 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
     let previousPosition = 0;
     for (const [index, entry] of ledger.entries.entries()) {
         const path = `replacementLedger.entries.${index}`;
-        if (entry.excludedPoolPosition <= previousPosition)
+        const sharedPool = promptedScreeningPool?.protocol === SCREENING_POOL_V2_PROTOCOL;
+        if (sharedPool) {
+            const previousSlotId = index === 0 ? undefined : ledger.entries[index - 1].receivingSlotId;
+            if (entry.receivingSlotId === undefined || (previousSlotId !== undefined && compareCodeUnitStrings(previousSlotId, entry.receivingSlotId) >= 0)) {
+                fail(path, "shared-reserve ledger entries are not in deterministic receiving-slot order");
+            }
+        }
+        else if (entry.excludedPoolPosition <= previousPosition)
             fail(path, "ledger entries are not in deterministic pool order");
         previousPosition = entry.excludedPoolPosition;
         if (excludedItems.has(entry.excludedItemSha256) || acceptedItems.has(entry.excludedItemSha256))
@@ -706,13 +733,31 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
         if (promptedScreeningPool !== undefined) {
             const excludedPoolItem = promptedScreeningPool.items.find((item) => item.itemSha256 === entry.excludedItemSha256);
             const replacementPoolItem = promptedScreeningPool.items.find((item) => item.itemSha256 === entry.replacementItemSha256);
-            if (excludedPoolItem?.poolKind !== "main"
-                || replacementPoolItem?.poolKind !== "reserve"
-                || excludedPoolItem.slotId !== replacementPoolItem.slotId
-                || entry.excludedPoolPosition !== excludedPoolItem.poolPosition
-                || entry.replacementPoolPosition !== replacementPoolItem.poolPosition
-                || promptedExpectedReplacements.get(entry.excludedItemSha256) !== entry.replacementItemSha256)
-                fail(path, "ledger does not name the deterministic first-admissible reserve for the exact sealed slot positions");
+            const expected = promptedExpectedReplacements.get(entry.excludedItemSha256);
+            let sealedPoolItemsMatch = false;
+            let actualReceivingSlotId;
+            if (promptedScreeningPool.protocol === SCREENING_POOL_V2_PROTOCOL) {
+                if (excludedPoolItem?.poolKind === "main" && replacementPoolItem?.poolKind === "reserve") {
+                    actualReceivingSlotId = entry.receivingSlotId;
+                    sealedPoolItemsMatch = excludedPoolItem.candidateClass === replacementPoolItem.candidateClass
+                        && excludedPoolItem.stratum === replacementPoolItem.stratum
+                        && entry.receivingSlotId === excludedPoolItem.slotId;
+                }
+            }
+            else if (excludedPoolItem?.poolKind === "main"
+                && replacementPoolItem?.poolKind === "reserve"
+                && "slotId" in excludedPoolItem
+                && "slotId" in replacementPoolItem) {
+                actualReceivingSlotId = excludedPoolItem.slotId;
+                sealedPoolItemsMatch = excludedPoolItem.slotId === replacementPoolItem.slotId
+                    && entry.receivingSlotId === undefined;
+            }
+            if (!sealedPoolItemsMatch
+                || entry.excludedPoolPosition !== excludedPoolItem?.poolPosition
+                || entry.replacementPoolPosition !== replacementPoolItem?.poolPosition
+                || expected?.replacementItemSha256 !== entry.replacementItemSha256
+                || expected.receivingSlotId !== actualReceivingSlotId)
+                fail(path, "ledger does not name the deterministic first-admissible reserve and its receiving slot at the exact sealed positions");
         }
         // Branches on admission mode (spec §6.4, §6.5 check (4); ratified resolution to G-1): a
         // screened exclusion is verified against the screening table's own per-row admission rule
@@ -771,11 +816,12 @@ export function verifyBinaryJudgmentAdmissionClosure(input, ports) {
             stratum: entry.stratum,
             reason: entry.reason,
             replacementItemSha256: prefixed(entry.replacementItemSha256),
+            ...(entry.receivingSlotId === undefined ? {} : { receivingSlotId: entry.receivingSlotId }),
         });
     }
     if (promptedScreeningPool !== undefined) {
         const ledgerReplacements = new Map(ledger.entries.map((entry) => [entry.excludedItemSha256, entry.replacementItemSha256]));
-        if (ledgerReplacements.size !== promptedExpectedReplacements.size || [...promptedExpectedReplacements].some(([excludedItem, replacementItem]) => ledgerReplacements.get(excludedItem) !== replacementItem)) {
+        if (ledgerReplacements.size !== promptedExpectedReplacements.size || [...promptedExpectedReplacements].some(([excludedItem, expected]) => ledgerReplacements.get(excludedItem) !== expected.replacementItemSha256)) {
             fail("replacementLedger.entries", "ledger does not exactly cover every prompted main-slot replacement");
         }
     }

package/dist/assets.d.ts

@@ -10,7 +10,12 @@ export interface PublicAssetInput {
     /** Canonically sorted identities for every authenticated `records/<sha>.bin` closure member. */
     readonly recordSha256s: readonly string[];
     readonly dissentCellKeys: readonly string[];
-    /** Verifier-derived, authenticated human projection. Absent only for legacy bundle assets. */
+    /**
+     * Verifier-derived, authenticated human projection. Absent only for the
+     * qualification-projecting profile (`benchmark-product-public-bundle/4`, `/7`, and `/8`), which
+     * carries `binaryQualification` instead. There is no third, comparison-free profile: a
+     * bundle rendered with neither field is refused at verification (issue #2984).
+     */
     readonly comparison?: PublicComparisonView;
     /** Producer-verified binary admission/instrument facts. Required for claim-package/2 only. */
     readonly binaryQualification?: {
@@ -26,6 +31,21 @@ export interface PublicAssetInput {
         }[];
     };
 }
+/**
+ * The six-variable disclosure table (issue #2839, ruling Q4: the bundle's own `index.html` and
+ * `README.md` are S2's; the site template is packet R1's).
+ *
+ * Rendered from `claim.disclosure` — a verified fact the claim already carries — so this hangs off
+ * the REPORT/claim facts rather than off a format test, and every bundle without a declaration
+ * renders byte-identically to what it rendered before this section existed.
+ *
+ * `measured-here` and `disclosed-by-publisher` are kept visually distinct and are never merged into
+ * one list: the whole point of the record is that a reader can tell at a glance which variables this
+ * venue proved and which it only carries. Nothing here counts, scores, or ranks the statuses (design
+ * §8), and there is no explanatory caption — the status token and the statement are the content.
+ */
+export declare function disclosureSpecificationHtml(input: PublicAssetInput): string;
+export declare function disclosureSpecificationMarkdown(input: PublicAssetInput): string;
 export declare function binaryAdmissionHtml(input: PublicAssetInput): string;
 export declare function binaryAdmissionMarkdown(input: PublicAssetInput): string;
 /** Fixed, deterministic public-bundle/2 presentation bytes. The builder only projects already

package/dist/assets.js

@@ -1,4 +1,4 @@
-import { BENCHMARKING_METHOD_IDS } from "@jinn-network/benchmarking-records";
+import { BENCHMARKING_METHOD_IDS, DISCLOSURE_VARIABLE_KEYS } from "@jinn-network/benchmarking-records";
 import { validateBinaryInstrumentQualificationProjection } from "@jinn-network/benchmarking-aggregate";
 import { canonicalJsonBytes } from "@jinn-network/trust-core";
 import { readFileSync } from "node:fs";
@@ -450,6 +450,57 @@ function publicationGradeWording(truthAdmission) {
         }
     }
 }
+/**
+ * The six-variable disclosure table (issue #2839, ruling Q4: the bundle's own `index.html` and
+ * `README.md` are S2's; the site template is packet R1's).
+ *
+ * Rendered from `claim.disclosure` — a verified fact the claim already carries — so this hangs off
+ * the REPORT/claim facts rather than off a format test, and every bundle without a declaration
+ * renders byte-identically to what it rendered before this section existed.
+ *
+ * `measured-here` and `disclosed-by-publisher` are kept visually distinct and are never merged into
+ * one list: the whole point of the record is that a reader can tell at a glance which variables this
+ * venue proved and which it only carries. Nothing here counts, scores, or ranks the statuses (design
+ * §8), and there is no explanatory caption — the status token and the statement are the content.
+ */
+export function disclosureSpecificationHtml(input) {
+    const disclosure = input.claim.disclosure;
+    if (disclosure === undefined)
+        return "";
+    const rows = DISCLOSURE_VARIABLE_KEYS.map((key) => {
+        const entry = disclosure.variables[key];
+        const detail = entry.status === "undisclosed"
+            ? `<p class="disclosure-reason">${escapeMarkup(entry.reason)}</p>`
+            : `<p class="disclosure-statement">${escapeMarkup(entry.statement)}</p>`;
+        const sources = entry.status === "disclosed-by-publisher" && entry.sources !== undefined
+            ? `<ul class="disclosure-sources">${entry.sources.map((source) => `<li>${escapeMarkup(source.uri)}</li>`).join("")}</ul>`
+            : "";
+        const evidence = entry.status === "measured-here"
+            ? `<ul class="disclosure-evidence">${entry.evidence.map((citation) => `<li><span class="role">${escapeMarkup(citation.role)}</span> <span class="digest">${escapeMarkup(citation.digest.sha256)}</span></li>`).join("")}</ul>`
+            : "";
+        return `<div class="disclosure-variable disclosure-${escapeMarkup(entry.status)}"><dt>${escapeMarkup(key)}</dt><dd><span class="disclosure-status">${escapeMarkup(entry.status)}</span>${detail}${sources}${evidence}</dd></div>`;
+    }).join("");
+    return `<section id="disclosure-specification" aria-labelledby="disclosure-specification-heading"><h2 id="disclosure-specification-heading">Six-variable disclosure</h2><dl class="facts disclosure">${rows}</dl><p class="digest">${escapeMarkup(disclosure.specification)} · record ${escapeMarkup(disclosure.recordSha256)} · subject ${escapeMarkup(disclosure.subjectSha256)}</p></section>`;
+}
+export function disclosureSpecificationMarkdown(input) {
+    const disclosure = input.claim.disclosure;
+    if (disclosure === undefined)
+        return "";
+    const rows = DISCLOSURE_VARIABLE_KEYS.map((key) => {
+        const entry = disclosure.variables[key];
+        const detail = entry.status === "undisclosed"
+            ? `\n  - ${escapeMarkdown(entry.reason)}`
+            : `\n  - ${escapeMarkdown(entry.statement)}`;
+        const sources = entry.status === "disclosed-by-publisher" && entry.sources !== undefined
+            ? entry.sources.map((source) => `\n  - source: ${escapeMarkdown(source.uri)}`).join("")
+            : "";
+        const evidence = entry.status === "measured-here"
+            ? entry.evidence.map((citation) => `\n  - ${escapeMarkdown(citation.role)}: ${escapeMarkdown(citation.digest.sha256)}`).join("")
+            : "";
+        return `- ${escapeMarkdown(key)}: ${escapeMarkdown(entry.status)}${detail}${sources}${evidence}`;
+    }).join("\n");
+    return `## Six-variable disclosure\n\n${rows}\n\n- ${escapeMarkdown(disclosure.specification)}\n- record: ${escapeMarkdown(disclosure.recordSha256)}\n- subject: ${escapeMarkdown(disclosure.subjectSha256)}\n\n`;
+}
 export function binaryAdmissionHtml(input) {
     const admission = input.binaryQualification;
     if (admission === undefined)
@@ -493,6 +544,12 @@ function neutralClaimHtml(facts) {
     }
     return '<p class="neutral">Verified binary-instrument qualification. Facts are presented per instrument without comparative conclusions.</p>';
 }
+// Task-selection provenance (issue #2980) is sealed into the Run and verified under
+// `claim-consistency`, but deliberately renders NOTHING here, and no asset below projects it.
+// The classic and anchored allocations pin `@colophon-claims/verify@0.1.0`, whose
+// `verifyPublicBundleSnapshot` byte-compares every presentation asset against its own rebuild, so
+// a bundle that rendered the sentence would carry an instruction to run a verifier that refuses
+// it. Restoring the render is issue #3416, once the reader line that derives it is re-pinned.
 function buildIndex(input, reportFacts, claimFacts) {
     const outcome = input.matrix.completeness.runOutcome;
     const status = reportFacts.kind === "binary" ? qualificationOutcomeLabel(outcome) : outcomeLabel(outcome);
@@ -543,7 +600,7 @@ ${neutralClaimHtml(reportFacts)}
 </header>
 <main>
 <section class="adverse" aria-labelledby="adverse-heading"><h2 id="adverse-heading">Prominent adverse facts</h2>${list(adverse, "No adverse facts stated.")}</section>${input.comparison === undefined ? "" : `\n${comparisonSectionHtml(input.comparison)}`}
-<section aria-labelledby="scope-heading"><h2 id="scope-heading">Benchmark and configuration scope</h2><dl class="facts"><div><dt>Benchmark digest</dt><dd class="digest">${input.claim.scope.benchmarkSha256}</dd></div><div><dt>Tasks</dt><dd>${input.claim.scope.taskCount}</dd></div><div><dt>Replicates</dt><dd>${input.claim.scope.replicates}</dd></div><div><dt>Venue</dt><dd>${escapeMarkup(input.claim.scope.venue)}</dd></div></dl><h3>Arms and pinned configuration</h3><ul>${arms}</ul></section>${reportFacts.kind === "binary" ? binaryAdmissionHtml(input) : ""}
+<section aria-labelledby="scope-heading"><h2 id="scope-heading">Benchmark and configuration scope</h2><dl class="facts"><div><dt>Benchmark digest</dt><dd class="digest">${input.claim.scope.benchmarkSha256}</dd></div><div><dt>Tasks</dt><dd>${input.claim.scope.taskCount}</dd></div><div><dt>Replicates</dt><dd>${input.claim.scope.replicates}</dd></div><div><dt>Venue</dt><dd>${escapeMarkup(input.claim.scope.venue)}</dd></div></dl><h3>Arms and pinned configuration</h3><ul>${arms}</ul></section>${reportFacts.kind === "binary" ? binaryAdmissionHtml(input) : ""}${disclosureSpecificationHtml(input)}
 <section aria-labelledby="matrix-heading"><h2 id="matrix-heading">Sealed Matrix accounting</h2><p class="source-label">Source: authenticated <a href="matrix.json">matrix.json</a>; values below are copied without reconciliation.</p><pre>${escapeMarkup(canonicalText({ completeness: input.matrix.completeness, attrition: input.matrix.attrition }))}</pre><h3>Completeness and attrition</h3><dl class="facts"><div><dt>Matrix run outcome</dt><dd>${escapeMarkup(outcome)}</dd></div><div><dt>Matrix expected</dt><dd>${input.matrix.completeness.expected}</dd></div><div><dt>Matrix judged</dt><dd>${input.matrix.completeness.judged}</dd></div><div><dt>Matrix floor</dt><dd>${escapeMarkup(input.matrix.completeness.floor)}</dd></div></dl><div class="table-scroll" tabindex="0" role="region" aria-label="Per-arm Matrix attrition"><table><caption>Exact per-arm attrition stored in the Matrix</caption><thead><tr><th scope="col">Arm</th><th scope="col">Expected</th><th scope="col">Judged</th><th scope="col">Unjudged</th><th scope="col">Unscorable</th><th scope="col">Expired</th><th scope="col">Invalidated</th><th scope="col">Excluded</th><th scope="col">Replacements</th></tr></thead><tbody>${attritionRows(input)}</tbody></table></div><h3>Matrix asymmetry flags</h3>${list(input.matrix.attrition.asymmetryFlags, "None recorded in the Matrix.")}</section>
 <section aria-labelledby="report-heading"><h2 id="report-heading">Sealed Report facts</h2><p class="source-label">Source: authenticated <a href="report.json">report.json</a>; values below are copied without reconciliation.</p><h3>${factsHeading(reportFacts, "report")}</h3>${armResultsHtml(reportFacts, "Exact wilson@1 values from the sealed Report")}<h3>Method and assurance facts stored in the Report</h3><dl class="facts"><div><dt>Report method</dt><dd>${escapeMarkup(input.report.method.id)} @ ${escapeMarkup(input.report.method.version)}</dd></div><div><dt>Report preregistered</dt><dd>${input.report.preregistered === true ? "Yes" : "No"}</dd></div></dl><h3>Report parameters</h3><pre>${escapeMarkup(canonicalText(input.report.method.parameters))}</pre><h3>Report conflicts</h3><pre>${escapeMarkup(canonicalText(reportFacts.conflicted))}</pre><h3>Report disclosures</h3><pre>${escapeMarkup(canonicalText(input.report.disclosures))}</pre></section>
 <section aria-labelledby="claim-heading"><h2 id="claim-heading">Stored Claim facts</h2><p class="source-label">Source: authenticated <a href="claim-package.json">claim-package.json</a>; values below are copied without reconciliation.</p><h3>${factsHeading(claimFacts, "claim")}</h3>${armResultsHtml(claimFacts, "Exact arm values stored in the Claim package")}<h3>Claim method and preregistration</h3><dl class="facts"><div><dt>Claim method</dt><dd>${escapeMarkup(input.claim.method.id)} @ ${escapeMarkup(input.claim.method.version)}</dd></div><div><dt>Claim preregistered</dt><dd>${input.claim.method.preregistered ? "Yes" : "No"}</dd></div><div><dt>Assurance preset</dt><dd>${escapeMarkup(input.claim.assurance.preset)}</dd></div></dl><h3>Claim parameters</h3><pre>${escapeMarkup(canonicalText(input.claim.method.parameters))}</pre><h3>Claim completeness</h3><pre>${escapeMarkup(canonicalText(input.claim.completeness))}</pre><h3>Claim attrition</h3><pre>${escapeMarkup(canonicalText(input.claim.attrition))}</pre><h3>Claim conflicts</h3><pre>${escapeMarkup(canonicalText(input.claim.conflicted))}</pre><h3>Claim disclosures</h3><h4>Unverifiable axes, integrity tiers, and per-subject disclosures</h4><pre>${escapeMarkup(canonicalText(input.claim.disclosures))}</pre><h3>Resolved assurance primitives</h3><pre>${escapeMarkup(canonicalText(input.claim.assurance.resolved))}</pre><p>${escapeMarkup(input.claim.assurance.disclosure)}</p><h3>Rehearsal disclosure</h3>${rehearsalHtml}</section>
@@ -749,7 +806,7 @@ ${adverse.map((value) => `- ${escapeMarkdown(value)}`).join("\n")}
 
 ## Configurations
 
-${arms}${reportFacts.kind === "binary" ? `\n\n${binaryAdmissionMarkdown(input).trimEnd()}` : ""}
+${arms}${reportFacts.kind === "binary" ? `\n\n${binaryAdmissionMarkdown(input).trimEnd()}` : ""}${input.claim.disclosure === undefined ? "" : `\n\n${disclosureSpecificationMarkdown(input).trimEnd()}`}
 
 ## Sealed Matrix accounting
 

package/dist/binding/beacon-binding.d.ts

@@ -0,0 +1,230 @@
+import { z } from "zod";
+/** The procedure identifier a binding record must carry. */
+export declare const BEACON_BINDING_PROCEDURE: "beacon-binding/1";
+/**
+ * How strongly a source's own round index proves that its value postdates a given instant.
+ *
+ * `deterministic-round-time` sources index rounds by a published arithmetic schedule, so the
+ * proof is offline arithmetic. `attributive-height` sources index by block height, whose time
+ * needs headers the reader must obtain separately -- the claim is then what the chain asserts,
+ * checked elsewhere, and never an offline proof.
+ */
+export type BeaconSourceTimeBasis = "deterministic-round-time" | "attributive-height";
+export interface BeaconSourceDefinition {
+    readonly timeBasis: BeaconSourceTimeBasis;
+    /** Unix seconds of round 1. Present only on `deterministic-round-time` sources. */
+    readonly genesisTimeSeconds?: number;
+    /** Seconds between rounds. Present only on `deterministic-round-time` sources. */
+    readonly periodSeconds?: number;
+    /** Reader-facing name used by the report face. */
+    readonly displayName: string;
+}
+/**
+ * The beacons this procedure admits. Values are the sources' own published chain parameters and
+ * are part of the derivation: a reader recomputing `beaconRoundInstant` needs exactly these
+ * numbers, so they live in the code rather than in a comment.
+ */
+export declare const BEACON_SOURCES: {
+    readonly "drand/quicknet": {
+        readonly timeBasis: "deterministic-round-time";
+        readonly genesisTimeSeconds: 1692803367;
+        readonly periodSeconds: 3;
+        readonly displayName: "drand quicknet";
+    };
+    readonly "drand/default": {
+        readonly timeBasis: "deterministic-round-time";
+        readonly genesisTimeSeconds: 1595431050;
+        readonly periodSeconds: 30;
+        readonly displayName: "drand default chain";
+    };
+    readonly "bitcoin/mainnet": {
+        readonly timeBasis: "attributive-height";
+        readonly displayName: "Bitcoin mainnet";
+    };
+};
+export type BeaconSourceId = keyof typeof BEACON_SOURCES;
+export declare const BEACON_SOURCE_IDS: readonly BeaconSourceId[];
+/**
+ * A schema-level sanity ceiling on a round index. Not a beacon limit, and deliberately not the
+ * representability guarantee either: the ceiling that matters is per-source, because it falls out
+ * of each source's own period, and one shared number cannot be sound for all of them. Quicknet's
+ * 3-second period puts round 1,000,000,000,000 some 95,000 years out and inside what `Date`
+ * represents; the default chain's 30-second period puts the same round ten times further out and
+ * outside it. So this bound only rejects the absurd, and `beaconRoundInstant` -- not the schema --
+ * owns the guarantee that the arithmetic stays representable. Every real Bitcoin height is eight
+ * orders of magnitude below this.
+ */
+export declare const MAX_BEACON_ROUND = 1000000000000;
+/**
+ * A public beacon reference: which beacon, which round or height, and the value it published
+ * there. `round` is the source's own index -- a drand round number, a Bitcoin block height.
+ */
+export declare const BeaconReferenceSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        "drand/quicknet": "drand/quicknet";
+        "drand/default": "drand/default";
+        "bitcoin/mainnet": "bitcoin/mainnet";
+    }>;
+    round: z.ZodNumber;
+    value: z.ZodString;
+}, z.core.$strict>;
+export type BeaconReference = z.infer<typeof BeaconReferenceSchema>;
+/**
+ * The two shapes, disjoint by construction so no reader can mistake the weaker binding for the
+ * stronger one:
+ *
+ * - `sampled` -- a slate drawn from a larger pool. `sample` is the claim; the verifier recomputes
+ *   it and fails on mismatch.
+ * - `census` -- the whole declared population runs, so there is no draw. `order` is the claim, and
+ *   it binds execution order only.
+ */
+export declare const RunBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"sampled">;
+    poolItemSha256s: z.ZodArray<z.ZodString>;
+    sampleSize: z.ZodNumber;
+    sample: z.ZodArray<z.ZodString>;
+    procedure: z.ZodLiteral<"beacon-binding/1">;
+    sealDigest: z.ZodString;
+    sealedAt: z.ZodString;
+    beacon: z.ZodObject<{
+        source: z.ZodEnum<{
+            "drand/quicknet": "drand/quicknet";
+            "drand/default": "drand/default";
+            "bitcoin/mainnet": "bitcoin/mainnet";
+        }>;
+        round: z.ZodNumber;
+        value: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"census">;
+    itemSha256s: z.ZodArray<z.ZodString>;
+    order: z.ZodArray<z.ZodString>;
+    procedure: z.ZodLiteral<"beacon-binding/1">;
+    sealDigest: z.ZodString;
+    sealedAt: z.ZodString;
+    beacon: z.ZodObject<{
+        source: z.ZodEnum<{
+            "drand/quicknet": "drand/quicknet";
+            "drand/default": "drand/default";
+            "bitcoin/mainnet": "bitcoin/mainnet";
+        }>;
+        round: z.ZodNumber;
+        value: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "mode">;
+export type RunBinding = z.infer<typeof RunBindingSchema>;
+export declare class RunBindingError extends Error {
+    readonly name = "RunBindingError";
+    readonly path: string;
+    constructor(path: string, detail: string);
+}
+/**
+ * The instant a `deterministic-round-time` beacon published `round`, as an RFC 3339 UTC string, or
+ * `undefined` for a source whose round index carries no offline time. The schedule is
+ * `genesis + (round - 1) * period`: round 1 is published at genesis.
+ *
+ * Refuses (throws `RunBindingError`) when that instant falls outside the range `Date` represents.
+ * The check lives here rather than on the schema because the largest representable round is a
+ * function of the source's own period -- the default chain runs out ten times earlier than
+ * quicknet does -- so a single schema ceiling would leave the slower source's tail passing
+ * validation and then throwing an untyped `RangeError` from `toISOString` deep inside
+ * verification. Guarding the arithmetic where the arithmetic happens makes the typed refusal a
+ * property of this function, and therefore true for every source and every caller.
+ */
+export declare function beaconRoundInstant(beacon: Pick<BeaconReference, "source" | "round">): string | undefined;
+/** The one round a run sealed at a given instant may bind to, and when that round is published. */
+export interface RequiredBeaconRound {
+    readonly round: number;
+    /** RFC 3339 UTC, from the source's own schedule -- the same arithmetic `beaconRoundInstant` does. */
+    readonly publishedAt: string;
+}
+/**
+ * The one round a run sealed at `sealedAt` may bind to on a `deterministic-round-time` source: the
+ * first round that source publishes STRICTLY after the seal (issue #3322).
+ *
+ * The point is that the seal already fixes it. `verifyRunBinding` admits any round whose instant
+ * postdates the seal, which makes the beacon VALUE unpredictable but leaves the CHOICE among
+ * realized values open: between seal and binding an operator sees many published rounds, can derive
+ * what each would produce, and can bind the one they prefer. The standard construction is to commit
+ * at seal time to a specific future round -- and for a scheduled source no separate commitment
+ * record is needed, because `(source, sealedAt)` already determines exactly one such round, and both
+ * are fixed at seal time and carried by the binding itself.
+ *
+ * From `instant(r) = genesis + (r - 1) * period`, the smallest `r` with `instant(r) > sealedAt` is
+ * `floor((sealedAt - genesis) / period) + 2`, clamped to round 1 for a seal that predates genesis.
+ *
+ * `undefined` -- meaning no round is derivable, so the operator's choice remains and the report face
+ * says so -- when the source indexes by block height rather than by a schedule, when `sealedAt` is
+ * unparseable, or when the required round leaves `MAX_BEACON_ROUND` or the representable range.
+ */
+export declare function requiredBeaconRound(source: BeaconSourceId, sealedAt: string): RequiredBeaconRound | undefined;
+export interface BeaconOrderParams {
+    /** `sha256:<64 lowercase hex>` -- the sealed record the beacon postdates. */
+    readonly sealDigest: string;
+    /** The beacon's published value, 64 lowercase hex characters. */
+    readonly beaconValue: string;
+    /** The identity set to order. Non-empty, unique, each `sha256:<64 lowercase hex>`. */
+    readonly itemSha256s: readonly string[];
+}
+export interface BeaconOrderResult {
+    /** `sha256:<64 lowercase hex>` of the sorted, unique identity set. */
+    readonly poolDigest: string;
+    /** Every item, ascending by HMAC stream (unsigned byte order), ties by code-unit order. */
+    readonly order: readonly string[];
+}
+/**
+ * The derivation itself. Refuses (throws `RunBindingError`) when `sealDigest` or `beaconValue` is
+ * malformed, or when `itemSha256s` is empty, contains a duplicate, or contains a malformed entry.
+ */
+export declare function computeBeaconOrder(params: BeaconOrderParams): BeaconOrderResult;
+/** Whether the beacon's postdating of the seal was proven here, or only asserted by its chain. */
+export type BeaconPostSealBasis = "proven-offline" | "attributive";
+/**
+ * Whether the seal fixed WHICH post-seal value applied, or the operator picked it (issue #3322).
+ *
+ * `seal-derived` -- the named round is `requiredBeaconRound` for this source and seal, so there was
+ * exactly one round to bind to and no choosing happened. `operator-chosen` -- the round postdates
+ * the seal (that is still checked) but was selected afterwards from among those published since, so
+ * the derivation is one of several the operator could have realized. Every `attributive-height`
+ * source is `operator-chosen` by construction: a block height carries no schedule, so no round
+ * follows from the seal.
+ *
+ * This is derived and reported, never enforced here. A verifier states what the bytes are; the
+ * choosing happens in the producer, which is where the refusal belongs (`bind` refuses a round other
+ * than the derivable one). Refusing here would also make every already-sealed record unreadable.
+ */
+export type BeaconRoundBasis = "seal-derived" | "operator-chosen";
+/** What every verified binding carries, whichever mode produced it. */
+export interface VerifiedRunBindingBase {
+    readonly procedure: typeof BEACON_BINDING_PROCEDURE;
+    readonly beacon: BeaconReference;
+    readonly sealDigest: string;
+    readonly sealedAt: string;
+    /** The recomputed identity-set digest of the pool (sampled) or population (census). */
+    readonly poolDigest: string;
+    readonly poolSize: number;
+    /** The recomputed full order. In census mode this is the execution order. */
+    readonly order: readonly string[];
+    readonly postSeal: BeaconPostSealBasis;
+    /** Whether the seal fixed which post-seal round applied, or the operator chose it. */
+    readonly roundBasis: BeaconRoundBasis;
+    /** The beacon's own publication instant, when its source's round index determines one. */
+    readonly beaconInstant?: string;
+}
+/**
+ * Discriminated on `mode` so `sample` is present exactly when there was a draw. A single optional
+ * `sample` would make every reader of the stronger binding write a fallback for a case that cannot
+ * happen, and the fallback is where a "0 items" sentence gets shipped.
+ */
+export type VerifiedRunBinding = (VerifiedRunBindingBase & {
+    readonly mode: "census";
+}) | (VerifiedRunBindingBase & {
+    readonly mode: "sampled";
+    readonly sample: readonly string[];
+});
+/**
+ * Verifies one binding record: the beacon postdates the seal, and the declared draw or order is
+ * exactly what `beacon-binding/1` derives. Throws `RunBindingError` on any disagreement -- the
+ * recomputation wins, always; a stored field never does.
+ */
+export declare function verifyRunBinding(candidate: unknown): VerifiedRunBinding;