@sanning/proof 0.19.1 → 0.20.0

package/dist/environment.d.ts

@@ -1,42 +1,21 @@
 import { type EvidenceBundleResult } from "./evidence.js";
 /** `"dev"` when every envelope is signed `dev`, `"mixed"` when only some are. */
 export type EnvironmentMarker = "dev" | "mixed";
-/** The headline `verify` prints for sandbox evidence in place of `VERIFIED`. */
-export declare const SANDBOX_HEADLINE = "SANDBOX";
-/** The title `case` prints for sandbox evidence in place of `Verified` (case titles are title case). */
-export declare const SANDBOX_TITLE = "Sandbox";
-/** The one line printed with it, and with any other headline, wherever the marker is present. */
-export declare const SANDBOX_LINE = "Sandbox evidence (environment dev): not production evidence";
 /**
- * The signed envelopes a pack holds: every checkpoint and event envelope of an
- * anchor-trace body, every event envelope of a stamp-evidence body, the same
- * inside an export's inline source bundle, and an agent proof's checkpoint
- * envelope. A stamp-trace body holds none. A value that is not an object is
- * not an envelope and is not counted.
+ * The signed envelopes a pack holds: checkpoint and event envelopes of an
+ * anchor-trace body, event envelopes of a stamp-evidence body (also inside an
+ * export's inline source bundle). Non-objects are not counted.
  */
 export declare function packEnvelopes(bundle: unknown): Record<string, unknown>[];
 /**
- * The environment marker over one or more packs: `"dev"` where every envelope
- * they hold is signed `environment: "dev"`, `"mixed"` where some are and some
- * are not (`production`, or no `environment` at all), and `null` where none
- * is, which is every production pack and every pack that holds no envelope.
+ * The marker over one or more packs: `"dev"` where every envelope is signed
+ * `environment: "dev"`, `"mixed"` where only some are, `null` where none is
+ * (including a pack that holds no envelope).
  */
 export declare function environmentMarker(bundles: readonly unknown[]): EnvironmentMarker | null;
 /**
- * Whether a body's only unsettled witnesses are simulated: the body has events
- * and witnesses (checkpoints, stamps or both), every witness is named, at
- * least one is simulated, and every other one a gateway confirmed. Then the
- * one thing that keeps the bundle from `verified` is a simulated witness
- * nobody can look up: no mismatch, no unreachable gateway, no witness of
- * another kind, no checkpoint or stamp witnessed by nobody.
- */
-export declare function onlySimulatedUnsettled(result: EvidenceBundleResult): boolean;
-/**
- * Whether a run with gateways counted only simulated witnesses, so nothing
- * was looked up on a chain: gateways were passed, the run is not counted as
- * checked on a chain, and it holds a simulated witness. A run that stopped
- * before its witnesses were read (a bad wrapper signature or `body_hash`, an
- * unknown `body_type`, an export whose source is not inline) holds none, so it
- * is not one, and prints what it printed before simulated witnesses existed.
+ * Whether a run with gateways counted only simulated witnesses, so nothing was
+ * looked up on a chain. A run that stopped before reading its witnesses holds
+ * none and is not one.
  */
 export declare function simulatedOnlyRun(result: EvidenceBundleResult, gateways: readonly string[]): boolean;

package/dist/environment.js

@@ -1,27 +1,13 @@
-// The environment marker: is this sandbox evidence?
+// The environment marker: whether a pack holds sandbox evidence.
 //
