@sanning/proof 0.19.1 → 0.20.0

package/dist/index.d.ts

@@ -1,19 +1,22 @@
-export { ACCEPTED_SPEC_MAJORS, contentHashes, jcs, specVersionSupported, verifyEnvelope, } from "./verifier.js";
+export { ACCEPTED_SPEC_MAJORS, contentHashes, jcs, specVersionSupported, verifyEnvelope, envelopeFault, envelopeFaults, } from "./verifier.js";
+export { ENVELOPE_FAULTS } from "./types.js";
+export type { EnvelopeFault } from "./types.js";
 export { jcsParse } from "./verifier.js";
-export { exceedsTextDepth, hasNonFiniteNumber, jcsParseWithinLimits, MAX_READ_DEPTH } from "./verifier.js";
 export { bytesToHex, deriveOperatorAddress, ed25519Refusal, ed25519Verify, hexToBytes, sha256Bytes, sha256Hex, utf8, verifyRsaPssSha256, } from "./crypto.js";
 export { EMPTY_TREE_ROOT_HEX, auditPath, leafHash, merkleRoot, nodeHash, verifyInclusion, } from "./merkle.js";
 export type { ContentRole, Envelope, Subject, VerificationResult, VerifyOptions } from "./types.js";
 export { ACCEPTED_EVIDENCE_MAJORS, ANCHOR_TRACE_BODY_TYPE, CO_SIGNATURES_NOTE, EXPORT_BODY_TYPE, STAMP_BODY_VERSION, STAMP_TRACE_BODY_TYPE, STAMP_EVIDENCE_BODY_TYPE, coSignaturesPresent, disclosedContent, recomputeExportVerdict, verifyEvidenceBundle, } from "./evidence.js";
-export type { AnchorTraceBody, AttestationPayload, AttestationRecord, AttestationResult, CheckpointResult, ComposeVerdictResult, DisclosedContentResult, DisclosedEventContent, DisclosureStatus, EvidenceBundle, EvidenceBundleResult, EvidenceIssuer, EvidenceStatus, EvidenceVerdict, EventResult, ExportBody, ExportResult, OnChainOutcome, OnChainResult, PerGatewayOutcome, AnchorRef, StampBody, StampEntry, StampResult, StampSubtree, StampSubtreeResult, StampTraceBody, StampEvidenceBody, StampEvidenceEvent, StampEvidenceInclusion, TraceCheckpoint, TraceEvent, TraceInclusion, VerdictAttestation, VerdictCheckpoint, VerdictEvent, VerdictObject, VerdictOnChain, VerdictOnChainGateway, VerifyEvidenceOptions, } from "./evidence.js";
+export type { AnchorTraceBody, AttestationPayload, AttestationRecord, AttestationResult, CheckpointResult, ComposeVerdictResult, DisclosedContentResult, DisclosedEventContent, DisclosureStatus, EvidenceBundle, EvidenceBundleResult, EvidenceIssuer, EvidenceStatus, EventResult, ExportBody, ExportResult, OnChainOutcome, OnChainResult, PerGatewayOutcome, AnchorRef, StampBody, StampEntry, StampResult, StampSubtree, StampSubtreeResult, StampTraceBody, StampEvidenceBody, StampEvidenceEvent, StampEvidenceInclusion, TraceCheckpoint, TraceEvent, TraceInclusion, VerdictAttestation, VerdictCheckpoint, VerdictEvent, VerdictObject, VerdictOnChain, VerdictOnChainGateway, VerifyEvidenceOptions, } from "./evidence.js";
 export { PACK_GRADE_CAUSE_KINDS, PACK_VERDICTS, accountDisclosure, completenessNotes, gradeCauses, gradePack, renderCause, signedLeafCount, } from "./grading.js";
 export type { CompletenessNote, DisclosureAccount, GradeInput, PackGrade, PackGradeCause, PackGradeCauseKind, PackVerdict, } from "./grading.js";
 export { DECLARATION_CONTENT_KINDS, DECLARATION_DEVIATION_KINDS, DECLARATION_NOTE_KINDS, DECLARATION_ROLES, DECLARATION_VERDICTS, DECLARATION_VERSION, DECLARATION_VERSION_V2, DECLARATION_VERSION_V3, DECLARATION_VERSIONS, checkDeclaration, declarationClaims, packRecords, renderContentFinding, renderDeclarationSummary, renderDeviation, renderNote, } from "./declaration.js";
 export type { DeclarationCheck, DeclarationClaims, DeclarationContentFinding, DeclarationContentKind, DeclarationDeviation, DeclarationDeviationKind, DeclarationNote, DeclarationNoteKind, DeclarationRole, DeclarationVerdict, PackRecord, } from "./declaration.js";
