genesis-mesh-sdk 0.58.1 → 0.59.1

package/CHANGELOG.md

@@ -7,6 +7,31 @@ Versions align with the [Genesis Mesh release sequence](https://github.com/Genes
 
 ---
 
+## [0.59.1] - 2026-10-01
+
+Coordinated Genesis Mesh v0.59.1 release: TypeScript support for governed
+secret lifecycles (attestation-backed evaluation, policy lifecycle, evidence
+store, offline verification).
+
+- Add attestation-backed evaluation, attestation queries, recognition policy reads
+  and signed revocation feeds.
+- Add boundary-policy management, the execution evidence-store client, signed
+  execution recording, governed actions and inventory reconciliation.
+- Add Python-compatible canonical JSON, model digests and offline verification
+  of signed artifacts and complete evidence exports.
+- Require verified decisions and expected bindings before governed callbacks;
+  guard evaluation and execution metadata before sending it to the NA.
+- Add async signers, signed admin GETs, NDJSON paging, bounded opt-in retries and
+  typed errors carrying NA details and request IDs.
+- Correct wire types and CommonJS package loading; require Node.js 22 or newer.
+- Add Python-vector, negative-path, public-route and live local-NA tests, plus
+  typechecking of the test suite and package entry-point smoke checks.
+
+## [0.59.0] - 2026-10-01
+
+Coordinated Genesis Mesh v0.59.0 release. No functional changes; the core adds
+the Network Authority evidence store, which this SDK does not wrap yet.
+
 ## [0.58.1] - 2026-09-29
 
 Coordinated Genesis Mesh v0.58.1 release. No functional changes; the core adds
@@ -33,22 +58,22 @@ across the train (see the core `docs/development/versioning.md`).
 
 ---
 
-## [0.53.0] — 2026-06-29
+## [0.53.0] - 2026-06-29
 
 ### Added
 
-- `GenesisMeshClient` — unified entry point with 7 domain sub-clients
-- `AgreementClient` — capability offer, counter, accept, verify
-- `BoundaryClient` — boundary decision and verification
-- `EvidenceClient` — trust evidence build and verify
-- `AttestationClient` — membership attestation issue, revoke, recognition policy
-- `DisclosureClient` — selective Merkle capability disclosure, nullifier
-- `ConsensusClient` — validator vote, consensus proof assembly and verify
-- `DataUsageClient` — data license policy, access intent, verify
-- `src/auth.ts` — `canonicalJson`, `signBytes`, `buildAdminHeaders` (Ed25519 / PKCS8-DER)
-- `src/client.ts` — `HttpTransport` with fetch, timeout, and typed error mapping
-- `src/errors.ts` — `GenesisMeshError` and typed subclasses for all NA error codes
-- `src/types.ts` — 30+ protocol interfaces matching the NA JSON wire format
+- `GenesisMeshClient` - unified entry point with 7 domain sub-clients
+- `AgreementClient` - capability offer, counter, accept, verify
+- `BoundaryClient` - boundary decision and verification
+- `EvidenceClient` - trust evidence build and verify
+- `AttestationClient` - membership attestation issue, revoke, recognition policy
+- `DisclosureClient` - selective Merkle capability disclosure, nullifier
+- `ConsensusClient` - validator vote, consensus proof assembly and verify
+- `DataUsageClient` - data license policy, access intent, verify
+- `src/auth.ts` - `canonicalJson`, `signBytes`, `buildAdminHeaders` (Ed25519 / PKCS8-DER)
+- `src/client.ts` - `HttpTransport` with fetch, timeout, and typed error mapping
+- `src/errors.ts` - `GenesisMeshError` and typed subclasses for all NA error codes
+- `src/types.ts` - 30+ protocol interfaces matching the NA JSON wire format
 - ESM and CJS dual build (`dist/esm/`, `dist/cjs/`, `dist/types/`)
 - 74 Jest unit tests covering all sub-clients
 

package/README.md

@@ -2,7 +2,7 @@
 
 TypeScript SDK for the Genesis Mesh Network Authority HTTP API.
 
-**Node.js ≥ 20 required. Zero runtime dependencies.**
+**Node.js ≥ 22 required. Zero runtime dependencies.**
 
 ## Install
 
@@ -29,6 +29,19 @@ const client = new GenesisMeshClient({
 });
 ```
 
+## Governed lifecycle SDK
+
+The SDK supports attestation-backed evaluation, boundary-policy management,
+execution recording, evidence-store queries and offline verification.
+
+- [Governed actions and reconciliation](docs/governance.md)
+- [Evidence store, policies, signers and retries](docs/evidence-store.md)
+- [Offline verification and integration tests](docs/offline-verification.md)
+
+`governedAction` requires verification keys and explicit expected policies. It
+verifies the signed response and its request context before calling the supplied
+action. Attestation-backed ALLOWs also require the expected attestation.
+
 ## Sub-clients
 
 ### agreement
@@ -38,7 +51,7 @@ const client = new GenesisMeshClient({
 > [Raw admin calls](#raw-admin-calls) below).
 
 ```typescript
-// Create a capability offer (admin — requires signing key)
+// Create a capability offer (admin - requires signing key)
 const offer = await client.agreement.offer({
   responder_sovereign_id: 'BETA-NA',
   capabilities: ['read:data', 'write:log'],
@@ -212,7 +225,7 @@ For NA routes not yet covered by a sub-client (e.g. `/admin/recognition-treaties
 use `buildAdminHeaders` directly:
 
 ```typescript
-import { buildAdminHeaders } from 'genesis-mesh-sdk';
+import { buildAdminHeaders, canonicalJson } from 'genesis-mesh-sdk';
 
 const body = {
   subject_sovereign_id: 'BETA-NA',
@@ -225,7 +238,7 @@ const headers = buildAdminHeaders(body, keyId, signingKeyBase64);
 const res = await fetch(`${baseUrl}/admin/recognition-treaties`, {
   method: 'POST',
   headers: { 'Content-Type': 'application/json', ...headers },
-  body: JSON.stringify(body),
+  body: canonicalJson(body),
 });
 ```
 
@@ -268,7 +281,9 @@ The SDK handles all of this automatically when `signingKeyBase64` is provided.
 ```bash
 npm run build       # ESM → dist/esm/ and CJS → dist/cjs/
 npm run typecheck   # type-check without emitting
-npm test            # run 74 Jest tests
+npm test            # unit tests and Python-vector verification
+npm run test:package # validate ESM and CommonJS entry points after building
+npm run test:e2e    # disposable local Python NA (see verification guide)
 ```
 
 ## License

package/dist/cjs/attestation.js

@@ -12,11 +12,33 @@ class AttestationClient {
     }
     /** Revoke a membership attestation by ID (admin). */
     revoke(attestationId, params = {}) {
-        return this.http.adminPost(`/admin/attestations/${attestationId}/revoke`, params);
+        return this.http.adminPost(`/admin/attestations/${encodeURIComponent(attestationId)}/revoke`, params);
     }
     /** Set the active recognition policy for this sovereign (admin). */
     savePolicy(params) {
         return this.http.adminPost('/admin/recognition-policy', params);
     }
+    /** A stored attestation with its current status (unauthenticated). */
+    get(attestationId) {
+        return this.http.publicGet(`/attestations/${encodeURIComponent(attestationId)}`);
+    }
+    /** Stored attestations, optionally filtered by issuer, subject or status (unauthenticated). */
+    list(params = {}) {
+        return this.http.publicGet('/attestations', { ...params });
+    }
+    /** Verify an attestation against a recognition policy (unauthenticated). */
+    verify(params) {
+        return this.http.publicPost('/attestations/verify', params, true);
+    }
+    /** The NA's active recognition policy (unauthenticated). */
+    getPolicy() {
+        return this.http.publicGet('/recognition-policy');
+    }
+    /** Signed feed of revoked attestations for an issuer; defaults to this NA (unauthenticated). */
+    revocationFeed(issuerSovereignId) {
+        return this.http.publicGet('/sovereign-revocation-feed', {
+            issuer_sovereign_id: issuerSovereignId,
+        });
+    }
 }
 exports.AttestationClient = AttestationClient;

package/dist/cjs/auth.js

@@ -1,30 +1,135 @@
 "use strict";
 /**
- * Admin authentication for Genesis Mesh NA endpoints.
+ * Key operations for Genesis Mesh: canonical JSON, digests, Ed25519 signing
+ * and verification, and admin request authentication.
  *
- * The NA verifies requests via four HTTP headers:
- *   X-Admin-Key-Id        — which operator key was used
- *   X-Admin-Signature     — Ed25519(canonicalJson({body,key_id,nonce,timestamp}))
- *   X-Admin-Timestamp     — ISO 8601 UTC timestamp
- *   X-Admin-Nonce         — UUID v4 replay-protection token
+ * The NA verifies admin requests via four HTTP headers:
+ *   X-Admin-Key-Id        - which operator key was used
+ *   X-Admin-Signature     - Ed25519(canonicalJson({body,key_id,nonce,timestamp}))
+ *   X-Admin-Timestamp     - ISO 8601 UTC timestamp
+ *   X-Admin-Nonce         - UUID v4 replay-protection token
  *
- * Canonical JSON matches Python json.dumps(..., sort_keys=True, separators=(",",":")):
- * keys are recursively sorted, output is compact with no whitespace.
+ * Canonical JSON matches Python json.dumps(..., sort_keys=True, separators=(",",":"))
+ * applied to the value the NA parses: keys recursively sorted, compact output,
+ * non-ASCII escaped (ensure_ascii), and non-integer numbers in Python float repr.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJson = parseJson;
+exports.compareCodePoints = compareCodePoints;
 exports.canonicalJson = canonicalJson;
+exports.sha256Hex = sha256Hex;
+exports.canonicalDigest = canonicalDigest;
 exports.signBytes = signBytes;
+exports.verifyBytes = verifyBytes;
+exports.publicKeyFromSeed = publicKeyFromSeed;
+exports.seedSigner = seedSigner;
+exports.signCanonical = signCanonical;
+exports.verifyCanonical = verifyCanonical;
+exports.pythonTimestamp = pythonTimestamp;
 exports.buildAdminHeaders = buildAdminHeaders;
+exports.buildAdminHeadersWithSigner = buildAdminHeadersWithSigner;
 const node_crypto_1 = require("node:crypto");
-/** Recursively produce compact sorted JSON — stable across Python and Node.js. */
+/** Escape every non-ASCII UTF-16 unit as \uXXXX, as Python's ensure_ascii does. */
+function asciiString(value) {
+    return JSON.stringify(value).replace(/[^\x00-\x7e]/g, ch => '\\u' + ch.charCodeAt(0).toString(16).padStart(4, '0'));
+}
+function pythonFloatRepr(value) {
+    if (Object.is(value, -0))
+        return '-0.0';
+    const [mantissa, expText] = value.toExponential().split('e');
+    const exp = Number(expText);
+    if (exp >= -4 && exp < 16) {
+        const negative = mantissa.startsWith('-');
+        const digits = mantissa.replace('-', '').replace('.', '');
+        const point = exp + 1;
+        let fixed;
+        if (point <= 0)
+            fixed = '0.' + '0'.repeat(-point) + digits;
+        else if (point >= digits.length)
+            fixed = digits + '0'.repeat(point - digits.length) + '.0';
+        else
+            fixed = digits.slice(0, point) + '.' + digits.slice(point);
+        return (negative ? '-' : '') + fixed;
+    }
+    const sign = exp < 0 ? '-' : '+';
+    return `${mantissa}e${sign}${String(Math.abs(exp)).padStart(2, '0')}`;
+}
+/**
+ * The text Python's json.dumps produces for the value the NA parses from this
+ * number's JSON. Integral text stays an int; anything else is a Python float.
+ * `pythonFloat` forces float repr for an integral value the NA sent as a float.
+ */
+function pythonNumber(value, pythonFloat = false) {
+    if (!Number.isFinite(value))
+        throw new Error('canonical JSON cannot encode a non-finite number');
+    const text = JSON.stringify(value);
+    if (!pythonFloat && /^-?\d+$/.test(text))
+        return text;
+    return pythonFloatRepr(value);
+}
+/**
+ * Holder objects/arrays → keys whose value the NA sent as an integral float
+ * (`90.0`). JSON.parse yields the number 90; canonical JSON must emit 90.0 or
+ * an NA signature over it would not verify.
+ */
+const PYTHON_FLOATS = new WeakMap();
+/**
+ * JSON.parse that remembers integral-valued floats so canonicalJson reproduces
+ * them. Use it for any NA JSON that will be verified or digested. Requires
+ * JSON.parse source text access (Node.js 22+).
+ */
+function parseJson(text) {
+    return JSON.parse(text, function (key, value, context) {
+        if (typeof value === 'number' && Number.isInteger(value) && context?.source && /[.eE]/.test(context.source)) {
+            let keys = PYTHON_FLOATS.get(this);
+            if (!keys)
+                PYTHON_FLOATS.set(this, (keys = new Set()));
+            keys.add(key);
+        }
+        return value;
+    });
+}
+function canonicalMember(holder, key, value) {
+    if (typeof value === 'number')
+        return pythonNumber(value, PYTHON_FLOATS.get(holder)?.has(key) ?? false);
+    return canonicalJson(value);
+}
+/** Python orders strings by Unicode code point, not UTF-16 code unit. */
+function compareCodePoints(a, b) {
+    const left = Array.from(a, c => c.codePointAt(0));
+    const right = Array.from(b, c => c.codePointAt(0));
+    for (let i = 0; i < Math.min(left.length, right.length); i++) {
+        if (left[i] !== right[i])
+            return left[i] - right[i];
+    }
+    return left.length - right.length;
+}
+/** Compact sorted JSON, byte-identical to the Python canonical form. */
 function canonicalJson(value) {
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'string')
+        return asciiString(value);
+    if (typeof value === 'number')
+        return pythonNumber(value);
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
     if (Array.isArray(value))
-        return '[' + value.map(canonicalJson).join(',') + ']';
-    const keys = Object.keys(value).sort();
-    const pairs = keys.map(k => `${JSON.stringify(k)}:${canonicalJson(value[k])}`);
-    return '{' + pairs.join(',') + '}';
+        return '[' + value.map((v, i) => canonicalMember(value, String(i), v)).join(',') + ']';
+    if (typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record).filter(k => record[k] !== undefined).sort(compareCodePoints);
+        return '{' + keys.map(k => `${asciiString(k)}:${canonicalMember(record, k, record[k])}`).join(',') + '}';
+    }
+    throw new Error(`canonical JSON cannot encode a ${typeof value}`);
+}
+/** SHA-256 hex of a string's UTF-8 bytes. */
+function sha256Hex(text) {
+    return (0, node_crypto_1.createHash)('sha256').update(text, 'utf-8').digest('hex');
+}
+/** SHA-256 hex of a value's canonical JSON - every GM `digest()`. */
+function canonicalDigest(value) {
+    return sha256Hex(canonicalJson(value));
 }
 /**
  * PKCS8 DER prefix for an Ed25519 private key.
@@ -32,18 +137,81 @@ function canonicalJson(value) {
  * Concatenate with the 32-byte seed to form a valid PKCS8 DER buffer.
  */
 const ED25519_PKCS8_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex');
+/**
+ * SPKI DER prefix for an Ed25519 public key.
+ * Layout: SEQUENCE { SEQUENCE { OID 1.3.101.112 }, BIT STRING { <32-byte key> } }
+ */
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
 /** Sign raw bytes with an Ed25519 seed (32-byte base64-encoded private key seed). */
 function signBytes(message, seedBase64) {
     const seed = Buffer.from(seedBase64, 'base64');
+    if (seed.length !== 32)
+        throw new Error('Ed25519 seed must be 32 bytes');
     const pkcs8 = Buffer.concat([ED25519_PKCS8_PREFIX, seed]);
     const privateKey = (0, node_crypto_1.createPrivateKey)({ key: pkcs8, format: 'der', type: 'pkcs8' });
     return (0, node_crypto_1.sign)(null, message, privateKey);
 }
-/** Build the four admin auth headers for a given request body. */
-function buildAdminHeaders(body, keyId, signingKeyBase64) {
+/** Verify an Ed25519 signature (base64) with a raw 32-byte public key (base64). */
+function verifyBytes(message, signatureBase64, publicKeyBase64) {
+    const raw = Buffer.from(publicKeyBase64, 'base64');
+    const sig = Buffer.from(signatureBase64, 'base64');
+    if (raw.length !== 32 || sig.length !== 64)
+        return false;
+    const publicKey = (0, node_crypto_1.createPublicKey)({
+        key: Buffer.concat([ED25519_SPKI_PREFIX, raw]),
+        format: 'der',
+        type: 'spki',
+    });
+    return (0, node_crypto_1.verify)(null, message, publicKey, sig);
+}
+/** Raw 32-byte public key (base64) for an Ed25519 seed (base64). */
+function publicKeyFromSeed(seedBase64) {
+    const seed = Buffer.from(seedBase64, 'base64');
+    if (seed.length !== 32)
+        throw new Error('Ed25519 seed must be 32 bytes');
+    const privateKey = (0, node_crypto_1.createPrivateKey)({
+        key: Buffer.concat([ED25519_PKCS8_PREFIX, seed]),
+        format: 'der',
+        type: 'pkcs8',
+    });
+    const spki = (0, node_crypto_1.createPublicKey)(privateKey).export({ type: 'spki', format: 'der' });
+    return spki.subarray(ED25519_SPKI_PREFIX.length).toString('base64');
+}
+/** A Signer backed by a raw Ed25519 seed held in memory. */
+function seedSigner(seedBase64, keyId) {
+    return { keyId, sign: (message) => signBytes(message, seedBase64) };
+}
+/** Sign a canonical body with a Signer; returns the GM `{key_id, sig}` pair. */
+async function signCanonical(canonical, signer) {
+    const sig = await signer.sign(Buffer.from(canonical, 'utf-8'));
+    if (sig.length !== 64)
+        throw new Error('signer returned a signature that is not 64 bytes');
+    return { key_id: signer.keyId, sig: Buffer.from(sig).toString('base64') };
+}
+/** True when `sig` verifies the canonical body under any of the public keys. */
+function verifyCanonical(canonical, sig, publicKeys) {
+    const message = Buffer.from(canonical, 'utf-8');
+    return publicKeys.some(key => verifyBytes(message, sig, key));
+}
+/**
+ * A UTC timestamp in the form Pydantic re-serialises unchanged: microsecond
+ * precision, `Z` suffix, fraction omitted when zero. `toISOString()` output
+ * (`.561Z`) would come back as `.561000Z` and break a signature over it.
+ */
+function pythonTimestamp(date = new Date()) {
+    const iso = date.toISOString();
+    const ms = date.getUTCMilliseconds();
+    const base = iso.slice(0, 19);
+    return ms === 0 ? `${base}Z` : `${base}.${String(ms).padStart(3, '0')}000Z`;
+}
+function adminMessage(body, keyId) {
     const timestamp = new Date().toISOString();
     const nonce = (0, node_crypto_1.randomUUID)();
-    const canonical = canonicalJson({ body, key_id: keyId, nonce, timestamp });
+    return { canonical: canonicalJson({ body, key_id: keyId, nonce, timestamp }), timestamp, nonce };
+}
+/** Build the four admin auth headers for a given request body. */
+function buildAdminHeaders(body, keyId, signingKeyBase64) {
+    const { canonical, timestamp, nonce } = adminMessage(body, keyId);
     const sig = signBytes(Buffer.from(canonical, 'utf-8'), signingKeyBase64);
     return {
         'X-Admin-Key-Id': keyId,
@@ -52,3 +220,14 @@ function buildAdminHeaders(body, keyId, signingKeyBase64) {
         'X-Admin-Nonce': nonce,
     };
 }
+/** Build the four admin auth headers with a Signer (key id taken from the signer). */
+async function buildAdminHeadersWithSigner(body, signer) {
+    const { canonical, timestamp, nonce } = adminMessage(body, signer.keyId);
+    const { sig } = await signCanonical(canonical, signer);
+    return {
+        'X-Admin-Key-Id': signer.keyId,
+        'X-Admin-Signature': sig,
+        'X-Admin-Timestamp': timestamp,
+        'X-Admin-Nonce': nonce,
+    };
+}

package/dist/cjs/boundary.js

@@ -1,18 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BoundaryClient = void 0;
+const execution_js_1 = require("./execution.js");
 class BoundaryClient {
     http;
     constructor(http) {
         this.http = http;
     }
-    /** Issue a signed boundary decision for a capability request (admin). */
+    /**
+     * Legacy agreement-only decision without policy (admin). Refused with
+     * `boundary_policy_required` when the NA requires policy enforcement; use `evaluate`.
+     */
     decide(params) {
         return this.http.adminPost('/admin/boundary/decide', params);
     }
+    /**
+     * Policy-aware evaluation under exactly one basis - an `attestation_id` or an
+     * `agreement` (admin). Returns the signed decision and its justification proof.
+     * A denial is a signed decision with `authorized: false`, not an error.
+     */
+    async evaluate(params) {
+        if ((params.attestation_id !== undefined) === (params.agreement !== undefined)) {
+            throw new Error('exactly one of agreement or attestation_id is required');
+        }
+        const reason = (0, execution_js_1.checkMetadataOnly)({ ...params.context });
+        if (reason)
+            throw new execution_js_1.SecretMaterialError(reason);
+        return this.http.adminPost('/admin/boundary/evaluate', params);
+    }
     /** Verify a boundary decision signature (unauthenticated). */
     verify(params) {
-        return this.http.publicPost('/boundary/verify', params);
+        return this.http.publicPost('/boundary/verify', params, true);
     }
 }
 exports.BoundaryClient = BoundaryClient;

package/dist/cjs/canonical.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Canonical signed bodies and digests of GM protocol models, derived from
+ * their wire JSON exactly as the Python models' to_canonical_json() and
+ * digest() derive them. Pure functions; key operations live in auth.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_CHAIN_FIELDS = void 0;
+exports.decisionCanonical = decisionCanonical;
+exports.executionCanonical = executionCanonical;
+exports.executionDigest = executionDigest;
+exports.attestationCanonical = attestationCanonical;
+exports.attestationDigest = attestationDigest;
+exports.revocationFeedCanonical = revocationFeedCanonical;
+exports.policyCanonical = policyCanonical;
+exports.policyDigest = policyDigest;
+exports.policySetDigest = policySetDigest;
+exports.justificationCanonical = justificationCanonical;
+exports.freshnessProofCanonical = freshnessProofCanonical;
+exports.checkpointCanonical = checkpointCanonical;
+exports.entryDigest = entryDigest;
+exports.payloadDigest = payloadDigest;
+const auth_js_1 = require("./auth.js");
+/** v0.59 resource-chain fields, omitted from the execution canonical form when absent. */
+exports.RESOURCE_CHAIN_FIELDS = [
+    'resource_id',
+    'resource_action',
+    'resource_sequence',
+    'prev_resource_digest',
+];
+function without(model, always, whenNull = []) {
+    const out = {};
+    for (const [key, value] of Object.entries(model)) {
+        if (always.includes(key))
+            continue;
+        if (whenNull.includes(key) && (value === null || value === undefined))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function decisionCanonical(decision) {
+    return (0, auth_js_1.canonicalJson)(without(decision, ['signature'], ['policy_binding', 'attestation_binding']));
+}
+function executionCanonical(evidence) {
+    return (0, auth_js_1.canonicalJson)(without(evidence, ['signature'], exports.RESOURCE_CHAIN_FIELDS));
+}
+/** `ExecutionEvidence.digest()`: links the per-decision and per-resource chains. */
+function executionDigest(evidence) {
+    return (0, auth_js_1.canonicalDigest)(without(evidence, ['signature'], exports.RESOURCE_CHAIN_FIELDS));
+}
+function attestationCanonical(attestation) {
+    return (0, auth_js_1.canonicalJson)(without(attestation, ['signatures']));
+}
+/** `MembershipAttestation.digest()`: the value an AttestationBinding commits to. */
+function attestationDigest(attestation) {
+    return (0, auth_js_1.canonicalDigest)(without(attestation, ['signatures']));
+}
+function revocationFeedCanonical(feed) {
+    return (0, auth_js_1.canonicalJson)(without(feed, ['signatures']));
+}
+function policyCanonical(policy) {
+    return (0, auth_js_1.canonicalJson)(without(policy, ['signature']));
+}
+/** `BoundaryPolicy.digest()`. */
+function policyDigest(policy) {
+    return (0, auth_js_1.canonicalDigest)(without(policy, ['signature']));
+}
+/** Digest of the ordered applied-policy list carried in a PolicyBinding. */
+function policySetDigest(policies) {
+    return (0, auth_js_1.canonicalDigest)(policies.map(p => [p.policy_id, p.version, p.policy_digest]));
+}
+function justificationCanonical(proof) {
+    return (0, auth_js_1.canonicalJson)(without(proof, ['signature']));
+}
+function freshnessProofCanonical(proof) {
+    return (0, auth_js_1.canonicalJson)(without(proof, ['signature']));
+}
+function checkpointCanonical(checkpoint) {
+    return (0, auth_js_1.canonicalJson)(without(checkpoint, ['signature']));
+}
+/** `EvidenceStoreEntry.digest()`: every envelope field. */
+function entryDigest(entry) {
+    return (0, auth_js_1.canonicalDigest)(entry);
+}
+/** SHA-256 of a stored payload's canonical JSON. */
+function payloadDigest(payload) {
+    return (0, auth_js_1.canonicalDigest)(payload);
+}