@sanning/proof 0.16.0 → 0.18.0

package/dist/file-match.js

@@ -60,6 +60,26 @@ export const NOT_READ_REASONS = [
     "handoff_record_malformed",
     "message_withheld",
 ];
+/**
+ * Why a file was named in the report and never hashed (5.7.5). A skipped file
+ * is listed, never dropped: every file a command found is matched, unmatched or
+ * skipped, so "no match" is never read as "no file was there".
+ */
+export const SKIPPED_REASONS = [
+    "symbolic_link",
+    "not_regular",
+    "unreadable",
+    "too_large",
+    "refused",
+];
+const SKIPPED_TEXT = {
+    symbolic_link: "a symbolic link: not followed, not read",
+    not_regular: "not a regular file: not read",
+    unreadable: "could not be read",
+    too_large: "past the 1 GiB read from folders in one run: not read",
+    // Followed by the reader's own words, `renderSkipped`.
+    refused: "a .zip entry the reader refused",
+};
 const REASON_TEXT = {
     no_records: "this bundle carries no records this reading can read",
     record_unreadable: "its record bytes cannot be read",
@@ -124,17 +144,17 @@ async function messageOf(ev, eventId, messageHash, content) {
     }
     return ABSENT;
 }
-async function readPack(bundle, content, packRef) {
+async function readPack(bundle, content, packRef, packIndex) {
     const commitments = [];
     const notRead = [];
     const events = resolveTraceEvents(bundle);
     if (events === undefined) {
-        notRead.push({ packRef, eventId: null, reason: "no_records" });
+        notRead.push({ packRef, eventId: null, reason: "no_records", packIndex, recordIndex: null });
         return { commitments, notRead };
     }
-    for (const ev of events) {
+    for (const [recordIndex, ev] of events.entries()) {
         if (!isObject(ev)) {
-            notRead.push({ packRef, eventId: null, reason: "record_unreadable" });
+            notRead.push({ packRef, eventId: null, reason: "record_unreadable", packIndex, recordIndex });
             continue;
         }
         const envelope = own(ev, "envelope");
@@ -144,7 +164,7 @@ async function readPack(bundle, content, packRef) {
         if (rawBytes !== undefined && rawBytes !== null) {
             eventBytes = typeof rawBytes === "string" ? decode(rawBytes) : undefined;
             if (eventBytes === undefined) {
-                notRead.push({ packRef, eventId, reason: "record_unreadable" });
+                notRead.push({ packRef, eventId, reason: "record_unreadable", packIndex, recordIndex });
                 continue;
             }
         }
@@ -153,15 +173,15 @@ async function readPack(bundle, content, packRef) {
             acceptedSpecMajors: RECORD_PROFILES,
         });
         if (!result.ok || !isObject(envelope) || !envelopeSpelled(envelope)) {
-            notRead.push({ packRef, eventId, reason: "record_not_verified" });
+            notRead.push({ packRef, eventId, reason: "record_not_verified", packIndex, recordIndex });
             continue;
         }
         if (eventBytes === undefined) {
-            notRead.push({ packRef, eventId, reason: "record_withheld" });
+            notRead.push({ packRef, eventId, reason: "record_withheld", packIndex, recordIndex });
             continue;
         }
         if (result.payloadHashOk !== true) {
-            notRead.push({ packRef, eventId, reason: "record_not_verified" });
+            notRead.push({ packRef, eventId, reason: "record_not_verified", packIndex, recordIndex });
             continue;
         }
         let record;
@@ -172,7 +192,7 @@ async function readPack(bundle, content, packRef) {
             record = undefined;
         }
         if (!isObject(record)) {
-            notRead.push({ packRef, eventId, reason: "record_unreadable" });
+            notRead.push({ packRef, eventId, reason: "record_unreadable", packIndex, recordIndex });
             continue;
         }
         const key = own(envelope, "public_key");
@@ -188,12 +208,12 @@ async function readPack(bundle, content, packRef) {
         if (isHandoffNamespace(held)) {
             const messageHash = own(event, "message_hash");
             if (!isConformantHandoffRecord(held) || !isHexField(messageHash, 64, true)) {
-                notRead.push({ packRef, eventId, reason: "handoff_record_malformed" });
+                notRead.push({ packRef, eventId, reason: "handoff_record_malformed", packIndex, recordIndex });
                 continue;
             }
             const message = await messageOf(ev, eventId, messageHash, content);
             if (message === ABSENT) {
-                notRead.push({ packRef, eventId, reason: "message_withheld" });
+                notRead.push({ packRef, eventId, reason: "message_withheld", packIndex, recordIndex });
                 continue;
             }
             const parts = isObject(message) ? own(message, "parts") : undefined;
@@ -209,6 +229,8 @@ async function readPack(bundle, content, packRef) {
                         contentHash: (part.content_hash).toLowerCase(),
                         signer,
                         signedAt,
+                        packIndex,
+                        recordIndex,
                     });
                 });
             }
@@ -216,7 +238,7 @@ async function readPack(bundle, content, packRef) {
         }
         const contentHash = own(event, "content_hash");
         if (!isHexField(contentHash, 64)) {
-            notRead.push({ packRef, eventId, reason: "no_content_hash" });
+            notRead.push({ packRef, eventId, reason: "no_content_hash", packIndex, recordIndex });
             continue;
         }
         commitments.push({
@@ -227,6 +249,8 @@ async function readPack(bundle, content, packRef) {
             contentHash: contentHash.toLowerCase(),
             signer,
             signedAt,
+            packIndex,
+            recordIndex,
         });
     }
     return { commitments, notRead };
@@ -238,9 +262,16 @@ async function offeredDigests(files) {
     for (const entry of files) {
         if (!isObject(entry))
             throw new TypeError("matchFiles: each file is an object {name, bytes}");
-        const { name, bytes } = entry;
+        const { name, bytes, sha256 } = entry;
         if (typeof name !== "string")
             throw new TypeError("matchFiles: a file's name is a string");
+        if (sha256 !== undefined && sha256 !== null) {
+            if ((bytes !== undefined && bytes !== null) || !isHexField(sha256, 64, true)) {
+                throw new TypeError("matchFiles: a file is {name, bytes} or {name, sha256}, and a sha256 is 64 lowercase hex characters");
+            }
+            out.push([name, sha256]);
+            continue;
+        }
         if (!(bytes instanceof Uint8Array)) {
             throw new TypeError("matchFiles: a file's bytes are a Uint8Array");
         }
@@ -275,6 +306,7 @@ async function match(commitments, notRead, files) {
         notOffered: commitments.filter((_, i) => !used.has(i)),
         notRead,
         scope: FILE_MATCH_SCOPE,
+        skipped: [],
     };
 }
 /**
@@ -284,19 +316,19 @@ async function match(commitments, notRead, files) {
  * never an offered file.
  */
 export async function matchFiles(bundle, files, content) {
-    const { commitments, notRead } = await readPack(bundle, content, null);
+    const { commitments, notRead } = await readPack(bundle, content, null, null);
     return match(commitments, notRead, files);
 }
 /** The same reading over every pack of a case, each commitment naming its pack's `ref`. */
 export async function matchCaseFiles(packs, files) {
     const commitments = [];
     const notRead = [];
-    for (const pack of packs) {
+    for (const [packIndex, pack] of packs.entries()) {
         if (!isObject(pack))
             throw new TypeError("matchCaseFiles: each pack is an object {ref, bundle}");
         if (typeof pack.ref !== "string")
             throw new TypeError("matchCaseFiles: a pack's ref is a string");
-        const r = await readPack(pack.bundle, pack.content, pack.ref);
+        const r = await readPack(pack.bundle, pack.content, pack.ref, packIndex);
         commitments.push(...r.commitments);
         notRead.push(...r.notRead);
     }
@@ -305,7 +337,9 @@ export async function matchCaseFiles(packs, files) {
 function commitmentJson(c) {
     return {
         pack_ref: c.packRef,
+        pack_index: c.packIndex,
         event_id: c.eventId,
+        record_index: c.recordIndex,
         kind: c.kind,
         part_index: c.partIndex,
         content_hash: c.contentHash,
@@ -315,6 +349,7 @@ function commitmentJson(c) {
 }
 /** The reading as the `files` member of `--json`, identical in both kernels. */
 export function fileMatchToJson(reading) {
+    const skipped = reading.skipped ?? [];
     return {
         offered: reading.offered,
         matched: reading.matched.map((m) => ({
@@ -326,13 +361,32 @@ export function fileMatchToJson(reading) {
         not_offered: reading.notOffered.map(commitmentJson),
         not_read: reading.notRead.map((n) => ({
             pack_ref: n.packRef,
+            pack_index: n.packIndex,
             event_id: n.eventId,
+            record_index: n.recordIndex,
             reason: n.reason,
             rendered: renderNotRead(n),
         })),
+        // Present only when something was skipped, so a reading with no skipped
+        // file is the object it was before a folder could be offered (A40).
+        ...(skipped.length > 0
+            ? {
+                skipped: skipped.map((k) => ({
+                    name: k.name,
+                    reason: k.reason,
+                    ...(k.detail !== undefined ? { detail: k.detail } : {}),
+                    rendered: renderSkipped(k),
+                })),
+            }
+            : {}),
         scope: reading.scope,
     };
 }
+function renderSkipped(k) {
+    if (k.detail !== undefined)
+        return `${k.name}  (${SKIPPED_TEXT[k.reason]}: ${k.detail}; not read)`;
+    return `${k.name}  (${SKIPPED_TEXT[k.reason]})`;
+}
 function recordName(eventId) {
     return eventId !== null ? `record ${eventId}` : "a record with no event_id";
 }
@@ -350,12 +404,41 @@ function renderNotRead(n) {
         return `no record read${where}: ${REASON_TEXT[n.reason]}`;
     return `${recordName(n.eventId)}${where} not read: ${REASON_TEXT[n.reason]}`;
 }
-/** The text report's lines for the reading, identical in both kernels. */
-export function renderFileMatch(reading) {
+/**
+ * The commitments no offered file matched and no disclosed log answers.
+ *
+ * `contents` is each pack's side content by `pack_ref`. A record whose own pack
+ * discloses bytes that hash to its `content_hash` is accounted for by the pack,
+ * and is not returned. Only the text report's count reads this; the reading, and
+ * `--json`, still list every commitment no file matched.
+ */
+export async function notAccountedFor(reading, contents) {
+    const out = [];
+    for (const c of reading.notOffered) {
+        const held = c.packRef !== null ? contents.get(c.packRef) : undefined;
+        const raw = c.kind === "record" && held !== undefined && held !== null && c.eventId !== null
+            ? decode(sideContentEntry(held, c.eventId).value)
+            : undefined;
+        if (raw !== undefined && (await sha256Hex(raw)) === c.contentHash)
+            continue;
+        out.push(c);
+    }
+    return out;
+}
+/**
+ * The text report's lines for the reading, identical in both kernels.
+ *
+ * By default every commitment no file matched is a line. `notAmong` is the case
+ * command's report when no `--files` was given: one count line for the recorded
+ * files no loose file matched, and no line for each (A41).
+ */
+export function renderFileMatch(reading, notAmong) {
+    const skipped = reading.skipped ?? [];
     const lines = [
         `files         ${reading.offered} offered: ${reading.matched.length} vouched for, ` +
-            `${reading.unmatched.length} match no record; ` +
-            `${reading.notOffered.length} commitment(s) had no file offered`,
+            `${reading.unmatched.length} match no record` +
+            (notAmong === undefined ? `; ${reading.notOffered.length} commitment(s) had no file offered` : "") +
+            (skipped.length > 0 ? `; ${skipped.length} skipped, not read` : ""),
     ];
     for (const m of reading.matched) {
         lines.push(`  vouched for  ${m.name}  sha256 ${m.sha256}`);
@@ -364,8 +447,16 @@ export function renderFileMatch(reading) {
     }
     for (const u of reading.unmatched)
         lines.push(`  no match     ${u.name}  sha256 ${u.sha256}`);
-    for (const c of reading.notOffered) {
-        lines.push(`  not offered  ${c.contentHash}, ${renderCommitment(c)}`);
+    for (const k of skipped)
+        lines.push(`  skipped      ${renderSkipped(k)}`);
+    if (notAmong === undefined) {
+        for (const c of reading.notOffered) {
+            lines.push(`  not offered  ${c.contentHash}, ${renderCommitment(c)}`);
+        }
+    }
+    else if (notAmong > 0) {
+        lines.push(`  ${notAmong} recorded commitment(s) matched no loose file and no log in their own pack ` +
+            "(--json lists every commitment no file matched, these included)");
     }
     for (const n of reading.notRead)
         lines.push(`  not read     ${renderNotRead(n)}`);

package/dist/grading.d.ts

@@ -145,6 +145,13 @@ export interface PackGrade {
  * bundle, precisely so the transport can say things the map cannot.
  */
 export declare function accountDisclosure(bundle: unknown, content: SideContentMap): DisclosureAccount;
+/**
+ * A JSON number read by its value: an integer within 2**53 - 1, or null.
+ * `Number.isSafeInteger`, mirrored by `_js_safe_integer` in
+ * `src/sanning_proof/chain.py`, so `2.0` is 2 in both kernels and
+ * `9007199254740993`, which this parser rounds, is unreadable in both.
+ */
+export declare function safeInteger(value: unknown): number | null;
 /** The `leaf_count` a checkpoint's SIGNED record commits to, or null if unreadable. */
 export declare function signedLeafCount(checkpoint: {
     event_bytes?: unknown;

package/dist/grading.js

@@ -323,6 +323,16 @@ content) {
     const extra = sideContentKeys(content).filter((id) => !accounted.has(id));
     return { expected, present, missing, unreadable, extra };
 }
+/**
+ * A JSON number read by its value: an integer within 2**53 - 1, or null.
+ * `Number.isSafeInteger`, mirrored by `_js_safe_integer` in
+ * `src/sanning_proof/chain.py`, so `2.0` is 2 in both kernels and
+ * `9007199254740993`, which this parser rounds, is unreadable in both.
+ */
+export function safeInteger(value) {
+    // `+ 0` folds -0 into 0, which Python's `int(-0.0)` already is.
+    return typeof value === "number" && Number.isSafeInteger(value) ? value + 0 : null;
+}
 /** The `leaf_count` a checkpoint's SIGNED record commits to, or null if unreadable. */
 export function signedLeafCount(checkpoint) {
     const hex = checkpoint?.event_bytes;
@@ -336,8 +346,10 @@ export function signedLeafCount(checkpoint) {
         // `BOM + JCS(checkpoint)` yielded a signed leaf count here and unreadable
         // there, and that count decides a completeness note (proof#140 gate 5).
         const record = jcsParse(hexToBytes(hex));
-        const n = record?.event?.leaf_count;
-        return Number.isInteger(n) ? n : null;
+        // Read BY VALUE, the model JCS signs: a record spelling `3.0`, `3e0` or
+        // `30e-1` commits to 3, and since A38 (proof#197) this count decides a
+        // verdict, not only a note. Past 2**53 - 1 it is unreadable, as in Python.
+        return safeInteger(record?.event?.leaf_count);
     }
     catch {
         return null;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { ACCEPTED_SPEC_MAJORS, contentHashes, jcs, specVersionSupported, verifyEnvelope, } from "./verifier.js";
-export { bytesToHex, deriveOperatorAddress, ed25519Verify, hexToBytes, sha256Bytes, sha256Hex, utf8, verifyRsaPssSha256, } from "./crypto.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";
@@ -8,16 +8,16 @@ export { PACK_GRADE_CAUSE_KINDS, PACK_VERDICTS, accountDisclosure, completenessN
 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_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_NOTE_KINDS, CASE_RELIANCE, CASE_RELIANCE_HANDOFF_CLAUSE, 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_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 { 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 type { OnChainHalf, OnChainRow, PublicRecordPack, PublicRecordResult, PublicRecordState, WitnessLookupOptions, WitnessTimeRow, } from "./witness-lookup.js";
-export type { CaseException, CaseExceptionKind, CaseNote, CaseNoteKind, CasePack, CasePackReading, CaseReading, CaseRecordReading, CaseVerdict, WitnessLine, WitnessState, } from "./case.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";
 export type { CaseFileFinding, CaseFileFindingKind, CaseFileIndexReading, } from "./case-file.js";
-export { FILE_MATCH_SCOPE, NOT_READ_REASONS, fileMatchToJson, matchCaseFiles, matchFiles, renderFileMatch, } from "./file-match.js";
-export type { FileCommitment, FileMatchPack, FileMatchReading, MatchedFile, NotRead, NotReadReason, OfferedFile, UnmatchedFile, } from "./file-match.js";
+export { FILE_MATCH_SCOPE, NOT_READ_REASONS, SKIPPED_REASONS, fileMatchToJson, matchCaseFiles, matchFiles, notAccountedFor, renderFileMatch, } from "./file-match.js";
+export type { FileCommitment, FileMatchPack, FileMatchReading, MatchedFile, NotRead, NotReadReason, OfferedFile, SkippedFile, SkippedReason, UnmatchedFile, } from "./file-match.js";
 export { ADAPTER_CHAIN_NAMESPACES, CHAIN_READING_SCOPE, readChains, renderChainFinding, } from "./chain.js";
 export type { ChainFinding, ChainFindingKind, ChainReading, ChainSource, ChainSummary, } from "./chain.js";
 export { EXIT_CODES, EXIT_CODES_HELP, EXIT_FAILED, EXIT_MALFORMED, EXIT_MIXED, EXIT_UNDETERMINED, EXIT_VERIFIED, exitCodeFor, } from "./exit-codes.js";

package/dist/index.js

@@ -18,7 +18,7 @@
 // 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";
-export { bytesToHex, deriveOperatorAddress, ed25519Verify, hexToBytes, sha256Bytes, sha256Hex, utf8, verifyRsaPssSha256, } from "./crypto.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
@@ -85,7 +85,7 @@ export { DECLARATION_CONTENT_KINDS, DECLARATION_DEVIATION_KINDS, DECLARATION_NOT
 //
 // 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_NOTE_KINDS, CASE_RELIANCE, CASE_RELIANCE_HANDOFF_CLAUSE, 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_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.
 export { MAX_BLOCK_TIME, MAX_WITNESS_CACHE_DEPTH, WITNESS_CACHE_NAME, WITNESS_CACHE_VERSION, checkWitnessCache, formatBlockTime, readWitnessCache, renderWitnessTime, witnessTimeQuery, } from "./witness-cache.js";
@@ -111,7 +111,7 @@ export { CASE_FILE_FINDING_KINDS, CASE_FILE_INDEX_NAME, CASE_FILE_VERSION, HOW_T
 // 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.
-export { FILE_MATCH_SCOPE, NOT_READ_REASONS, fileMatchToJson, matchCaseFiles, matchFiles, renderFileMatch, } from "./file-match.js";
+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.
 //

package/dist/merkle.js

@@ -66,26 +66,32 @@ export async function verifyInclusion(leaf, leafIndex, totalLeaves, auditPath, e
     }
     if (totalLeaves === 1)
         return auditPath.length === 0 && bytesEqual(leaf, expectedRoot);
+    // Arithmetic, not bitwise: JavaScript's `&` and `>>=` truncate to 32 bits,
+    // so a tree past 2**31 leaves walked a different tree here than in the
+    // Python kernel, whose integers are unbounded. `% 2` and a halving floor
+    // are exact for every safe integer, and the stated index and count reach
+    // this walk as safe integers.
     let fn = leafIndex;
     let sn = totalLeaves - 1;
     let r = leaf;
+    const half = (v) => Math.floor(v / 2);
     for (const p of auditPath) {
         if (sn === 0)
             return false; // path longer than the tree depth — malformed
-        if ((fn & 1) === 1 || fn === sn) {
+        if (fn % 2 === 1 || fn === sn) {
             r = await nodeHash(p, r);
-            if ((fn & 1) === 0) {
-                while ((fn & 1) === 0 && fn !== 0) {
-                    fn >>= 1;
-                    sn >>= 1;
+            if (fn % 2 === 0) {
+                while (fn % 2 === 0 && fn !== 0) {
+                    fn = half(fn);
+                    sn = half(sn);
                 }
             }
         }
         else {
             r = await nodeHash(r, p);
         }
-        fn >>= 1;
-        sn >>= 1;
+        fn = half(fn);
+        sn = half(sn);
     }
     return sn === 0 && bytesEqual(r, expectedRoot);
 }

package/dist/verifier.js

@@ -7,7 +7,7 @@
 // Conformance is enforced by test/conformance.test.ts, which runs every
 // corpus test vector through this code and asserts byte-for-byte agreement.
 import canonicalize from "canonicalize";
-import { ed25519Verify, isHexField, sha256Hex, utf8 } from "./crypto.js";
+import { SIGNATURE_FAILED, ed25519Refusal, isHexField, sha256Hex, utf8 } from "./crypto.js";
 // Fail-closed accepted-profile registry (envelope-spec §2): exactly the
 // accepted profile majors, nothing else. Minors within an accepted
 // major ("sanning.agent/v1.<minor>") are additive and tolerated — matching the Go
@@ -690,7 +690,7 @@ export async function verifyEnvelope(env, options) {
     try {
         return await verifyEnvelopeChecked(env, opts);
     }
-    catch (e) {
+    catch {
         return {
             ok: false,
             specVersionOk: false,
@@ -700,7 +700,7 @@ export async function verifyEnvelope(env, options) {
             signatureOk: false,
             contentHashOk: opts.expectedContentHash === undefined ? null : false,
             contentRole: null,
-            errors: [`envelope could not be read: ${stringifyErr(e)}`],
+            errors: ["envelope could not be read"],
         };
     }
 }
@@ -737,8 +737,13 @@ async function verifyEnvelopeChecked(env, opts) {
         };
     }
     const specVersionOk = specVersionSupported(env.spec_version, opts.acceptedSpecMajors);
-    if (!specVersionOk)
-        errors.push(`unsupported spec_version: ${JSON.stringify(env.spec_version)}`);
+    if (!specVersionOk) {
+        // Absent or null reads "missing", as in the Python kernel. Everything else
+        // is quoted the way both kernels quote a value in a finding.
+        errors.push(env.spec_version === undefined || env.spec_version === null
+            ? "missing spec_version"
+            : `unsupported spec_version: ${JSON.stringify(env.spec_version)}`);
+    }
     // Skeleton field format (envelope-spec §2, proof#95): a present `signed_at`
     // or `environment` that is not what §2 says fails the verdict. There is no
     // result field for it, so the verdict shape is unchanged for every envelope
@@ -766,8 +771,8 @@ async function verifyEnvelopeChecked(env, opts) {
     // line, or an ANSI escape that paints `VERIFIED` green, into what the
     // verifier prints. No other field in this file echoes its value, the Python
     // twin names the same failure without one, and the value is in the envelope
-    // the auditor already holds. The RECOMPUTED digest stays: this kernel
-    // produced it, so it is 64 characters of lowercase hex by construction.
+    // the auditor already holds. Neither is the recomputed digest: the reason is
+    // the Python kernel's sentence, word for word (proof#150).
     let payloadHashOk;
     if (typeof env.payload_hash !== "string") {
         payloadHashOk = false;
@@ -779,23 +784,23 @@ async function verifyEnvelopeChecked(env, opts) {
             try {
                 const recomputed = await sha256Hex(utf8(jcs(env.payload)));
                 checks.push(recomputed === env.payload_hash);
-                if (recomputed !== env.payload_hash) {
-                    errors.push(`payload_hash mismatch: the envelope's payload_hash is not SHA-256(JCS(payload)), recomputed=${recomputed}`);
-                }
             }
-            catch (e) {
+            catch {
                 checks.push(false);
-                errors.push(`payload canonicalization failed: ${stringifyErr(e)}`);
+                errors.push("payload is not JCS-canonicalizable");
             }
         }
         if (opts.payloadBytes !== undefined) {
             const external = await sha256Hex(opts.payloadBytes);
             checks.push(external === env.payload_hash);
-            if (external !== env.payload_hash) {
-                errors.push(`payload_hash does not match the committed bytes: bytes=${external}`);
-            }
         }
         payloadHashOk = checks.length > 0 ? checks.every(Boolean) : null;
+        // One sentence for a mismatch against the inline payload, the supplied
+        // bytes or both, and none when the payload could not be canonicalized: the
+        // Python kernel's rule, word for word (proof#150).
+        if (payloadHashOk === false && !errors.some((e) => e.startsWith("payload is not"))) {
+            errors.push("payload_hash does not match the committed bytes");
+        }
     }
     // Check 2 — Signature Confirmed: Ed25519 over the signed scope, which is
     // JCS(envelope minus `signature` minus `co_signatures`) per envelope-spec §2.
@@ -803,15 +808,22 @@ async function verifyEnvelopeChecked(env, opts) {
     // invalidating the primary signature; the field is reserved/default-absent.
     // The corpus has no co-signed vectors, so this strip is pinned by an explicit
     // unit test rather than by conformance.
+    // The refusal names the clause of the Ed25519 rule a signature breaks
+    // (envelope-spec §7, A44), so a forged shape reads differently from a
+    // corrupted byte; an equation that does not hold reads the bare sentence.
     let signatureOk = false;
     try {
         const { signature: _signature, co_signatures: _coSignatures, ...envelopeForSig } = env;
-        signatureOk = await ed25519Verify(utf8(jcs(envelopeForSig)), env.signature, env.public_key);
-        if (!signatureOk)
-            errors.push("Ed25519 signature verification failed");
+        const refusal = await ed25519Refusal(utf8(jcs(envelopeForSig)), env.signature, env.public_key);
+        signatureOk = refusal === null;
+        if (refusal !== null)
+            errors.push(refusal);
     }
-    catch (e) {
-        errors.push(`signature verification error: ${stringifyErr(e)}`);
+    catch {
+        // The sentence the Python kernel writes for the same failure. What was
+        // thrown is the host's wording (`jcs: input nesting exceeds ...`), and a
+        // public result carries the kernel's own words only (proof#150).
+        errors.push(SIGNATURE_FAILED);
     }
     // Check 3 (optional) — Content Bind: the user's bytes match a hash this
     // envelope commits to. The tag got us here; only this proves the bytes match.
@@ -865,6 +877,3 @@ async function verifyEnvelopeChecked(env, opts) {
         errors,
     };
 }
-function stringifyErr(e) {
-    return e instanceof Error ? e.message : String(e);
-}

package/dist/zip-reader.d.ts

@@ -27,6 +27,13 @@
 export declare const MAX_ZIP_ENTRIES = 50000;
 /** More uncompressed bytes than this, across every entry, refuse the archive. */
 export declare const MAX_ZIP_BYTES: number;
+/**
+ * An archive file larger than this is refused before it is read: the
+ * uncompressed cap, and room for the headers, the central directory and the
+ * deflate framing of an archive that holds that much. The caller checks the
+ * size on disk, so the archive is never read whole to find out it is too big.
+ */
+export declare const MAX_ZIP_ARCHIVE_BYTES: number;
 /** A name nested deeper than this many folders refuses the archive. */
 export declare const MAX_ZIP_DEPTH = 32;
 /** The archive cannot be read as a case file. `message` is the whole report, identical in both kernels. */

package/dist/zip-reader.js

@@ -29,6 +29,13 @@ import { utf8Strict } from "./verifier.js";
 export const MAX_ZIP_ENTRIES = 50_000;
 /** More uncompressed bytes than this, across every entry, refuse the archive. */
 export const MAX_ZIP_BYTES = 2 ** 30;
+/**
+ * An archive file larger than this is refused before it is read: the
+ * uncompressed cap, and room for the headers, the central directory and the
+ * deflate framing of an archive that holds that much. The caller checks the
+ * size on disk, so the archive is never read whole to find out it is too big.
+ */
+export const MAX_ZIP_ARCHIVE_BYTES = MAX_ZIP_BYTES + 256 * 2 ** 20;
 /** A name nested deeper than this many folders refuses the archive. */
 export const MAX_ZIP_DEPTH = 32;
 const EOCD = 0x06054b50;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanning/proof",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "TypeScript kernel of the Sanning verification stack: RFC 8785 (JCS) canonicalization, SHA-256, and Ed25519 verification for Verifiable Event Envelopes. Full-family verifier (inline + external commitment); accepts sanning.agent/v1 and sanning.events/v2. Conformance-gated byte-for-byte against the test-vectors corpus.",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@noble/ed25519": "^2.1.0",
+    "@noble/ed25519": "^3.2.0",
     "canonicalize": "^2.0.0"
   },
   "devDependencies": {