-export { CASE_BODY_TYPES, CASE_EXCEPTION_KINDS, CASE_QUARANTINED_PROFILES, CASE_RECORD_PROFILES, CASE_RECORD_STATUSES, CASE_NOTE_KINDS, CASE_RELIANCE, CASE_RELIANCE_HANDOFF_CLAUSE, CASE_RELIANCE_SANDBOX, CASE_VERDICTS, CONTENT_WITHHELD_BY_DECLARATION, CO_SIGNATURES_PRESENT, VERDICT_DISPLAY_TITLES, WITNESS_NOT_LOOKED_UP, WITNESS_STATES, WITNESS_TIME_CACHED, WITNESS_TIME_RECORDED, caseReliance, readCase, renderCaseNote, renderCaseSummary, renderException, renderWitnessLine, } from "./case.js";
+export { CASE_BODY_TYPES, CASE_EXCEPTION_KINDS, CASE_QUARANTINED_PROFILES, CASE_RECORD_PROFILES, CASE_RECORD_STATUSES, CASE_NOTE_KINDS, CASE_RELIANCE, CASE_RELIANCE_HANDOFF_CLAUSE, CASE_RELIANCE_SANDBOX, CASE_VERDICTS, CONTENT_WITHHELD_BY_DECLARATION, CO_SIGNATURES_PRESENT, VERDICT_DISPLAY_TITLES, WITNESS_NOT_LOOKED_UP, WITNESS_STATES, WITNESS_TIME_CACHED, WITNESS_TIME_RECORDED, caseProblems, caseReliance, readCase, renderCaseNote, renderCaseSummary, renderException, renderWitnessLine, } from "./case.js";
 export { MAX_BLOCK_TIME, MAX_WITNESS_CACHE_DEPTH, WITNESS_CACHE_NAME, WITNESS_CACHE_VERSION, checkWitnessCache, formatBlockTime, readWitnessCache, renderWitnessTime, witnessTimeQuery, } from "./witness-cache.js";
 export type { CachedWitnessTime, WitnessTimeAnswer, WitnessTimeCheck } from "./witness-cache.js";
-export { lookupPublicRecord, onChainHalf, witnessLine } from "./witness-lookup.js";
+export { lookupPublicRecord, onChainHalf, onChainOutcome, onChainRow, witnessLine, } from "./witness-lookup.js";
+export { CLAIMS, CLAIM_LABELS, CLAIM_QUESTIONS, CLAIM_STATES, ENVELOPE_FAULT_KINDS, KIND_CLAIMS, NOTE_FINDINGS, NOTE_ORDER, NOT_IN_SCOPE_REASONS, NOT_PROVEN_REASONS, PERSON_TITLES, PERSON_TITLE_PARTS, REASON_KINDS, RECORD_REASON_CLAIMS, RECORD_REASON_LINES, SANDBOX_PERSON_LINE, VERDICTS, VERDICT_COLOURS, VERDICT_TITLES, bundleProblems, claimsOf, downgraded, note, orderedNotes, restOnSigned, personText, problem, problemToJson, renderFindingNote, renderPerson, verdictOf, withItems, } from "./claims.js";
+export type { Claim, ClaimEntry, ClaimItem, ClaimState, Labels, LinePart, NoteEntry, NotInScopeReason, NotProvenReason, Person, Problem, ProblemItem, ProblemJson, ProblemValues, ReasonKind, Verdict, VerdictJson, } from "./claims.js";
 export type { OnChainHalf, OnChainRow, PublicRecordPack, PublicRecordResult, PublicRecordState, WitnessLookupOptions, WitnessTimeRow, } from "./witness-lookup.js";
 export type { CaseException, CaseExceptionKind, CaseNote, CaseNoteKind, CasePack, CasePackReading, CaseReading, CaseRecordReading, CaseRecordStatus, CaseVerdict, WitnessLine, WitnessState, } from "./case.js";
 export { CASE_FILE_FINDING_KINDS, CASE_FILE_INDEX_NAME, CASE_FILE_VERSION, HOW_TO_VERIFY_NAME, REPORT_README_FIRST_LINE, howToVerifyText, isPackRef, readCaseFileIndex, renderCaseFileFinding, } from "./case-file.js";
