@colophon-claims/verify 0.2.0 → 0.2.1

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/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;

package/dist/profile/claim-consistency.js

@@ -13,9 +13,9 @@ const PAIRED_ESTIMATE_LIMITATION = "This method estimates an effect; it does not
 const equal = (left, right) => left.length === right.length && left.every((byte, index) => byte === right[index]);
 /** 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. Mirrors
- * `benchmark-product/core`'s own copy (`src/verification/claim-consistency.ts`). */
-function firstDifference(actual, expected, path = "claim") {
+ * 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 function firstDifference(actual, expected, path = "claim") {
     // Never hand `undefined` to canonicalJsonBytes: it is deliberately not a JSON value, and a
     // field carried by one side alone is itself the first difference.
     if (actual === undefined || expected === undefined)
@@ -54,7 +54,7 @@ export function assertClaimConsistency(input) {
     // Presence, not emptiness: an empty section belongs to the anchored closure's declared-but-absent
     // bundle, and an omitted one to every unanchored bundle.
     const anchors = input.anchors;
-    const expected = buildClaimPackage({ draftId: input.draftId, benchmarkSha256: identities.benchmarkSha256, runRecord, runSha256: identities.runSha256, matrixRecord, matrixSha256: identities.matrixSha256, reportRecord, reportSha256: identities.reportSha256, reportEnvelopeSha256: identities.reportEnvelopeSha256, venueHonesty: buildLocalVenueHonesty(matrixRecord.cells, runRecord, anchors ?? []), verificationCommandVerb: "bundle verify", assurance: { preset: input.assurancePreset, resolved: { independence: runRecord.policy.independence, minVerdicts, distinctEvaluator, verdictRule } }, ...(input.rehearsal === undefined ? {} : { previewDisclosure: input.rehearsal }), ...(anchors === undefined ? {} : { anchors }) });
+    const expected = buildClaimPackage({ draftId: input.draftId, benchmarkSha256: identities.benchmarkSha256, runRecord, runSha256: identities.runSha256, matrixRecord, matrixSha256: identities.matrixSha256, reportRecord, reportSha256: identities.reportSha256, reportEnvelopeSha256: identities.reportEnvelopeSha256, venueHonesty: buildLocalVenueHonesty(matrixRecord.cells, runRecord, anchors ?? []), verificationCommandVerb: "bundle verify", assurance: { preset: input.assurancePreset, resolved: { independence: runRecord.policy.independence, minVerdicts, distinctEvaluator, verdictRule } }, ...(input.rehearsal === undefined ? {} : { previewDisclosure: input.rehearsal }), ...(anchors === undefined ? {} : { anchors }), ...(input.disclosure === undefined ? {} : { disclosure: input.disclosure }) });
     if (!equal(canonicalJsonBytes(claim), canonicalJsonBytes(expected)))
         refuse("record-integrity", "claim-consistency", `claim package ${firstDifference(claim, expected) ?? "claim"} is not the exact projection of verified facts`);
     const rehearsalLine = input.rehearsal === undefined ? undefined : previewDisclosureSummaryLine(input.rehearsal);

package/dist/profile/claim.d.ts

@@ -27,9 +27,15 @@
  * disclosure. The one deliberate exception to "never cross-check here": `buildClaimPackage`
  * THROWS when the stated primitives disagree with what the sealed Run record's own policy
  * carries — a claim stating primitives the sealed Run does not carry would be dishonest.
+ *
+ * Issue #3205: the claim id is chosen on TWO independent axes — anchored or not, and
+ * qualification-projecting or not — which is four allocations, not three. `claim-package/5` is
+ * the fourth cell; before it existed an anchored binary-instrument run could not produce a
+ * claim at all, which made anchoring and binary-instrument benchmarking mutually exclusive.
  */
 import { z } from "zod";
 import type { MatrixRecord, ReportRecord, RunRecord } from "@jinn-network/benchmarking-records";
+import type { ClaimDisclosureSection } from "./disclosure.js";
 import { SELF_RUN_TRUST_ROOT } from "./anchor-claims.js";
 import type { ClaimAnchor } from "./anchor-claims.js";
 type VenueHonesty = unknown;
@@ -42,16 +48,40 @@ export declare const BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-p
  * own later allocation.
  */
 export declare const ANCHORED_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/4";
+/**
+ * The anchored binary-qualification claim package (issue #3205): claim-package/2's exact
+ * qualification projection plus claim-package/4's `anchors` section, carried by
+ * `benchmark-product-public-bundle/7`. This is the "later allocation" both earlier guards named:
+ * /2 has no anchors slot and /4 has no qualification slot, so before this number existed an
+ * anchored run of a binary-instrument benchmark could not produce a claim at all. The allocation is
+ * an ADDITION — /1, /2, /3, and /4 keep their meanings and their bytes.
+ */
+export declare const ANCHORED_BINARY_QUALIFICATION_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/5";
+/**
+ * The disclosed anchored binary-qualification claim package (issue #2839,
+ * disclosure-specification-record design §6.5/§6.6): claim-package/5 exactly, plus the
+ * `disclosure` section, carried by `benchmark-product-public-bundle/8`.
+ *
+ * The design reserved `/5` for its own disclosure allocation on the UNANCHORED qualified branch, on
+ * the premise (its §12.2) that anchoring and qualification could never combine. Issue #3205 both
+ * took `/5` and dissolved that premise, so per the design's own §6.5 rule — the implementation
+ * packet takes the then-next free numbers if a line has advanced — this is `/6`, and it stacks on
+ * the ANCHORED branch so the real flagship bundle can carry its disclosure record without giving up
+ * its anchor. The allocation is an ADDITION: /1, /2, /3, /4, and /5 keep their meanings and bytes.
+ */
+export declare const DISCLOSED_CLAIM_PACKAGE_SCHEMA_ID = "benchmark-product.claim-package/6";
 export declare const BINARY_QUALIFICATION_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
 export declare const BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1 <bundle-dir>";
 /** Prompted-screening v2 claims require the verifier release that carries that admission surface. */
-export declare const PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.2.0 <bundle-dir>";
+export declare const PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.2.1 <bundle-dir>";
+/** Previously materialized prompted bundles remain valid under their immutable 0.2.0 claim. */
+export declare const LEGACY_PROMPTED_BINARY_QUALIFICATION_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.2.0 <bundle-dir>";
 export declare const PROMPTED_BINARY_QUALIFICATION_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.2 <bundle-dir>";
 /** The fixed sentence every claim package's assurance block carries (BP-21, spec §6/§7.1): what
  * distinct evaluator identities on this venue actually prove. Never softened per-claim. */
 export declare const ASSURANCE_DISCLOSURE: string;
 export declare const ClaimPackageSchema: z.ZodPreprocess<z.ZodObject<{
-    claimSchema: z.ZodUnion<readonly [z.ZodLiteral<"benchmark-product.claim-package/1">, z.ZodLiteral<"benchmark-product.claim-package/2">, z.ZodLiteral<"benchmark-product.claim-package/4">]>;
+    claimSchema: z.ZodUnion<readonly [z.ZodLiteral<"benchmark-product.claim-package/1">, z.ZodLiteral<"benchmark-product.claim-package/2">, z.ZodLiteral<"benchmark-product.claim-package/4">, z.ZodLiteral<"benchmark-product.claim-package/5">, z.ZodLiteral<"benchmark-product.claim-package/6">]>;
     scope: z.ZodObject<{
         draftId: z.ZodString;
         benchmarkSha256: z.ZodString;
@@ -272,6 +302,169 @@ export declare const ClaimPackageSchema: z.ZodPreprocess<z.ZodObject<{
             pending: z.ZodLiteral<true>;
         }, z.core.$strict>]>]>;
     }, z.core.$strict>>>;
+    disclosure: z.ZodOptional<z.ZodObject<{
+        recordSha256: z.ZodString;
+        specification: z.ZodLiteral<"https://spec.jinn.network/disclosure/six-variable/v1">;
+        subjectSha256: z.ZodString;
+        variables: z.ZodObject<{
+            "ingestion-model": z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"measured-here">;
+                statement: z.ZodString;
+                evidence: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        "pinned-configuration": "pinned-configuration";
+                        "execution-observation": "execution-observation";
+                    }>;
+                    digest: z.ZodObject<{
+                        sha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"disclosed-by-publisher">;
+                statement: z.ZodString;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"undisclosed">;
+                reason: z.ZodEnum<{
+                    "not-stated": "not-stated";
+                    "stated-without-identifiers": "stated-without-identifiers";
+                    "outside-this-experiment": "outside-this-experiment";
+                }>;
+            }, z.core.$strict>], "status">;
+            "retrieval-config": z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"measured-here">;
+                statement: z.ZodString;
+                evidence: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        "pinned-configuration": "pinned-configuration";
+                        "execution-observation": "execution-observation";
+                    }>;
+                    digest: z.ZodObject<{
+                        sha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"disclosed-by-publisher">;
+                statement: z.ZodString;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"undisclosed">;
+                reason: z.ZodEnum<{
+                    "not-stated": "not-stated";
+                    "stated-without-identifiers": "stated-without-identifiers";
+                    "outside-this-experiment": "outside-this-experiment";
+                }>;
+            }, z.core.$strict>], "status">;
+            "answer-model": z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"measured-here">;
+                statement: z.ZodString;
+                evidence: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        "pinned-configuration": "pinned-configuration";
+                        "execution-observation": "execution-observation";
+                    }>;
+                    digest: z.ZodObject<{
+                        sha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"disclosed-by-publisher">;
+                statement: z.ZodString;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"undisclosed">;
+                reason: z.ZodEnum<{
+                    "not-stated": "not-stated";
+                    "stated-without-identifiers": "stated-without-identifiers";
+                    "outside-this-experiment": "outside-this-experiment";
+                }>;
+            }, z.core.$strict>], "status">;
+            "answer-prompt": z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"measured-here">;
+                statement: z.ZodString;
+                evidence: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        "pinned-configuration": "pinned-configuration";
+                        "execution-observation": "execution-observation";
+                    }>;
+                    digest: z.ZodObject<{
+                        sha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"disclosed-by-publisher">;
+                statement: z.ZodString;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"undisclosed">;
+                reason: z.ZodEnum<{
+                    "not-stated": "not-stated";
+                    "stated-without-identifiers": "stated-without-identifiers";
+                    "outside-this-experiment": "outside-this-experiment";
+                }>;
+            }, z.core.$strict>], "status">;
+            "judge-model": z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"measured-here">;
+                statement: z.ZodString;
+                evidence: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        "pinned-configuration": "pinned-configuration";
+                        "execution-observation": "execution-observation";
+                    }>;
+                    digest: z.ZodObject<{
+                        sha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"disclosed-by-publisher">;
+                statement: z.ZodString;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"undisclosed">;
+                reason: z.ZodEnum<{
+                    "not-stated": "not-stated";
+                    "stated-without-identifiers": "stated-without-identifiers";
+                    "outside-this-experiment": "outside-this-experiment";
+                }>;
+            }, z.core.$strict>], "status">;
+            "judge-prompt": z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"measured-here">;
+                statement: z.ZodString;
+                evidence: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        "pinned-configuration": "pinned-configuration";
+                        "execution-observation": "execution-observation";
+                    }>;
+                    digest: z.ZodObject<{
+                        sha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"disclosed-by-publisher">;
+                statement: z.ZodString;
+                sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"undisclosed">;
+                reason: z.ZodEnum<{
+                    "not-stated": "not-stated";
+                    "stated-without-identifiers": "stated-without-identifiers";
+                    "outside-this-experiment": "outside-this-experiment";
+                }>;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$strip>>;
 export type ClaimPackage = z.infer<typeof ClaimPackageSchema>;
 export interface BuildClaimPackageInput {
@@ -313,10 +506,16 @@ export interface BuildClaimPackageInput {
      * here: this builder is pure, and the derivation needs the record bytes the caller already
      * authenticated. */
     readonly anchors?: readonly ClaimAnchor[];
+    /** disclosure-specification-record design §6.6: the projected disclosure section, already derived
+     * from the sealed record's exact bytes by the shared `deriveDisclosureSpecification`. Absent for
+     * every run with no declaration, which is what keeps every existing claim byte-identical. */
+    readonly disclosure?: ClaimDisclosureSection;
 }
 export declare const CLAIM_VERIFICATION_CHECKS: readonly string[];
 /** The anchored closure's list: the six frozen checks plus `integrity-anchors` (§8). */
 export declare const ANCHORED_CLAIM_VERIFICATION_CHECKS: readonly string[];
+/** The disclosed closure's list: the anchored seven plus `disclosure-specification` (design §7). */
+export declare const DISCLOSED_CLAIM_VERIFICATION_CHECKS: readonly string[];
 export declare const PUBLIC_BUNDLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
 /** The unconditional trust-root sentence, re-exported unchanged. It is DEFINED once beside its
  * anchored replacement in `anchor-claims.ts`: one sentence written out twice, in two mirrored