-// `environment` is an OPTIONAL skeleton field inside every envelope's signed
-// scope, `"dev"` or `"production"` (envelope-spec §2, A1 and A9). The spec
-// says a verifier MAY surface the value as `environment_marker` in its result
-// and a profile MAY refuse to count dev-marked envelopes toward production
-// evidence. Both commands now do the first, and print a pack or case that
-// holds a `dev` envelope as sandbox evidence rather than as `VERIFIED`.
-//
-// The marker is read from the signed envelopes the pack holds, never from a
-// wrapper field, a pack name or anything else the holder could write without a
-// key. It never moves the verdict word: a sandbox pack that verifies is still
-// `verified`, and the commands map that to the headline `SANDBOX` and exit 5
-// (`sandboxExit` in `./exit-codes.ts`). The Python twin is
-// `src/sanning_proof/environment.py`.
-import { isAgentProofSpec } from "./agent-proof.js";
+// `environment` is an optional field inside every envelope's signed scope,
+// `"dev"` or `"production"` (envelope-spec section 2). It is read from the signed
+// envelopes a pack holds, never from a wrapper field, a pack name or anything
+// else the holder could write without a key. It is a label, never a claim or a
+// verdict: a sandbox pack that verifies is still `verified`, prints the sandbox
+// line, and exits 3 (`exitCodeFor`).
 import { ANCHOR_TRACE_BODY_TYPE, EXPORT_BODY_TYPE, SIMULATED_WITNESS_KIND, STAMP_EVIDENCE_BODY_TYPE, } from "./evidence.js";