@@ -22,14 +25,15 @@ export { FILE_MATCH_SCOPE, NOT_READ_REASONS, SKIPPED_REASONS, fileMatchToJson, m
 export type { FileCommitment, FileMatchPack, FileMatchReading, MatchedFile, NotRead, NotReadReason, OfferedFile, SkippedFile, SkippedReason, UnmatchedFile, } from "./file-match.js";
 export { ADAPTER_CHAIN_NAMESPACES, CHAIN_READING_SCOPE, readChainLinks, readChains, renderChainFinding, } from "./chain.js";
 export type { ChainFinding, ChainFindingKind, ChainLink, ChainReading, ChainSource, ChainSummary, } from "./chain.js";
-export { EXIT_CODES, EXIT_CODES_HELP, EXIT_FAILED, EXIT_MALFORMED, EXIT_MIXED, EXIT_SANDBOX, EXIT_UNDETERMINED, EXIT_VERIFIED, exitCodeFor, sandboxExit, } from "./exit-codes.js";
-export { SANDBOX_HEADLINE, SANDBOX_LINE, SANDBOX_TITLE, environmentMarker, onlySimulatedUnsettled, packEnvelopes, } from "./environment.js";
+export { EXIT_CODES, EXIT_CODES_HELP, EXIT_COULD_NOT_RUN, EXIT_FAILED, EXIT_INCOMPLETE, EXIT_SANDBOX, EXIT_VERIFIED, exitCodeFor, } from "./exit-codes.js";
+export { environmentMarker, packEnvelopes, } from "./environment.js";
 export type { EnvironmentMarker } from "./environment.js";
 export { attestationSignatureToHex, composeExport } from "./compose.js";
 export type { ComposeExportOptions, ComposeExportResult, ExporterKey } from "./compose.js";
-export { AGENT_PROOF_SPEC_VERSION, isAgentProofSpec, verifyAgentProof } from "./agent-proof.js";
-export type { AgentProofBundle, AgentProofResult, VerifyAgentProofOptions, } from "./agent-proof.js";
-export { CANDIDATE_NAMESPACE, DEFINED_EVENT_TYPES, NOT_A_HANDOFF_FINDING, isConformantHandoffRecord, readHandoff, readHandoffs, recordIsMalformed, } from "./handoff.js";
+export { CANDIDATE_NAMESPACE, DEFINED_EVENT_TYPES, NOT_A_HANDOFF_FINDING, isConformantHandoffRecord, readHandoff, readHandoffs, recordDefect, recordIsMalformed, recordIsNonconforming, } from "./handoff.js";
 export type { CandidateReading, HandoffReading, HandoffRecord, HandoffVerdict, HeldRecord, } from "./handoff.js";
 export { BYTES_FOR_UNKNOWN_PART, CONFLICTING_PART_BYTES, INLINE_BYTES_KEYS, MESSAGE_RESULT_ORDER, PARTS_NOT_AN_ARRAY, PART_ENCODING_MISMATCH, PART_INLINE_BYTES, PART_INLINE_MISMATCHED, PART_MALFORMED_DESCRIPTOR, PART_MATCHED, PART_MISMATCHED, PART_NOT_A_FILE, PART_SUPPLIED_TWICE, PART_UNCHECKED, REFUSAL_ORDER, commitHeldMessage, isFilePart, uncheckedHeldParts, } from "./message-parts.js";
 export type { HeldMessage, Note, PartReading, Refusal, SuppliedPart } from "./message-parts.js";
+export { AGENT_EVENT_TYPES, RECORD_TYPES_OUTSIDE_AGENT, readAgentRecord, readAgentRecordWithHeld, readAgentRecords, renderAgentReading, } from "./agent-record.js";
+export type { AgentHeldRecord, AgentReason, AgentRecordReading, AgentVerdict } from "./agent-record.js";
+export { AGENT_SCHEMA_PIN, AGENT_SCHEMA_VERSIONS } from "./agent-schemas.generated.js";

package/dist/index.js

@@ -1,179 +1,72 @@
-// @sanning/proof — TypeScript kernel of the Sanning verification stack.
-//
-// The verification primitives for the Verifiable Event Envelope family
-// (specs/envelope-spec.md), sanning.agent/v1 profile: RFC 8785 (JCS)
-// canonicalization, SHA-256, Ed25519 envelope verification, and the
-// content-hash extraction used for reverse provenance lookup. Sibling of the
-// Python `sanning-proof` kernel and the Go `pkg/proof` reference; conformance
-// is byte-for-byte against the shared `test-vectors/` corpus.
-//
-// Scope boundary (envelope-spec §10 #13): this package verifies a SINGLE
-// envelope. Chain walking (previous_hash), checkpoint reconciliation, and
-// gateway/transport concerns are consumer-layer logic composed above it.
-// ACCEPTED_SPEC_MAJORS is exported for parity with the sibling kernels'
-// registries (Python ACCEPTED_SPEC_MAJORS, Go SupportedSpecMajor): a consumer
-// can see which profiles this build admits without inferring it from probe
-// calls. It is frozen at its definition (`Object.freeze`, typed
-// `readonly string[]`) because the verifier reads that same array — an exported
-// mutable accept-set would be a runtime-widenable kernel. Additive — no
-// existing export changes.
-export { ACCEPTED_SPEC_MAJORS, contentHashes, jcs, specVersionSupported, verifyEnvelope, } from "./verifier.js";
-// The strict reader of bytes that claim to be JCS, the twin of Python's public
-// `canonicalize.jcs_loads`. The enclave attestation adapters read a token's
-// JSON through it, so they refuse what the kernel refuses. Additive.
+// @sanning/proof: the TypeScript verification kernel for the Verifiable Event
+// Envelope family (specs/envelope-spec.md): RFC 8785 (JCS), SHA-256, Ed25519
+// envelope verification, and the bundle, pack and case readings built on them.
+// Conformance is byte-for-byte against the shared `test-vectors/` corpus.
+// The accept-set this build admits. Frozen at its definition, because the
+// verifier reads the same array.
+export { ACCEPTED_SPEC_MAJORS, contentHashes, jcs, specVersionSupported, verifyEnvelope, envelopeFault, envelopeFaults, } from "./verifier.js";
+export { ENVELOPE_FAULTS } from "./types.js";
+// The strict reader of bytes that claim to be JCS (Python's `jcs_loads`).
 export { jcsParse } from "./verifier.js";
-// The same reader within the enclave readers' limits (enclave-attestation
-// section 2.1): depth checked on the bytes first, every number finite. The
-// adapters read a token's header and claims and the manifest through it.
-// Additive.
-export { exceedsTextDepth, hasNonFiniteNumber, jcsParseWithinLimits, MAX_READ_DEPTH } from "./verifier.js";
 export { bytesToHex, deriveOperatorAddress, ed25519Refusal, ed25519Verify, hexToBytes, sha256Bytes, sha256Hex, utf8, verifyRsaPssSha256, } from "./crypto.js";
 export { EMPTY_TREE_ROOT_HEX, auditPath, leafHash, merkleRoot, nodeHash, verifyInclusion, } from "./merkle.js";
-// Evidence-bundle verification (specs/evidence-bundle.md): the signed
-// sanning.evidence/v1 wrapper carrying the sanning.anchor.trace/v3 body. The CLI
-// (`npx @sanning/proof verify`) is built on this. The same path dispatches on the
-// issuer-composed sanning.evidence.export/v2 body (specs/evidence-export.md) to
-// verifyExportBody (embedded RSA-PSS operator attestations + a recomputed §4
-// verdict object with per-gateway on-chain outcomes).
-//
-// `disclosedContent` is the INGEST half of the same path (evidence-bundle
-// §5.1). A received bundle carries its disclosed raw bytes as lowercase hex, so
-// materializing them was, until now, every consumer re-implementing the
-// encoding convention — and a consumer that copied the field VERBATIM wrote
-// files that failed verification on genuine evidence. This hands back DECODED
-// bytes, and only for events whose verification bound them to the committed
-// content_hash. Additive; verifyEvidenceBundle's behavior is unchanged.
+// Evidence-bundle verification (specs/evidence-bundle.md), including the
+// sanning.evidence.export/v2 body (specs/evidence-export.md).
+// `disclosedContent` returns decoded disclosed bytes, only for events whose
+// verification bound them to the committed content_hash.
 export { ACCEPTED_EVIDENCE_MAJORS, ANCHOR_TRACE_BODY_TYPE, CO_SIGNATURES_NOTE, EXPORT_BODY_TYPE, STAMP_BODY_VERSION, STAMP_TRACE_BODY_TYPE, STAMP_EVIDENCE_BODY_TYPE, coSignaturesPresent, disclosedContent, recomputeExportVerdict, verifyEvidenceBundle, } from "./evidence.js";
-// Pack grading (src/grading.ts): what a verification SURFACE may claim about a
-// pack — the signed bundle PLUS whatever disclosed bytes travelled beside it.
-//
-// The rule is already normative in evidence-bundle.md §5.1 (absent disclosure is
-// undetermined, not failed) and §6 (no status ever means "safe"); what the
-// surfaces added on top was a sharper word for undetermined and an account of
-// what the pack failed to disclose. It lived twice, in two repos and two
-// languages, and the two derivations had already diverged once. It lives here.
-//
-// Pure — data in, data out, no I/O, so the kernel's scope boundary
-// (specs/architecture.md §3) is unchanged. `vectors/pack-grading.json` is the
-// conformance statement of the rule and ships in the published tarball, so a
-// consumer that cannot yet import `gradePack` can vendor the table, hold its own
-// derivation to it, and diff its copy against ours. Additive — no existing
-// export changes.
+// Pack grading: what a verification surface may claim about a pack and the
+// disclosed bytes beside it (evidence-bundle.md §5.1, §6). Pure.
+// `vectors/pack-grading.json` states the rule for consumers to test against.
 export { PACK_GRADE_CAUSE_KINDS, PACK_VERDICTS, accountDisclosure, completenessNotes, gradeCauses, gradePack, renderCause, signedLeafCount, } from "./grading.js";
-// The declaration (src/declaration.ts): what a pack SAYS it holds, checked
-// against what it does (evidence-bundle.md §5.4).
-//
-// Every other check in this kernel checks a record that is PRESENT, so a pack
-// with half its records dropped verifies perfectly and an auditor cannot tell
-// a full hand-over from a trimmed one. The declaration is the pack's own
-// statement of what it was meant to contain, inside `body` and therefore under
-// the bundle's signature. Any deviation FAILS and every deviation is NAMED; a
-// pack that carries no declaration is `partial`, never `verified`; and a
-// reading that rests on the UNSIGNED content handed in beside the pack is
-// named on its own and carries the weaker word, because whoever assembles a
-// case chose those bytes (proof#147).
-//
-// Pure: data in, data out, no I/O. `gradePack` takes the result as an
-// optional fourth argument, so a surface gets one verdict; omitting it is the
-// pre-§5.4 behavior, unchanged. Additive: no existing export changes.
+// The declaration: what a pack says it holds, checked against what it does
+// (evidence-bundle.md §5.4). Pure. `gradePack` takes the result as an optional
+// fourth argument.
 export { DECLARATION_CONTENT_KINDS, DECLARATION_DEVIATION_KINDS, DECLARATION_NOTE_KINDS, DECLARATION_ROLES, DECLARATION_VERDICTS, DECLARATION_VERSION, DECLARATION_VERSION_V2, DECLARATION_VERSION_V3, DECLARATION_VERSIONS, checkDeclaration, declarationClaims, packRecords, renderContentFinding, renderDeclarationSummary, renderDeviation, renderNote, } from "./declaration.js";
-// The case (src/case.ts): one verdict over SEVERAL packs, across organizations
-// (anchor#198). The layer above the declaration, and the closure for what a
-// declaration cannot reach.
-//
-// A pack a party assembles about itself is not self-proving about what that
-// party LEFT OUT (envelope-spec.md §4.1 A15, evidence-bundle.md §5.4.2 rule 7),
-// because the omission happens before any reader runs. Reading several parties'
-// packs at once is what closes it: a `handoff.sent` with no counterpart is
-// always named, and where a pack signed by the key it names is in the case, the
-// reading says that pack holds no counterpart (unless every candidate was
-// accounted for under A20, which reads as no counterpart and names no pack). Whether a party that presented
-// no such pack recorded anything is not established (proof#143). `readCase`
-// verifies every pack itself, offline, so it is async. Matching is on keys and hashes alone and NEVER on tenancy, so a pair from two
-// organizations verifies (DL-60).
-//
-// Pure: data in, data out, no I/O. Additive: a new module, no existing export
-// changes, and no new verdict word anywhere.
-export { CASE_BODY_TYPES, CASE_EXCEPTION_KINDS, CASE_QUARANTINED_PROFILES, CASE_RECORD_PROFILES, CASE_RECORD_STATUSES, CASE_NOTE_KINDS, CASE_RELIANCE, CASE_RELIANCE_HANDOFF_CLAUSE, CASE_RELIANCE_SANDBOX, CASE_VERDICTS, CONTENT_WITHHELD_BY_DECLARATION, CO_SIGNATURES_PRESENT, VERDICT_DISPLAY_TITLES, WITNESS_NOT_LOOKED_UP, WITNESS_STATES, WITNESS_TIME_CACHED, WITNESS_TIME_RECORDED, caseReliance, readCase, renderCaseNote, renderCaseSummary, renderException, renderWitnessLine, } from "./case.js";
-// The witnessed-time cache (evidence-bundle 5.6.6, v1.25, A30): read it, look it
-// up, print it. Never an input to a verdict.
+// The case: one verdict over several parties' packs, closing what a single
+// pack cannot prove about its own omissions (evidence-bundle.md §5.5).
+// Matching is on keys and hashes alone, never tenancy, so a pair across two
+// organizations verifies. `readCase` verifies every pack itself, offline.
+export { CASE_BODY_TYPES, CASE_EXCEPTION_KINDS, CASE_QUARANTINED_PROFILES, CASE_RECORD_PROFILES, CASE_RECORD_STATUSES, CASE_NOTE_KINDS, CASE_RELIANCE, CASE_RELIANCE_HANDOFF_CLAUSE, CASE_RELIANCE_SANDBOX, CASE_VERDICTS, CONTENT_WITHHELD_BY_DECLARATION, CO_SIGNATURES_PRESENT, VERDICT_DISPLAY_TITLES, WITNESS_NOT_LOOKED_UP, WITNESS_STATES, WITNESS_TIME_CACHED, WITNESS_TIME_RECORDED, caseProblems, caseReliance, readCase, renderCaseNote, renderCaseSummary, renderException, renderWitnessLine, } from "./case.js";
+// The witnessed-time cache (evidence-bundle.md §5.6.6). Never an input to a
+// verdict.
 export { MAX_BLOCK_TIME, MAX_WITNESS_CACHE_DEPTH, WITNESS_CACHE_NAME, WITNESS_CACHE_VERSION, checkWitnessCache, formatBlockTime, readWitnessCache, renderWitnessTime, witnessTimeQuery, } from "./witness-cache.js";
-// The public-record (witness) lookup the CLI runs with `--gateways`
-// (src/witness-lookup.ts, proof#200): moved out of the CLI so a consumer
-// that is not the CLI, the verify page, calls the SAME implementation
-// rather than keeping its own copy (verify-page#70). Pure kernel scope: the
-// one network call lives in `lookupPublicRecord` and `onChainHalf`, runs
-// only when a caller hands in a gateway, and goes through `options.fetchImpl`
-// where a caller supplies one (a browser page's own `fetch`) or the ambient
-// global `fetch` otherwise, so this export runs in a browser exactly as it
-// runs in Node. `onChainHalf` and `witnessLine` are the CLI's own unchanged
-// building blocks; `lookupPublicRecord` is the new one-call, four-state entry
-// point a page wants, additive over both. `confirmed` from
-// `lookupPublicRecord` is a claim about the BYTES only, never about whether
-// the pack itself verifies, and a caller must never show it apart from the
-// pack's own verdict.
-export { lookupPublicRecord, onChainHalf, witnessLine } from "./witness-lookup.js";
-// The case file's index (src/case-file.ts, evidence-bundle.md §5.6, A25):
-// compared with the drop it describes, with NO verdict contribution. The index
-// is never an input to `readCase`. Pure: bytes and a file list in.
+// The public-record lookup behind `--gateways`. The only network call runs when
+// a caller hands in a gateway, through `options.fetchImpl` or the global
+// `fetch`, so it runs in a browser. `confirmed` is a claim about the bytes
+// only: never show it apart from the pack's own verdict.
+export { lookupPublicRecord, onChainHalf, onChainOutcome, onChainRow, witnessLine, } from "./witness-lookup.js";
+// Six claims, three verdicts, and the person layer (evidence-bundle.md section 3): every
+// detailed kind maps to one claim and one state, and the verdict is read off the claims.
+export { CLAIMS, CLAIM_LABELS, CLAIM_QUESTIONS, CLAIM_STATES, ENVELOPE_FAULT_KINDS, KIND_CLAIMS, NOTE_FINDINGS, NOTE_ORDER, NOT_IN_SCOPE_REASONS, NOT_PROVEN_REASONS, PERSON_TITLES, PERSON_TITLE_PARTS, REASON_KINDS, RECORD_REASON_CLAIMS, RECORD_REASON_LINES, SANDBOX_PERSON_LINE, VERDICTS, VERDICT_COLOURS, VERDICT_TITLES, bundleProblems, claimsOf, downgraded, note, orderedNotes, restOnSigned, personText, problem, problemToJson, renderFindingNote, renderPerson, verdictOf, withItems, } from "./claims.js";
+// The case file's index (evidence-bundle.md §5.6), compared with the drop it
+// describes. Never an input to `readCase` or any verdict.
 export { CASE_FILE_FINDING_KINDS, CASE_FILE_INDEX_NAME, CASE_FILE_VERSION, HOW_TO_VERIFY_NAME, REPORT_README_FIRST_LINE, howToVerifyText, isPackRef, readCaseFileIndex, renderCaseFileFinding, } from "./case-file.js";
-// Files handed in beside a pack (src/file-match.ts, evidence-bundle.md §5.7,
-// A29, proof#92): each file's SHA-256 matched against the commitments the
-// pack's SIGNED records make, by hash alone. Never moves a verdict.
+// Files handed in beside a pack (evidence-bundle.md §5.7), matched by SHA-256
+// against the pack's signed commitments. Never moves a verdict.
 export { FILE_MATCH_SCOPE, NOT_READ_REASONS, SKIPPED_REASONS, fileMatchToJson, matchCaseFiles, matchFiles, notAccountedFor, renderFileMatch, } from "./file-match.js";
-// Chain reading (src/chain.ts): following the pointer every sanning.events/v2
-// record carries to the record before it, over the records ONE bundle presents.
-//
-// Every anchored event has carried that pointer since the profile was ratified
-// and nothing we shipped read it, so a bundle with an event removed — and a
-// chain that restarted after a crash and now asserts two beginnings — passed
-// every check we had (proof#43). The verifier was right not to do this: it
-// verifies a single envelope and says so. Nothing above it did it either.
-//
-// Pure — data in, data out, no I/O — so the kernel's scope boundary
-// (specs/architecture.md §3) is unchanged, and the rule ships as
-// `vectors/chain-reading.json` beside the pack-grading table for the same
-// reason: a rule consumers must agree with needs a statement they can fetch.
-//
-// It returns FINDINGS, never a verdict, and it feeds no status on its own: a
-// pack's signed v3 declaration can claim a chain complete and in order, and
-// `checkDeclaration` holds that claim to the links `readChainLinks` reads
-// (evidence-bundle.md 5.4.2 rule 11). Chain links are
-// deletion/reorder-evidence for the events present and NOT a completeness proof
-// (`anchor/docs/profile-sanning.events-v2.md` §5), drop the last N events of a
-// chain and nothing dangles. `CHAIN_READING_SCOPE` is that sentence, exported so
-// every surface prints the same limit rather than paraphrasing it into a claim.
-// Additive — no existing export changes.
+// Chain reading: findings over the `previous_hash` links one bundle presents,
+// never a verdict and never a completeness proof. `CHAIN_READING_SCOPE` is the
+// sentence every surface prints beside them. `vectors/chain-reading.json`
+// states the rule; a v3 declaration's chain claim is checked against
+// `readChainLinks` (evidence-bundle.md §5.4.2 rule 11).
 export { ADAPTER_CHAIN_NAMESPACES, CHAIN_READING_SCOPE, readChainLinks, readChains, renderChainFinding, } from "./chain.js";
-// The `proof export` composer (specs/evidence-export.md §5, phase 2): produce a
-// signed, offline-verifiable sanning.evidence.export/v2 artifact from a source
-// anchor-trace bundle + operator attestations + an exporter Ed25519 key. The
-// inverse of verifyEvidenceBundle's verifyExportBody dispatch.
-// One exit-code table for every verb (0.13.0): the verdict word to the exit
-// code, and the help text every verb prints. Additive.
-export { EXIT_CODES, EXIT_CODES_HELP, EXIT_FAILED, EXIT_MALFORMED, EXIT_MIXED, EXIT_SANDBOX, EXIT_UNDETERMINED, EXIT_VERIFIED, exitCodeFor, sandboxExit, } from "./exit-codes.js";
-// Sandbox evidence: the environment marker over the envelopes a pack or case
-// holds (envelope-spec §2, the `environment_marker` MAY), and the headline and
-// line both commands print for it. Additive.
-export { SANDBOX_HEADLINE, SANDBOX_LINE, SANDBOX_TITLE, environmentMarker, onlySimulatedUnsettled, packEnvelopes, } from "./environment.js";
+// The `proof export` composer (specs/evidence-export.md §5): a signed,
+// offline-verifiable sanning.evidence.export/v2 artifact. Also the one
+// exit-code table and help text every verb uses.
+export { EXIT_CODES, EXIT_CODES_HELP, EXIT_COULD_NOT_RUN, EXIT_FAILED, EXIT_INCOMPLETE, EXIT_SANDBOX, EXIT_VERIFIED, exitCodeFor, } from "./exit-codes.js";
+// Sandbox evidence: the environment marker over a pack's or case's envelopes
+// (envelope-spec section 2).
+export { environmentMarker, packEnvelopes, } from "./environment.js";
 export { attestationSignatureToHex, composeExport } from "./compose.js";
-// Agent inclusion-proof bundle verification: the
-// sanning.agent.proof/v1 bundle. The CLI sniffs spec_version and routes here so
-// one verifier covers both agent and anchor bundles.
-export { AGENT_PROOF_SPEC_VERSION, isAgentProofSpec, verifyAgentProof } from "./agent-proof.js";
-// The hand-off pairing rule (src/handoff.ts): which records are candidates to
-// be the counterpart of a hand-off record, how a candidate set of more than one
-// is ordered, and what a formed pair grades to (specs/envelope-spec.md §4.1
-// v1.9, proof#132 and proof#136). The Python half is src/sanning_proof/handoff.py and the two
-// answer identically on identical bytes. Additive: a new module, and no
-// existing export changes.
-export { CANDIDATE_NAMESPACE, DEFINED_EVENT_TYPES, NOT_A_HANDOFF_FINDING, isConformantHandoffRecord, readHandoff, readHandoffs, recordIsMalformed, } from "./handoff.js";
-// A file part's BYTES (src/message-parts.ts): what a file part is, and what a
-// receiver that HOLDS a part's bytes commits to (envelope-spec.md section 4.1
-// v1.13, A18, proof#145). A receiver that holds the bytes hashes them and, on a
-// mismatch, commits to the message AS IT HELD IT, so the pair fails on
-// `message_hash` rather than verifying over bytes nobody checked. The Python
-// half is src/sanning_proof/message_parts.py and the two are held together by
-// cross-kernel/run_parts.sh. Pure: it neither canonicalizes nor hashes the
-// message.
+// The hand-off pairing rule (envelope-spec.md §4.1). The Python half answers
+// identically on identical bytes.
+export { CANDIDATE_NAMESPACE, DEFINED_EVENT_TYPES, NOT_A_HANDOFF_FINDING, isConformantHandoffRecord, readHandoff, readHandoffs, recordDefect, recordIsMalformed, recordIsNonconforming, } from "./handoff.js";
+// File parts (envelope-spec.md §4.1): a receiver holding a part's bytes
+// commits to the message as it held it, so a mismatch fails on `message_hash`
+// rather than verifying over unchecked bytes.
 export { BYTES_FOR_UNKNOWN_PART, CONFLICTING_PART_BYTES, INLINE_BYTES_KEYS, MESSAGE_RESULT_ORDER, PARTS_NOT_AN_ARRAY, PART_ENCODING_MISMATCH, PART_INLINE_BYTES, PART_INLINE_MISMATCHED, PART_MALFORMED_DESCRIPTOR, PART_MATCHED, PART_MISMATCHED, PART_NOT_A_FILE, PART_SUPPLIED_TWICE, PART_UNCHECKED, REFUSAL_ORDER, commitHeldMessage, isFilePart, uncheckedHeldParts, } from "./message-parts.js";
+// Reading a sanning.agent record (vendor/specs/agent-events.md §10) against
+// the schemas bundled from the pinned specs release: no file read, no fetch.
+export { AGENT_EVENT_TYPES, RECORD_TYPES_OUTSIDE_AGENT, readAgentRecord, readAgentRecordWithHeld, readAgentRecords, renderAgentReading, } from "./agent-record.js";
+export { AGENT_SCHEMA_PIN, AGENT_SCHEMA_VERSIONS } from "./agent-schemas.generated.js";

package/dist/json-schema.d.ts

@@ -0,0 +1,29 @@
+export type JsonSchema = boolean | {
+    readonly [keyword: string]: unknown;
+};
+export type SchemaReason = "unknown_field" | "missing_field" | "bad_value";
+export interface SchemaError {
+    readonly reason: SchemaReason;
+    readonly at: string;
+}
+/** Validate against schemas that reference each other by `$id`. */
+export declare class SchemaSet {
+    private readonly documents;
+    private readonly patterns;
+    constructor(documents: readonly JsonSchema[]);
+    /** Every error `value` has against the document whose `$id` is `id`; empty when it validates. */
+    validate(id: string, value: unknown): SchemaError[];
+    private check;
+    private passes;
+    private resolve;
+    private pattern;
+}
+/** JSON equality, without recursion so a deeply nested value cannot overflow the stack. */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+export declare function isObject(v: unknown): v is Record<string, unknown>;
+export declare function has(obj: object, key: string): boolean;
+/** One JSON Pointer reference token (RFC 6901). */
+export declare function escapeToken(t: string): string;
+export declare function unescapeToken(t: string): string;
+/** Freeze `value` and every object and array inside it. */
+export declare function deepFreeze<T>(value: T): T;

package/dist/json-schema.js

@@ -0,0 +1,298 @@
+// A JSON Schema (draft 2020-12) validator for the keywords the pinned
+// sanning.agent schemas use, and no others. It reads schemas handed to it as
+// data, resolves `$ref` among them by `$id`, and never fetches anything. A
+// keyword outside the supported set throws rather than being skipped: a later
+// pin that adds one must fail loudly, never validate less than it says.
+//
+// Errors are collected in all-errors mode and returned as the reasons of
+// agent-events.md §10 step 4 and §10.1: `unknown_field` (additionalProperties), `missing_field`
+// (required) and `bad_value` (anything else), each at a JSON Pointer.
+// Keywords that carry no assertion.
+const ANNOTATIONS = new Set(["$schema", "$id", "$defs", "title", "description"]);
+const ASSERTIONS = new Set([
+    "$ref",
+    "type",
+    "const",
+    "enum",
+    "not",
+    "anyOf",
+    "properties",
+    "additionalProperties",
+    "required",
+    "minProperties",
+    "items",
+    "minItems",
+    "maxItems",
+    "uniqueItems",
+    "pattern",
+    "minLength",
+    "maxLength",
+    "minimum",
+    "maximum",
+]);
+/** Validate against schemas that reference each other by `$id`. */
+export class SchemaSet {
+    documents = new Map();
+    patterns = new Map();
+    constructor(documents) {
+        for (const d of documents) {
+            if (typeof d !== "object" || typeof d.$id !== "string") {
+                throw new Error("json-schema: every document needs an $id");
+            }
+            supportedOnly(d);
+            this.documents.set(stripFragment(d.$id), d);
+        }
+    }
+    /** Every error `value` has against the document whose `$id` is `id`; empty when it validates. */
+    validate(id, value) {
+        const doc = this.documents.get(id);
+        if (doc === undefined)
+            throw new Error(`json-schema: no document ${id}`);
+        const errors = [];
+        this.check(doc, id, value, "", errors);
+        return errors;
+    }
+    check(schema, base, value, at, errors) {
+        if (schema === true)
+            return;
+        if (schema === false) {
+            errors.push({ reason: "bad_value", at });
+            return;
+        }
+        const s = schema;
+        const bad = () => {
+            errors.push({ reason: "bad_value", at });
+        };
+        if (s.$ref !== undefined) {
+            const [doc, target] = this.resolve(String(s.$ref), base);
+            this.check(target, doc, value, at, errors);
+        }
+        if (s.type !== undefined) {
+            const types = Array.isArray(s.type) ? s.type : [s.type];
+            if (!types.some((t) => hasType(value, t)))
+                bad();
+        }
+        if (has(s, "const") && !deepEqual(value, s.const))
+            bad();
+        if (s.enum !== undefined && !s.enum.some((e) => deepEqual(value, e)))
+            bad();
+        if (s.not !== undefined && this.passes(s.not, base, value))
+            bad();
+        if (s.anyOf !== undefined) {
+            const branchErrors = [];
+            let passed = false;
+            for (const branch of s.anyOf) {
+                const e = [];
+                this.check(branch, base, value, at, e);
+                if (e.length === 0) {
+                    passed = true;
+                    break;
+                }
+                branchErrors.push(...e);
+            }
+            if (!passed) {
+                errors.push(...branchErrors);
+                bad();
+            }
+        }
+        if (typeof value === "string") {
+            if (s.pattern !== undefined && !this.pattern(String(s.pattern)).test(value))
+                bad();
+            if (s.minLength !== undefined && codePoints(value) < s.minLength)
+                bad();
+            if (s.maxLength !== undefined && codePoints(value) > s.maxLength)
+                bad();
+        }
+        if (typeof value === "number") {
+            if (s.minimum !== undefined && value < s.minimum)
+                bad();
+            if (s.maximum !== undefined && value > s.maximum)
+                bad();
+        }
+        if (Array.isArray(value)) {
+            if (s.minItems !== undefined && value.length < s.minItems)
+                bad();
+            if (s.maxItems !== undefined && value.length > s.maxItems)
+                bad();
+            if (s.uniqueItems === true && !allUnique(value))
+                bad();
+            if (s.items !== undefined) {
+                value.forEach((item, i) => this.check(s.items, base, item, `${at}/${i}`, errors));
+            }
+        }
+        if (isObject(value)) {
+            const props = (s.properties ?? {});
+            if (s.required !== undefined) {
+                for (const name of s.required) {
+                    if (!has(value, name))
+                        errors.push({ reason: "missing_field", at: `${at}/${escapeToken(name)}` });
+                }
+            }
+            if (s.minProperties !== undefined && Object.keys(value).length < s.minProperties)
+                bad();
+            for (const key of Object.keys(value)) {
+                const child = `${at}/${escapeToken(key)}`;
+                if (has(props, key)) {
+                    this.check(props[key], base, value[key], child, errors);
+                }
+                else if (s.additionalProperties === false) {
+                    errors.push({ reason: "unknown_field", at: child });
+                }
+                else if (s.additionalProperties !== undefined) {
+                    this.check(s.additionalProperties, base, value[key], child, errors);
+                }
+            }
+        }
+    }
+    passes(schema, base, value) {
+        const e = [];
+        this.check(schema, base, value, "", e);
+        return e.length === 0;
+    }
+    resolve(ref, base) {
+        const url = new URL(ref, base);
+        const doc = stripFragment(url.href);
+        let target = this.documents.get(doc);
+        if (target === undefined)
+            throw new Error(`json-schema: no document for $ref ${ref}`);
+        const fragment = decodeURIComponent(url.hash.slice(1));
+        if (fragment !== "") {
+            if (!fragment.startsWith("/"))
+                throw new Error(`json-schema: unsupported $ref ${ref}`);
+            for (const token of fragment.slice(1).split("/")) {
+                const t = unescapeToken(token);
+                if (!isObject(target) || !has(target, t))
+                    throw new Error(`json-schema: unresolved $ref ${ref}`);
+                target = target[t];
+            }
+        }
+        return [doc, target];
+    }
+    pattern(source) {
+        let re = this.patterns.get(source);
+        if (re === undefined) {
+            // ECMA-262 with the `u` flag, as JSON Schema reads `pattern`: `$` is the
+            // end of the string, with no exception for a final newline.
+            re = new RegExp(source, "u");
+            this.patterns.set(source, re);
+        }
+        return re;
+    }
+}
+/** Throw on a keyword this validator does not implement, anywhere in `schema`. */
+function supportedOnly(schema) {
+    const stack = [schema];
+    while (stack.length > 0) {
+        const s = stack.pop();
+        if (typeof s === "boolean")
+            continue;
+        if (!isObject(s))
+            throw new Error("json-schema: a schema is an object or a boolean");
+        for (const [k, v] of Object.entries(s)) {
+            if (!ANNOTATIONS.has(k) && !ASSERTIONS.has(k))
+                throw new Error(`json-schema: unsupported keyword ${k}`);
+            if (k === "properties" || k === "$defs")
+                stack.push(...Object.values(v));
+            else if (k === "anyOf")
+                stack.push(...v);
+            else if (k === "items" || k === "not" || k === "additionalProperties")
+                stack.push(v);
+        }
+    }
+}
+function stripFragment(id) {
+    const i = id.indexOf("#");
+    return i === -1 ? id : id.slice(0, i);
+}
+function hasType(value, type) {
+    switch (type) {
+        case "null":
+            return value === null;
+        case "boolean":
+            return typeof value === "boolean";
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return Number.isInteger(value);
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return isObject(value);
+        default:
+            throw new Error(`json-schema: unsupported type ${type}`);
+    }
+}
+/** String length as JSON Schema counts it: in code points, not UTF-16 code units. */
+function codePoints(s) {
+    let n = 0;
+    for (const _ of s)
+        n++;
+    return n;
+}
+function allUnique(items) {
+    for (let i = 0; i < items.length; i++) {
+        for (let j = i + 1; j < items.length; j++) {
+            if (deepEqual(items[i], items[j]))
+                return false;
+        }
+    }
+    return true;
+}
+/** JSON equality, without recursion so a deeply nested value cannot overflow the stack. */
+export function deepEqual(a, b) {
+    const stack = [[a, b]];
+    while (stack.length > 0) {
+        const [x, y] = stack.pop();
+        if (x === y)
+            continue;
+        if (Array.isArray(x)) {
+            if (!Array.isArray(y) || x.length !== y.length)
+                return false;
+            for (let i = 0; i < x.length; i++)
+                stack.push([x[i], y[i]]);
+            continue;
+        }
+        if (isObject(x)) {
+            if (!isObject(y))
+                return false;
+            const kx = Object.keys(x);
+            if (kx.length !== Object.keys(y).length)
+                return false;
+            for (const k of kx) {
+                if (!has(y, k))
+                    return false;
+                stack.push([x[k], y[k]]);
+            }
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+export function isObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+export function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+/** One JSON Pointer reference token (RFC 6901). */
+export function escapeToken(t) {
+    return t.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+export function unescapeToken(t) {
+    return t.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+/** Freeze `value` and every object and array inside it. */
+export function deepFreeze(value) {
+    const stack = [value];
+    while (stack.length > 0) {
+        const v = stack.pop();
+        if (v !== null && typeof v === "object" && !Object.isFrozen(v)) {
+            Object.freeze(v);
+            stack.push(...Object.values(v));
+        }
+    }
+    return value;
+}