@sanning/proof 0.12.0 → 0.13.0

package/dist/crypto.d.ts

@@ -4,7 +4,7 @@ export declare function isHexField(value: unknown, nibbles: number, lower?: bool
 export declare function utf8(s: string): Uint8Array;
 export declare function sha256Bytes(bytes: Uint8Array): Promise<Uint8Array>;
 export declare function sha256Hex(bytes: Uint8Array): Promise<string>;
-export declare function ed25519Verify(signatureHex: string, message: Uint8Array, publicKeyHex: string): Promise<boolean>;
+export declare function ed25519Verify(message: Uint8Array, signatureHex: string, publicKeyHex: string): Promise<boolean>;
 export declare function ed25519Sign(message: Uint8Array, privateKeyHex: string): Promise<string>;
 export declare function ed25519PublicKey(privateKeyHex: string): Promise<string>;
 export declare function verifyRsaPssSha256(payloadBytes: Uint8Array, signatureHex: string, publicKey: {

package/dist/crypto.js

@@ -74,7 +74,11 @@ export async function sha256Hex(bytes) {
 // appear in the envelope; message is raw bytes. Never throws — a malformed
 // signature or key is "not verified," not an exception, so a hostile envelope
 // can't crash the checker.
-export async function ed25519Verify(signatureHex, message, publicKeyHex) {
+// Arguments in the Python twin's order, `ed25519_verify(message,
+// signature_hex, public_key_hex)` (P-03, 0.13.0). The message came second
+// until 0.13.0; a caller that still passes the signature first gets a compile
+// error, because a string is not a Uint8Array.
+export async function ed25519Verify(message, signatureHex, publicKeyHex) {
     try {
         // zip215:false → strict RFC-8032 verification, matching the Go agent's
         // crypto/ed25519 exactly (noble defaults to the more lenient zip215:true).

package/dist/declaration.d.ts

@@ -1,30 +1,27 @@
 import { type HandoffRecord } from "./handoff.js";
 import { type SideContentMap } from "./side-content.js";
-/** The declaration schema this reader knows. */
+/** The first declaration schema, which every earlier reader knows. */
 export declare const DECLARATION_VERSION = "sanning.declaration/v1";
-/** The three states a declaration check can reach, from the §3 vocabulary. */
-export type DeclarationVerdict = "verified" | "failed" | "partial";
-export type DeclarationDeviationKind = 
-/** The declaration is written to this version and is not readable as one. */
-"declaration-malformed"
-/** A record the declaration expects is not in the pack. */
- | "declared-absent"
-/** A record in the pack the declaration never expected. */
- | "undeclared-present"
 /**
- * A record declared `content_withheld` whose bytes the pack supplies INSIDE
- * its own signed body, in `events[].content`.
+ * v1 plus a signed `records[].role` on every record (evidence-bundle.md
+ * 5.4.1 v1.20, A21). A reader that knows only v1 reads a v2 declaration as one
+ * it cannot read, which is the safe direction.
  */
- | "withheld-but-disclosed"
-/** The pack carries one `event_id` on two or more records. */
- | "duplicate-event-id"
-/** A claimed hand-off names a record the declaration does not declare. */
- | "pair-record-undeclared"
+export declare const DECLARATION_VERSION_V2 = "sanning.declaration/v2";
+/** Every declaration schema this reader knows, in the order they were added. */
+export declare const DECLARATION_VERSIONS: readonly ["sanning.declaration/v1", "sanning.declaration/v2"];
 /**
- * A claimed hand-off names a record that is not a conformant hand-off
- * record of the side it is claimed on (envelope-spec.md 4.1).
+ * What a v2 declaration may sign a record IS, compared exactly: `handoff`, a
+ * record 4.1 governs that the pack claims as a side in `handoffs[]`, or
+ * `step`, any other record.
  */
- | "pair-record-not-a-handoff";
+export declare const DECLARATION_ROLES: readonly ["handoff", "step"];
+export type DeclarationRole = (typeof DECLARATION_ROLES)[number];
+/** The three states a declaration check can reach, from the §3 vocabulary. */
+export declare const DECLARATION_VERDICTS: readonly ["verified", "failed", "partial"];
+export type DeclarationVerdict = (typeof DECLARATION_VERDICTS)[number];
+export declare const DECLARATION_DEVIATION_KINDS: readonly ["declaration_malformed", "declared_absent", "undeclared_present", "withheld_but_disclosed", "duplicate_event_id", "pair_record_undeclared", "pair_record_not_a_handoff", "role_handoff_unclaimed", "role_step_claimed", "role_step_governed", "role_step_unreadable"];
+export type DeclarationDeviationKind = (typeof DECLARATION_DEVIATION_KINDS)[number];
 /**
  * Every way a pack and the UNSIGNED content handed in beside it fail to line
  * up, as a closed set. Neither of these is a deviation, and neither of them
@@ -51,22 +48,8 @@ export type DeclarationDeviationKind =
  * legal and grades `verified`, which is strictly better than the `incomplete`
  * these carry.
  */
-export type DeclarationContentKind = 
-/**
- * A record declared `disclosed` whose bytes reached this reader from
- * neither channel. ALWAYS content-dependent: 5.4.1 lets those bytes travel
- * beside the pack as `logs/<event_id>.json`, so "no bytes arrived" is a
- * fact about what the READER was handed and never a fact about what the
- * holder supplied. No signature covers the absence of a file nobody signed.
- */
-"content-dependent-withholding"
-/**
- * A record declared `content_withheld` whose bytes reached this reader ONLY
- * from the unsigned side-content map. The pack's own body supplies none, so
- * the holder committed to no such disclosure. The in-body half of the same
- * rule is the `withheld-but-disclosed` DEVIATION and still fails.
- */
- | "content-dependent-disclosure";
+export declare const DECLARATION_CONTENT_KINDS: readonly ["content_dependent_withholding", "content_dependent_disclosure"];
+export type DeclarationContentKind = (typeof DECLARATION_CONTENT_KINDS)[number];
 /**
  * One way the pack and the unsigned content beside it do not line up. Named
  * like a deviation and weighed like an absence.
@@ -77,18 +60,8 @@ export interface DeclarationContentFinding {
     eventId?: string;
 }
 /** Everything this check reports that is NOT a deviation, as a closed set. */
-export type DeclarationNoteKind = 
-/**
- * Every record declared `disclosed` supplied no bytes, so nothing was
- * selected: the bytes did not travel with the pack.
- */
-"disclosure-did-not-travel"
-/**
- * A claimed hand-off side whose `event_bytes` the pack withholds. The reader
- * cannot see what the record is either way, so it is neither a conformant
- * hand-off record nor a non-conformant one.
- */
- | "pair-record-withheld";
+export declare const DECLARATION_NOTE_KINDS: readonly ["disclosure_did_not_travel", "pair_record_withheld", "role_step_withheld"];
+export type DeclarationNoteKind = (typeof DECLARATION_NOTE_KINDS)[number];
 /**
  * One named non-deviation finding, as data.
  *
@@ -102,9 +75,9 @@ export interface DeclarationNote {
     count?: number;
     /** The record this is about, where it is about one. */
     eventId?: string;
-    /** Which side of a claimed hand-off named it, for `pair-record-withheld`. */
+    /** Which side of a claimed hand-off named it, for `pair_record_withheld`. */
     side?: "sent" | "received";
-    /** Which claimed hand-off, by position, for `pair-record-withheld`. */
+    /** Which claimed hand-off, by position, for `pair_record_withheld`. */
     pairIndex?: number;
 }
 /** One deviation, as data. A surface renders its own prose or calls `renderDeviation`. */
@@ -116,8 +89,14 @@ export interface DeclarationDeviation {
     side?: "sent" | "received";
     /** Which claimed hand-off, by position, for the two `pair-record-` deviations. */
     pairIndex?: number;
-    /** What is wrong with the declaration itself, for `declaration-malformed`. */
+    /** What is wrong with the declaration itself, for `declaration_malformed`. */
     reason?: string;
+    /**
+     * The `declaration_version` the object claimed, for `declaration_malformed`,
+     * so the rendered sentence names the version the holder wrote to rather than
+     * the first one this reader learned.
+     */
+    version?: string;
 }
 export interface DeclarationCheck {
     verdict: DeclarationVerdict;
@@ -142,6 +121,22 @@ export interface DeclarationCheck {
     declared: string[];
     /** Of those, the ones declared withheld on purpose. */
     declaredWithheld: string[];
+    /**
+     * The `declaration_version` this reader read the object as, one of
+     * `DECLARATION_VERSIONS`, or `null` where the body carries no declaration or
+     * one whose version this reader does not know. Set for a malformed object
+     * too: the version was read, the rest was not. Optional so a check a caller
+     * builds by hand, as rule version 5 adapters do, still type-checks.
+     */
+    version?: string | null;
+    /**
+     * Every record a v2 declaration signs a role for, in declaration order.
+     * Empty for v1, and for anything this reader could not read.
+     */
+    roles?: {
+        eventId: string;
+        role: DeclarationRole;
+    }[];
 }
 /**
  * One of the pack's own records: the id, and whether the pack supplied its
@@ -242,7 +237,7 @@ export interface DeclarationClaims {
      */
     present: boolean;
     /**
-     * Whether this reader could read the claim as `DECLARATION_VERSION` AND the
+     * Whether this reader could read the claim as one of `DECLARATION_VERSIONS` AND the
      * object satisfies 5.4.1. `false` covers an absent declaration, an unknown
      * version and a malformed object, and a case reader must not read any of the
      * three as "the holder claimed nothing to check".
@@ -256,6 +251,17 @@ export interface DeclarationClaims {
      * is legal and is exactly the shape a case reader has to name.
      */
     claimedSides: string[];
+    /**
+     * The version the claim was read as, where `readable`; else `null`. The case
+     * reader's claim check is v1's alone (5.5.1 v1.20): a v2 pack's claim check
+     * is rule 9, which the declaration check already ran.
+     */
+    version: string | null;
+    /** Every record a READABLE v2 declaration signs a role for. Empty for v1. */
+    roles: {
+        eventId: string;
+        role: DeclarationRole;
+    }[];
 }
 /**
  * Read the claim a pack's declaration makes, without grading the pack.