-/** The headline `verify` prints for sandbox evidence in place of `VERIFIED`. */
-export const SANDBOX_HEADLINE = "SANDBOX";
-/** The title `case` prints for sandbox evidence in place of `Verified` (case titles are title case). */
-export const SANDBOX_TITLE = "Sandbox";
-/** The one line printed with it, and with any other headline, wherever the marker is present. */
-export const SANDBOX_LINE = "Sandbox evidence (environment dev): not production evidence";
-// The same bound `resolveTraceEvents` puts on unwrapping export wrappers.
+// Same bound as `resolveTraceEvents` puts on unwrapping export wrappers.
 const MAX_EXPORT_UNWRAP = 4;
 function isObject(v) {
     return v !== null && typeof v === "object" && !Array.isArray(v);
@@ -41,20 +27,12 @@ function entryEnvelopes(list, out) {
     }
 }
 /**
- * The signed envelopes a pack holds: every checkpoint and event envelope of an
- * anchor-trace body, every event envelope of a stamp-evidence body, the same
- * inside an export's inline source bundle, and an agent proof's checkpoint
- * envelope. A stamp-trace body holds none. A value that is not an object is
- * not an envelope and is not counted.
+ * The signed envelopes a pack holds: checkpoint and event envelopes of an
+ * anchor-trace body, event envelopes of a stamp-evidence body (also inside an
+ * export's inline source bundle). Non-objects are not counted.
  */
 export function packEnvelopes(bundle) {
     const out = [];
-    if (isObject(bundle) && isAgentProofSpec(own(bundle, "spec_version"))) {
-        const env = own(bundle, "checkpoint_envelope");
-        if (isObject(env))
-            out.push(env);
-        return out;
-    }
     let cur = bundle;
     for (let depth = 0; depth < MAX_EXPORT_UNWRAP; depth++) {
         if (!isObject(cur))
@@ -79,10 +57,9 @@ export function packEnvelopes(bundle) {
     return out;
 }
 /**
- * The environment marker over one or more packs: `"dev"` where every envelope
- * they hold is signed `environment: "dev"`, `"mixed"` where some are and some
- * are not (`production`, or no `environment` at all), and `null` where none
- * is, which is every production pack and every pack that holds no envelope.
+ * The marker over one or more packs: `"dev"` where every envelope is signed
+ * `environment: "dev"`, `"mixed"` where only some are, `null` where none is
+ * (including a pack that holds no envelope).
  */
 export function environmentMarker(bundles) {
     let total = 0;
@@ -99,35 +76,9 @@ export function environmentMarker(bundles) {
     return dev === total ? "dev" : "mixed";
 }
 /**
- * Whether a body's only unsettled witnesses are simulated: the body has events
- * and witnesses (checkpoints, stamps or both), every witness is named, at
- * least one is simulated, and every other one a gateway confirmed. Then the
- * one thing that keeps the bundle from `verified` is a simulated witness
- * nobody can look up: no mismatch, no unreachable gateway, no witness of
- * another kind, no checkpoint or stamp witnessed by nobody.
- */
-export function onlySimulatedUnsettled(result) {
-    const witnesses = [...result.checkpoints, ...(result.stamps ?? [])];
-    if (witnesses.length === 0 || result.events.length === 0)
-        return false;
-    let simulated = 0;
-    for (const w of witnesses) {
-        if (w.anchorRef === null)
-            return false;
-        if (w.anchorRef.kind === SIMULATED_WITNESS_KIND)
-            simulated++;
-        else if (w.onChain?.rollup !== "confirm")
-            return false;
-    }
-    return simulated > 0;
-}
-/**
- * Whether a run with gateways counted only simulated witnesses, so nothing
- * was looked up on a chain: gateways were passed, the run is not counted as
- * checked on a chain, and it holds a simulated witness. A run that stopped
- * before its witnesses were read (a bad wrapper signature or `body_hash`, an
- * unknown `body_type`, an export whose source is not inline) holds none, so it
- * is not one, and prints what it printed before simulated witnesses existed.
+ * Whether a run with gateways counted only simulated witnesses, so nothing was
+ * looked up on a chain. A run that stopped before reading its witnesses holds
+ * none and is not one.
  */
 export function simulatedOnlyRun(result, gateways) {
     if (gateways.length === 0 || result.onChainChecked)

package/dist/evidence.d.ts

@@ -1,40 +1,26 @@
-import type { Envelope } from "./types.js";
-/** The accepted `sanning.evidence/v1` wrapper majors; exported in both kernels (P-01, 0.13.0). */
+import { type AgentRecordReading } from "./agent-record.js";
+import type { Envelope, EnvelopeFault } from "./types.js";
+/** The accepted evidence-bundle wrapper majors. */
 export declare const ACCEPTED_EVIDENCE_MAJORS: readonly string[];
 export declare const ANCHOR_TRACE_BODY_TYPE = "sanning.anchor.trace/v3";
 /**
- * The name `event_bytes` replaced. Under the new majors a body entry that still
- * carries it is a hard reject, never an ignored unknown field: ignored, it
- * would read as a withheld record and the event would verify with nothing
- * checked, the fail-open the new majors exist to prevent (governance.md §8,
- * W-3).
+ * The field name `event_bytes` replaced. A body entry still carrying it is a
+ * hard reject: ignored, it would read as a withheld record and verify with
+ * nothing checked.
  */
 export declare const LEGACY_EVENT_BYTES_FIELD = "record_bytes";
 export declare const EXPORT_BODY_TYPE = "sanning.evidence.export/v2";
 /**
- * The Sanning-signed interval stamp body (evidence-bundle.md §5.2, DL-58).
- *
- * Its own `body_type` rather than a widened anchor-trace body, and the reason
- * is the whole decision: an anchor-trace checkpoint carries a PRODUCER-signed
- * `sanning.events/v2` envelope, and a stamp has no producer signature at all:
- * Sanning places it, under DL-52, for a customer who holds no chain identity.
- * The two rejected options were making `envelope` optional and synthesising an
- * envelope that Sanning signs; the second would have made a Sanning
- * attestation indistinguishable ON THE WIRE from a producer's, which is
- * unrecoverable once witnessed.
+ * The Sanning-signed interval stamp body (evidence-bundle.md §5.2). Its own
+ * body type, because a stamp has no producer signature: a Sanning attestation
+ * must never be indistinguishable on the wire from a producer's.
  */
 export declare const STAMP_TRACE_BODY_TYPE = "sanning.stamp.trace/v1";
 export declare const STAMP_EVIDENCE_BODY_TYPE = "sanning.stamp.evidence/v2";
 /**
- * The version string INSIDE a witnessed stamp body — a different string from
- * the `body_type` above, and the two are easy to confuse.
- *
- * `sanning.stamp.trace/v1` discriminates the BUNDLE BODY: it is the reader's
- * dispatch key. `sanning.stamp/v1` is the control plane's own version of the
- * bytes it hands a witness (`control-plane/src/stamp-tree.ts`,
- * `STAMP_BODY_VERSION`). A `sanning.stamp.trace/v1` body pins the inner
- * version to exactly this value: two answers to one question inside one
- * signature is the §5.1.2 mixed-vocabulary reject, one layer down.
+ * The version string inside a witnessed stamp body, distinct from the
+ * `body_type` above (the dispatch key). A stamp trace body pins it to exactly
+ * this value (§5.1.2).
  */
 export declare const STAMP_BODY_VERSION = "sanning.stamp/v1";
 export interface EvidenceIssuer {
@@ -43,23 +29,9 @@ export interface EvidenceIssuer {
     agent_id?: string;
     [k: string]: unknown;
 }
-export interface EvidenceVerdict {
-    status: string;
-    summary?: string;
-    counts?: Record<string, number>;
-    as_of?: string;
-    [k: string]: unknown;
-}
 /**
- * Where a commitment was witnessed (evidence-bundle.md §5.1.1).
- *
- * The same three-part shape the control plane indexes (`kind` / one promoted
- * `id` / a typed remainder), so the signed body, the index row and the SDK
- * artifact stop being three vocabularies for one fact.
- *
- * NOT ONE FIELD HERE NAMES A CHAIN. Arweave's chunk proof, data_path, offsets
- * and packing live in `ref`, opaque to every reader above this seam. A field
- * that would need renaming for a second witness belongs in `ref` by definition.
+ * Where a commitment was witnessed (evidence-bundle.md §5.1.1). No field here
+ * names a chain: chain-specific detail lives in the opaque `ref`.
  */
 export interface AnchorRef {
     kind: string;
@@ -68,15 +40,13 @@ export interface AnchorRef {
 }
 export interface TraceCheckpoint {
     /**
-     * The checkpoint's identity and the join key, DERIVED: hex SHA-256 of the
-     * decoded `event_bytes`. Recomputed by the verifier, never taken from the
-     * label.
+     * Hex SHA-256 of the decoded `event_bytes`: the checkpoint's identity and join
+     * key. Recomputed by the verifier, never trusted.
      */
     checkpoint_ref: string;
     /**
-     * Where it was witnessed, IF IT HAS BEEN. Optional, and absent is honest:
-     * under DL-52 a checkpoint is routinely placed before it is witnessed, and a
-     * required field that must be filled dishonestly is a defect in the format.
+     * Where it was witnessed, if it has been. Absent is honest: checkpoints are
+     * placed before they are witnessed.
      */
     anchor_ref?: AnchorRef;
     envelope: Envelope;
@@ -102,13 +72,9 @@ export interface AnchorTraceBody {
     events: TraceEvent[];
 }
 /**
- * One sub-tree of a stamp, as the WITNESSED bytes carry it.
- *
- * Keyed in the body by a blinded reference (an HMAC under a per-org secret we
- * never publish), so a reader learns that the org runs N agents and their
- * relative volumes and learns no name. The RANGE is deliberately in the clear:
- * it is what makes a later per-agent slice claim checkable by a third party
- * without Sanning, and hiding it would put us back in the trust path.
+ * One sub-tree of a stamp, as the witnessed bytes carry it. Keyed by a blinded
+ * reference, so a reader learns no agent name. The range is in the clear so a
+ * per-agent slice claim is checkable without Sanning.
  */
 export interface StampSubtree {
     first_leaf: number;
@@ -117,15 +83,12 @@ export interface StampSubtree {
     root: string;
 }
 /**
- * The stamp body as the control plane witnesses it
- * (`control-plane/src/stamp-tree.ts`, `StampBody`).
- *
- * Never read from the bundle directly — it is parsed out of `stamp_bytes`,
- * which is the only authority. Present as a type so the parse has a shape.
+ * The stamp body as the control plane witnesses it. Only ever parsed out of
+ * `stamp_bytes`, the sole authority.
  */
 export interface StampBody {
     stamp_version: string;
-    /** The org, BLINDED. Not an org id, and not reversible without the secret. */
+    /** The org, blinded. Not reversible without the secret. */
     org_ref: string;
     interval_start: string;
     interval_end: string;
@@ -135,18 +98,13 @@ export interface StampBody {
 }
 /** One entry of a `sanning.stamp.trace/v1` body's `stamps[]` (§5.2). */
 export interface StampEntry {
-    /**
-     * The stamp's identity within this bundle, DERIVED: hex SHA-256 of the
-     * DECODED `stamp_bytes`, not of the hex text. A verifier MUST recompute it.
-     */
+    /** Hex SHA-256 of the decoded `stamp_bytes`, not the hex text. Recomputed by the verifier. */
     stamp_ref: string;
     /** Lowercase hex of the exact JCS bytes that were handed to the witness. */
     stamp_bytes: string;
     /**
-     * Where the stamp was witnessed, IF IT HAS BEEN (§5.1.1). Absent is honest:
-     * a sealed-but-unconfirmed stamp is witnessed by nobody, and an emitter that
-     * filled this in from a submission receipt would be claiming a chain
-     * position that does not exist yet.
+     * Where the stamp was witnessed, if it has been (§5.1.1). Absent is honest: a
+     * submission receipt is not a chain position.
      */
     anchor_ref?: AnchorRef;
 }
@@ -159,7 +117,7 @@ export interface StampEvidenceInclusion {
     leaf_index: number;
     leaf_count: number;
     audit_path: string[];
-    /** Resolves against `stamps[].stamp_ref` in the SAME body. */
+    /** Resolves against `stamps[].stamp_ref` in the same body. */
     stamp_ref: string;
 }
 export interface StampEvidenceEvent {
@@ -169,7 +127,7 @@ export interface StampEvidenceEvent {
     inclusion: StampEvidenceInclusion;
 }
 export interface StampEvidenceBody {
-    /** Byte-identical to §5.2.2 — one definition, one place to change. */
+    /** Byte-identical to §5.2.2. */
     stamps: StampEntry[];
     events: StampEvidenceEvent[];
 }
@@ -179,7 +137,6 @@ export interface EvidenceBundle {
     issuer: EvidenceIssuer;
     generated_at: string;
     gateway?: string | null;
-    verdict: EvidenceVerdict;
     body?: unknown;
     body_ref?: string;
     body_hash: string;
@@ -189,7 +146,7 @@ export interface EvidenceBundle {
     signature: string;
     [k: string]: unknown;
 }
-export type EvidenceStatus = "verified" | "partial" | "failed" | "malformed";
+export type EvidenceStatus = "verified" | "failed" | "incomplete";
 export type OnChainOutcome = "confirm" | "mismatch" | "unreachable";
 export interface PerGatewayOutcome {
     gateway: string;
@@ -203,11 +160,7 @@ export interface OnChainResult {
 export interface CheckpointResult {
     /** The derived `checkpoint_ref`, empty when it could not be derived. */
     checkpointRef: string;
-    /**
-     * Where this checkpoint was witnessed. `null` when the checkpoint carries no
-     * `anchor_ref`: placed but not yet witnessed, which is a normal state and NOT
-     * a deficiency.
-     */
+    /** Where it was witnessed; `null` when placed but not yet witnessed, which is normal. */
     anchorRef: AnchorRef | null;
     envelopeOk: boolean;
     merkleRootOk: boolean;
@@ -215,6 +168,7 @@ export interface CheckpointResult {
     onChain: OnChainResult | null;
     ok: boolean;
     errors: string[];
+    anchorRefMalformed?: boolean;
 }
 export interface EventResult {
     eventId: string;
@@ -225,10 +179,45 @@ export interface EventResult {
     contentOk: boolean | null;
     ok: boolean;
     errors: string[];
+    /**
+     * The `sanning.agent` reading of this record (agent-events.md section 10), read with
+     * every other record of the pile it was verified in: the bundle, or every pack
+     * of a case. `null` where the record is not an agent record, or its envelope
+     * did not verify, or its record bytes did not travel or did not bind. It never
+     * moves `ok` or the bundle status; the pack grade reads it (section 5.4.5).
+     */
+    agent: AgentRecordReading | null;
+    /**
+     * True where the record's `stamp_ref` or `checkpoint_ref` names a stamp or checkpoint the
+     * pack does not hold: `witnessed` is not proven (`missing`), never disproven, whatever else
+     * about the record fails.
+     */
+    stampAbsent?: boolean;
+    /**
+     * True where the record carries a retired field name, or bytes that are present and cannot
+     * be read: a defect in the artifact that fails the record under a key that can be read.
+     */
+    ownFormFailed?: boolean;
+    /**
+     * True where the record's signed bytes bind to its `payload_hash` under a signature that
+     * holds and are not JSON: the producer broke the format it signed, so `follows_rules` is
+     * disproven and nothing was proven altered.
+     */
+    recordNotJson?: boolean;
+    /**
+     * True where the bytes this record's content was checked against came from the side
+     * input, which nobody signed: a mismatch then leaves `unchanged` not proven
+     * (`not_checked`), never disproven.
+     */
+    contentUnsigned?: boolean;
+    /** Why the record's envelope does not verify: the worst of `envelopeFaults`, or `null`. */
+    envelopeFault?: EnvelopeFault | null;
+    /** Every envelope fault found (`ENVELOPE_FAULTS`), worst first. */
+    envelopeFaults?: EnvelopeFault[];
 }
 /** One sub-tree's recomputed result (§5.2). */
 export interface StampSubtreeResult {
-    /** The blinded key the body spells it under. Meaningless without the org's secret. */
+    /** The blinded key the body uses. */
     ref: string;
     firstLeaf: number;
     leafCount: number;
@@ -236,17 +225,13 @@ export interface StampSubtreeResult {
 }
 /** One `stamps[]` entry's result (§5.2). */
 export interface StampResult {
-    /** The stamp's derived identity, as the bundle spells it. "" when unusable. */
+    /** The stamp's derived identity. "" when unusable. */
     stampRef: string;
     /** The asserted `stamp_ref` equals SHA-256 of the decoded `stamp_bytes`. */
     stampRefOk: boolean;
     /**
-     * The witnessed bytes decoded, parsed, and re-canonicalized to themselves.
-     *
-     * The last clause is not pedantry. The plane stores these bytes as TEXT and
-     * replays them verbatim precisely because a round-trip through a normalizing
-     * serializer is not guaranteed to reproduce what was signed; a body that is
-     * not JCS-canonical is one that every re-deriving reader hashes differently.
+     * The witnessed bytes decode, parse and re-canonicalize to themselves. A body
+     * that is not JCS-canonical hashes differently for every re-deriving reader.
      */
     bodyOk: boolean;
     stampVersion: string | null;
@@ -255,55 +240,34 @@ export interface StampResult {
     merkleRoot: string | null;
     leafCount: number | null;
     /**
-     * Every sub-tree range accounts for exactly one leaf of the stamp: the
-     * ranges sorted by `first_leaf` tile `[0, leaf_count)` with no gap and no
-     * overlap, and their counts sum to `leaf_count`.
+     * The sub-tree ranges, sorted by `first_leaf`, tile `[0, leaf_count)` with no
+     * gap or overlap.
      */
     subtreesOk: boolean;
     subtrees: StampSubtreeResult[];
     /**
-     * Where it was witnessed, or `null` for a stamp nothing has witnessed yet.
-     *
-     * `null` is NOT a failure and never an accusation — it is the honest state
-     * of every stamp for the first minutes of its life and the permanent state
-     * of every stamp when no witness is configured. It does hold the bundle at
-     * `partial`: a stamp is Sanning's own assertion until something independent
-     * carries it.
+     * Where it was witnessed, or `null` if nothing has witnessed it yet. Never an
+     * accusation, but it holds the bundle at `partial`: until witnessed, a stamp
+     * is Sanning's own assertion.
      */
     anchorRef: AnchorRef | null;
     /**
-     * Per-gateway on-chain outcomes for this stamp's `anchor_ref` (§4.2's shape,
-     * `checkpoints[]`'s vocabulary), or `null` when NOTHING WAS CHECKED.
-     *
-     * ── The four states, and why none of them collapses ──
-     *
-     * `null` means not checked — no gateways were supplied, or this stamp names
-     * no witness to check, or its `anchor_ref.kind` has no witness adapter, or
-     * its id is not one the adapter accepts; the witness was not checked. It is
-     * a statement about the RUN, never about the stamp. The other three are
-     * statements about the stamp and live in `onChain.rollup`: `confirm` (a
-     * gateway returned the witnessed bytes), `mismatch` (a gateway returned
-     * DIFFERENT bytes: a finding, and the only one of the four that fails
-     * anything), `unreachable` (we asked and nobody answered: an availability
-     * gap, never an accusation).
-     *
-     * Keeping "not checked" distinct from "unreachable" is the whole point. A
-     * surface handed a collapsed boolean cannot tell "no gateway could be
-     * reached" from "no gateway was tried", and reported the first when the
-     * second was true — a false accusation manufactured by a missing state.
+     * Per-gateway outcomes for this stamp's `anchor_ref`, or `null` when nothing
+     * was checked (a statement about the run, not the stamp). Of `confirm`,
+     * `mismatch` and `unreachable`, only `mismatch` fails anything. "Not checked"
+     * and "unreachable" stay distinct so a surface never reports an availability
+     * gap that was never tested.
      */
     onChain: OnChainResult | null;
     /**
-     * Derived collapse of `onChain`, mirroring `CheckpointResult.onChainOk` so a
-     * consumer reads one field the same way on both: `false` on mismatch, `true`
-     * on confirm, `null` on unreachable AND on not-checked.
-     *
-     * It is deliberately the LOSSY view — `null` is three-quarters of the state
-     * space here. Anything that needs to tell those apart reads `onChain`.
+     * Lossy collapse of `onChain`, as on `CheckpointResult`: `false` mismatch,
+     * `true` confirm, `null` unreachable or not checked.
      */
     onChainOk: boolean | null;
     ok: boolean;
     errors: string[];
+    /** True where the only thing wrong is a malformed `anchor_ref` (as on a checkpoint). */
+    anchorRefMalformed?: boolean;
 }
 export interface EvidenceBundleResult {
     status: EvidenceStatus;
@@ -314,10 +278,13 @@ export interface EvidenceBundleResult {
     onChainChecked: boolean;
     checkpoints: CheckpointResult[];
     events: EventResult[];
-    assertedStatus: string | null;
     export?: ExportResult;
     stamps?: StampResult[];
     errors: string[];
+    unreadable?: boolean;
+    generatedAtMalformed?: boolean;
+    keyUnreadable?: boolean;
+    versionUnknown?: boolean;
     notes?: string[];
 }
 export interface AttestationRecord {
@@ -414,6 +381,7 @@ export interface AttestationResult {
     subjectRefOk: boolean | null;
     ok: boolean;
     errors: string[];
+    fieldError?: string | null;
 }
 export interface ExportResult {
     sourceLinkageOk: boolean;
@@ -422,6 +390,7 @@ export interface ExportResult {
     attestations: AttestationResult[];
     verdict: VerdictObject;
     status: EvidenceStatus;
+    sourceUnreadable?: boolean;
 }
 export interface VerifyEvidenceOptions {
     gateways?: string[];
@@ -429,40 +398,35 @@ export interface VerifyEvidenceOptions {
     fetchImpl?: typeof fetch;
 }
 /**
- * A surface MUST NOT present a wrapper's `co_signatures` as evidence
- * (evidence-bundle.md §2, decided by Phil 2026-09-24 on proof#148): nothing
- * in either kernel verifies the field, and it sits outside the wrapper's
- * signed scope (`bundleForSig` below), so anyone holding a pack's bytes can
- * append it with no key at all. This is the one sentence both kernels attach
- * as a note, never a verdict, never an exit code.
+ * A wrapper's `co_signatures` is not evidence (evidence-bundle.md §2): nothing
+ * verifies it, and it sits outside the signed scope, so anyone can append it.
+ * Attached as a note, never a verdict or exit code.
  */
 export declare const CO_SIGNATURES_NOTE = "unverified co-signatures are present in this pack's wrapper and are not part of the evidence";
 /**
- * True iff the wrapper's reserved `co_signatures` field carries at least one
- * entry.
- *
- * Absence and an empty array read the same way here: the field asserts
- * nothing about a second signer until it holds one, and evidence-bundle.md's
- * own carve-out language for the analogous envelope field treats "absent"
- * and "an empty array" as one thing (envelope-spec.md §7.1). A non-array
- * value (malformed shape, but the field is reserved, not yet specified)
- * still counts as present: it is not the well-formed absence either rule
- * describes.
+ * Whether the wrapper's reserved `co_signatures` carries at least one entry.
+ * Absent and empty read the same (envelope-spec.md §7.1); a non-array value
+ * counts as present.
  */
 export declare function coSignaturesPresent(b: unknown): boolean;
+/** evidence-bundle.md §2. Byte-identical to the Python kernel's. */
+export declare const GENERATED_AT_MALFORMED = "malformed generated_at: not an RFC 3339 UTC date-time with Z naming a real date and time (evidence-bundle section 2)";
 /**
- * A bundle this kernel cannot read.
- *
- * `wrapperOk` is true only where the wrapper signature and `body_hash` were
- * CHECKED and held before the body was found unreadable. It is then reported
- * as held, because it did: `signatureOk` and `bodyHashOk` are statements about
- * the wrapper, and a body this kernel cannot parse does not unsign it. The
- * case reader decides whose pack a bundle is on exactly those two fields
- * (`evidence-bundle.md` 5.5.1), so reporting `false` here let a holder who
- * broke its own body shape read as a forger.
+ * Name an envelope `public_key` or `signature` spelled outside the hex charset
+ * or at the wrong length, in the same words as Python, so both kernels give one
+ * reading. Only a string is checked; a missing one is the envelope layer's to
+ * fail.
+ */
+/**
+ * The envelope faults that leave a claim not proven rather than disproven: the record's
+ * envelope or key cannot be read, or its version is one this verifier does not know.
+ */
+export declare const UNPROVEN_ENVELOPE_FAULTS: readonly EnvelopeFault[];
+/**
+ * Verify a `sanning.evidence/v1` bundle, dispatching on its `body_type`. The
+ * returned `status` is recomputed from the body; a wrapper `verdict` member,
+ * where a producer still writes one, is never read (evidence-bundle.md section 4).
  */
-/** evidence-bundle §2 (A31). Byte-identical to the Python kernel's. */
-export declare const GENERATED_AT_MALFORMED = "malformed generated_at: not an RFC 3339 UTC date-time with Z naming a real date and time (evidence-bundle \u00A72)";
 export declare function verifyEvidenceBundle(bundle: unknown, options?: VerifyEvidenceOptions): Promise<EvidenceBundleResult>;
 /**
  * The `anchor_ref.kind` a sandbox plane writes for a witness it simulated
@@ -485,18 +449,13 @@ export interface DisclosedContentResult {
     errors: string[];
 }
 /**
- * Materialize the disclosed raw bytes of a received bundle (evidence-bundle §5.1).
- *
- * Verify-then-return: the bundle is verified with {@link verifyEvidenceBundle}
- * (same options — gateways, out-of-band `content`, `fetchImpl`), and an event's
- * bytes are returned ONLY when that verification bound them to the committed
- * `content_hash`. There is no path through this function that yields bytes
- * whose SHA-256 is not the commitment.
+ * Materialize the disclosed raw bytes of a received bundle (evidence-bundle.md
+ * §5.1). The bundle is verified with {@link verifyEvidenceBundle}, and an
+ * event's bytes are returned only when that verification bound them to the
+ * committed `content_hash`.
  *
- * Returns `Uint8Array`, never a string: the spec commits to raw bytes, and a
- * UTF-8 decode is lossy for any payload that is not valid UTF-8 — re-encoding
- * such a string would produce different bytes and a different hash. Callers who
- * know their payload is text decode it themselves and own that assumption.
+ * Returns `Uint8Array`, never a string: a UTF-8 decode is lossy and would
+ * change the hash.
  */
 export declare function disclosedContent(bundle: unknown, options?: VerifyEvidenceOptions): Promise<DisclosedContentResult>;
 export declare function resolveTraceEvents(bundle: unknown): TraceEvent[] | undefined;