@synoi/sraid 0.2.0 → 0.4.0

package/README.md

@@ -1,7 +1,11 @@
 # @synoi/sraid
 
-Reference TypeScript implementation of **SRAID (Self-Routing Addressable
-Identity Data)** — L0 of the SynOI SRAID Stack. MIT-licensed.
+Reference TypeScript implementation of **SRAID**, the SynOI content-addressed
+object format. MIT-licensed.
+
+SRAID is a name, not an acronym. It has been expanded two different ways in two
+different places; neither expansion added anything, so this package no longer
+expands it. What it does is below.
 
 SRAID defines:
 
@@ -9,24 +13,28 @@ SRAID defines:
 - a deterministic canonical object serializer used as input to hashing and signing,
 - a content-derived **OID** (`sha256:` followed by 64 hex chars) over the canonical bytes,
 - a hybrid **Ed25519 + ML-DSA-65** signature envelope,
-- an **L3 Merkle-DAG lineage** layer (`prev` edge + typed `links[]`), hashed into the OID so a head id commits its whole reachable history, and
-- a supersession record, the **SRO** (Supersession Record Object), that links a successor CDRO to its predecessor.
-
-The three legacy supersession mechanisms — the self-asserted `supersedes`
-string, the standalone SRO, and the `prev` edge — are unified by the lineage
-helpers (`lineageLinks`, `supersededOids`, `latestWins`). `latestWins` resolves
-a set of versions to its single head by following the identity-bound `prev`/
-`links` edges, giving a verifier a **latest-wins / monotone** rule instead of an
-unwitnessed pointer. Given the complete version set, `latestWins` will not name
-a superseded object as head; full rollback-replay resistance additionally
-requires that the superseding object cannot be withheld, which is a Resolver /
-transparency-log property (DESIGN, not yet deployed). The `set_complete` field
-on `LatestWinsResult` is the local signal that lets a caller detect an
-incomplete (potentially withheld) set.
-
-Higher layers — Vault/Resolver (L1), Inference Broker/Resonance (L2), GAP (L3)
-— are built on SRAID objects. This package is intentionally tiny and has no
-storage, no HTTP surface, and no governance logic.
+- a **Merkle-DAG lineage** layer (`prev` edge + typed `links[]`), hashed into the OID so a head id commits its whole reachable history.
+
+Supersession is expressed by two things, both identity-bound because
+`cdroContentCore` hashes them: the `prev`/`links[]` Merkle edges, and the legacy
+self-asserted `supersedes` string. `latestWins` resolves a version set to its
+single head by following the identity-bound edges, giving a verifier a
+**latest-wins / monotone** rule instead of an unwitnessed pointer. Given the
+complete version set it will not name a superseded object as head; full
+rollback-replay resistance additionally requires that the superseding object
+cannot be withheld, which is a Resolver / transparency-log property (DESIGN, not
+yet deployed). `set_complete` on `LatestWinsResult` is the local signal letting a
+caller detect an incomplete (potentially withheld) set.
+
+The standalone **SRO** was removed in 0.4.0 — see the CHANGELOG.
+
+This package is object identity: canonical bytes, OIDs, hybrid signature
+verification, lineage. It has no storage, no HTTP surface, and no policy.
+
+It verifies **signatures, not identities**: `signer_kid` is an opaque string this
+package never resolves, and nothing here checks revocation. Deciding whether a
+key was trusted at signing time needs a key directory, which is a caller
+concern.
 
 ## Install
 
@@ -39,63 +47,101 @@ npm install @synoi/sraid
 ```ts
 import {
   canonicalize,
-  oidOf,
-  verifySignature,
+  cdroOid,
+  cdroContentCore,
+  pae,
+  verifyAttestation,
   validateCdro,
+  type AttestationEnvelope,
   type CDRO,
-  type SignatureEnvelope,
 } from '@synoi/sraid'
 import { ed25519 } from '@noble/curves/ed25519'
 import { ml_dsa65 } from '@noble/post-quantum/ml-dsa.js'
 import { randomBytes } from 'node:crypto'
 
-// 1. Build a CDRO body and derive its OID.
-const body = { capability: 'door.unlock', risk_class: 'B' }
-const oid = oidOf(body)                          // sha256:<64 hex chars>
-
-const cdro: CDRO<typeof body> = {
-  oid,
+// 1. Build the CDRO content core: every field EXCEPT the detached
+//    envelope fields (oid, signature, attestation, ...).
+const core = {
   type: 'gap:capability_declaration',
-  sraid_version: '2.0',
+  sraid_version: '2.0' as const,
   tenant_id: 't-home',
   created_at_ms: Date.now(),
   created_by: 'actor:skill:demo',
-  body,
+  body: { capability: 'door.unlock', risk_class: 'B' },
 }
 
-console.log(validateCdro(cdro))                  // { ok: true, errors: [] }
+// 2. Identity is the hash of the WHOLE content core, not just the body.
+//    Use cdroOid(core) — NOT oidOf(core.body).
+const cdro: CDRO<typeof core.body> = { oid: cdroOid(core), ...core }
+
+console.log(validateCdro(cdro))            // { ok: true, errors: [] }
+console.log(cdro.oid === cdroOid(cdro))    // true
 
-// 2. Sign the canonical bytes with both Ed25519 and ML-DSA-65.
-const canonical = canonicalize(cdro.body)
-const message = new TextEncoder().encode(canonical)
+// 3. Sign the canonical content core through the DSSE PAE, which binds
+//    payloadType into the signed bytes (prevents cross-type replay).
+const payloadType = 'application/vnd.synoi.sraid+json'
+const payload = canonicalize(cdroContentCore(cdro))
+const signedBytes = pae(payloadType, payload)
 
 const edPriv = new Uint8Array(randomBytes(32))
 const edPub = ed25519.getPublicKey(edPriv)
 const mlKeys = ml_dsa65.keygen(new Uint8Array(randomBytes(32)))
 
-const envelope: SignatureEnvelope = {
-  ed25519: Buffer.from(ed25519.sign(message, edPriv)).toString('base64'),
-  ml_dsa_65: Buffer.from(ml_dsa65.sign(message, mlKeys.secretKey)).toString('base64'),
-  signer_kid: 'synoi-demo-2026-05',
+const attestation: AttestationEnvelope = {
+  payloadType,
+  payload,
+  signatures: [
+    {
+      alg: 'ed25519',
+      sig: Buffer.from(ed25519.sign(signedBytes, edPriv)).toString('base64'),
+      keyid: 'synoi-demo-2026-05',
+    },
+    {
+      alg: 'ml-dsa-65',
+      sig: Buffer.from(ml_dsa65.sign(signedBytes, mlKeys.secretKey)).toString('base64'),
+      keyid: 'synoi-demo-2026-05',
+    },
+  ],
 }
 
-// 3. Verify.
-const v = verifySignature({
-  canonical,
-  envelope,
+// 4. Attaching the attestation does NOT change identity — the six detached
+//    envelope fields are stripped before hashing.
+const attested = { ...cdro, attestation }
+console.log(cdroOid(attested) === cdro.oid) // true
+
+// 5. Verify. `valid` is true only when BOTH signatures verify over the PAE.
+const v = verifyAttestation({
+  envelope: attestation,
   ed25519_pub: edPub,
   ml_dsa_pub: mlKeys.publicKey,
+  expectedPayloadType: payloadType,
 })
-console.log(v)                                   // { valid: true, reasons: [] }
+console.log(v)                             // { valid: true, reasons: [] }
 ```
 
+> **Identity is over the content core, not the body.** `oidOf(cdro.body)` is
+> *not* a CDRO's OID; use `cdroOid`. `verifySignature` / `SignatureEnvelope`
+> (bare-bytes, no payload-type binding) remain exported for compatibility but
+> are superseded by the attestation path above.
+
 ## Surface
 
 ```ts
 canonicalize(value: unknown): string
+
+// CDRO identity — hash the content core. THIS is an object's OID.
+cdroOid(cdro: unknown): string
+cdroContentCore(cdro: unknown): Record<string, unknown>
+CDRO_ENVELOPE_FIELDS: readonly string[]   // the six stripped fields
+
+// Value-level hashing. oidOf(cdro.body) is NOT the CDRO's OID.
 oidOf(canonical: unknown): string
 oidOfCanonical(canonical: string | Uint8Array): string
 
+// DSSE attestation — payload-type bound, both signatures required.
+verifyAttestation(input): { valid: boolean; reasons: string[] }
+pae(payloadType: string, payload: string | Uint8Array): Uint8Array
+
 verifySignature(args: {
   canonical:   string | Uint8Array
   envelope:    SignatureEnvelope
@@ -109,13 +155,69 @@ validateSignatureEnvelope(x: unknown): { ok: boolean; errors: string[] }
 
 // Types
 interface CDRO<TBody>            { /* envelope */ }
-interface SRO                    { /* supersession record */ }
 interface SignatureEnvelope      { ed25519: string; ml_dsa_65: string; signer_kid: string }
 ```
 
+## Browser, Chrome extension, service worker
+
+The default (`.`) entry statically imports `node:crypto` in three places
+(`ed25519.ts`, `mldsa.ts`, `oid.ts`), so `import '@synoi/sraid'` breaks any
+browser bundle. Import the `./verify-browser` subpath instead. It carries exactly
+what a v2 hybrid DSSE receipt verifier needs, with no static `node:crypto`
+anywhere in its graph.
+
+```ts
+import { verifyAttestation, canonicalize, cdroContentCore } from '@synoi/sraid/verify-browser'
+
+const v = await verifyAttestation({
+  envelope:            receipt.attestation,
+  ed25519_pub,                                   // raw 32 bytes
+  ml_dsa_pub,                                    // raw 1952 bytes
+  expectedPayloadType: 'application/vnd.synoi.gap+json',
+})
+// { valid: true, reasons: [] } only when BOTH signatures verify over the PAE
+```
+
+```ts
+// The subpath surface. Four of these are ASYNC where the node entry is sync,
+// because WebCrypto is Promise-based. Everything else is shared byte-for-byte
+// with the node entry, so the two agree on the same input.
+verifyAttestation(input): Promise<{ valid: boolean; reasons: string[] }>   // ASYNC
+cdroOid(cdro: unknown): Promise<string>                                    // ASYNC
+oidOf(canonical: unknown): Promise<string>                                 // ASYNC
+oidOfCanonical(canonical: string | Uint8Array): Promise<string>            // ASYNC
+
+canonicalize(value: unknown): string          // pure, identical to the node entry
+cdroContentCore(cdro: unknown): Record<string, unknown>
+pae(payloadType: string, payload: string | Uint8Array): Uint8Array
+CDRO_ENVELOPE_FIELDS: readonly string[]
+ALG_ED25519, ALG_ML_DSA_65
+```
+
+Crypto backends, since browsers have no native ML-DSA and no `node:crypto`:
+Ed25519 verify on WebCrypto (RFC 8032 cofactored, matching the node path) with a
+`@noble/curves` fallback below the WebCrypto-Ed25519 support floor; ML-DSA-65
+verify on `@noble/post-quantum`; SHA-256 on WebCrypto `subtle.digest`.
+
+The node default entry is unchanged and keeps its synchronous `node:crypto` fast
+paths. This subpath is purely additive. Added in 0.3.0; earlier versions export
+only `.` and `./canonicalize`.
+
+## Authority verification
+
+Capability-grant and delegation-chain verification is NOT in this package. It is
+authorization policy, not object identity, and it moved to
+[`@synoi/authority-verify`](https://github.com/synoi/synoi-authority-verify) in
+0.4.0.
+
+`capabilityCovers`, `AuthorityResolver` and `GrantStatus` did NOT move - they are
+a pure string predicate and a live-status contract, and remain in the surface
+above.
+
 ## Canonical form
 
-The canonical form is recursive JCS-lite JSON:
+The canonical form is a strict RFC 8785 (JCS) profile, tested against the
+RFC 8785 vectors (`test/rfc8785-conformance.test.ts`):
 
 - primitives via `JSON.stringify`,
 - objects emit keys in lexicographic order,
@@ -125,7 +227,7 @@ The canonical form is recursive JCS-lite JSON:
 
 This canonical form is a wire contract. **Any byte-level change to the
 serializer changes every OID and invalidates every previously-created
-signature.** Treat it as frozen for SRAID v1.0; evolve it only via a new,
+signature.** Treat it as frozen for SRAID v2.0; evolve it only via a new,
 explicitly versioned canonical profile.
 
 ## OID format
@@ -134,8 +236,12 @@ explicitly versioned canonical profile.
 OID = "sha256:" + lowercase_hex( sha256( canonicalize(content) ) )
 ```
 
-The hash input is the OBJECT MINUS its own `oid` and `signature` fields, so
-signature rotation does not change the OID.
+The hash input is the object MINUS the six detached envelope fields
+(`oid`, `signature`, `ml_dsa_signature`, `signature_key_id`,
+`signature_algorithm`, `attestation`) — see `CDRO_ENVELOPE_FIELDS`. Everything
+else is hashed, including `authority`, `sensitivity`, `prev`, `links` and
+`supersedes`, so those are identity-bound and cannot be silently stripped.
+Signing or rotating a signature never changes the OID.
 
 ## Why hybrid signatures
 
@@ -146,4 +252,4 @@ in this package returns `valid: true` only when BOTH succeed.
 
 ## License
 
-MIT — see [`LICENSE`](./LICENSE).
+MIT, see [`LICENSE`](./LICENSE).

package/SPEC.md

@@ -1,4 +1,4 @@
-# SRAID - Self-Routing Addressable Identity Data, Core Object Specification
+# SRAID - Core Object Specification
 
 **Core Specification, Version 1.0**
 
@@ -38,7 +38,7 @@ A SRAID object (the Canonical Data Record Object, or **CDRO**) is a map with the
 
 The `oid`, `attestation`, and `signature` members are excluded from the OID input (Section 4) so that the same content produces the same OID and re-signing never changes identity. All other members are part of the canonical content and therefore contribute to the OID.
 
-**Lineage fields are independent.** An object MAY carry `supersedes`, `prev`, and one or more `links[]` simultaneously. `supersedes` asserts a version-replacement relationship (this object is the authoritative successor of the referenced OID); `prev` is the hash-chain backpointer for ordered append; `links[]` are typed semantic edges (L3). Each is validated for canonical-OID format in isolation. The validator does NOT enforce agreement among them (for example it does not require `supersedes === prev`), nor does it resolve or fetch the referenced objects. Higher layers (Vault/Resolver, GAP) are responsible for any cross-field lineage semantics. The signed supersession receipt (SRO, type `sraid:sro`) is distinct from the self-asserted `supersedes` field on a CDRO: the SRO is an independently signed object authored by a governing actor; `supersedes` is a producer-asserted claim inside the envelope. Both fields are format-validated but neither implies the other.
+**Lineage fields are independent.** An object MAY carry `supersedes`, `prev`, and one or more `links[]` simultaneously. `supersedes` asserts a version-replacement relationship (this object is the authoritative successor of the referenced OID); `prev` is the hash-chain backpointer for ordered append; `links[]` are typed semantic edges (L3). Each is validated for canonical-OID format in isolation. The validator does NOT enforce agreement among them (for example it does not require `supersedes === prev`), nor does it resolve or fetch the referenced objects. Higher layers (Vault/Resolver, GAP) are responsible for any cross-field lineage semantics. The standalone supersession receipt (SRO, type `sraid:sro`) was REMOVED in 0.4.0: nothing in any language consumed it, `lineage.ts` never handled it, and the canon had already retired the term (ADR_022 section 0). A caller recording WHY something was superseded should put that in the successor's own `body`, where it is hashed and signed.
 
 ## 3. Canonical form
 

package/dist/attestation.d.ts

@@ -30,57 +30,16 @@
  * Identity stability: signatures live in a detached `signatures[]` array and
  * are NEVER part of the OID hash input (see `cdroContentCore` in oid.ts), so
  * adding, rotating, or replacing a signature never changes the object's OID.
- */
-import type { AttestationEnvelope } from './types.js';
-/** The single supported algorithm identifiers for the JSON profile. */
-export declare const ALG_ED25519 = "ed25519";
-export declare const ALG_ML_DSA_65 = "ml-dsa-65";
-/**
- * The DSSE Pre-Authentication Encoding (PAE).
- *
- * Per the DSSE spec:
- *
- *   PAE(type, body) = "DSSEv1" SP LEN(type) SP type SP LEN(body) SP body
- *
- * where:
- *   - SP is a single ASCII space (0x20),
- *   - LEN(x) is the ASCII-decimal byte length of x's UTF-8 encoding,
- *   - type and body are the raw UTF-8 bytes (NOT base64).
  *
- * Binding the payloadType (and both lengths) into the signed bytes is what
- * makes a signature non-transferable across object types. Returns the raw
- * bytes to be signed/verified.
+ * NODE ENTRY: this module verifies via node:crypto (Ed25519 native, ML-DSA-65
+ * native-with-@noble-fallback) and is SYNCHRONOUS. The PAE, algorithm ids,
+ * types, AND-policy lookup, and envelope-shape predicate are shared with the
+ * browser verify surface via ./internal/attestation-core.ts (pure, no
+ * node:crypto); only the verify orchestration below is node-specific. The
+ * browser-safe async equivalent lives in ./verify-browser.ts.
  */
-export declare function pae(payloadType: string, payload: string | Uint8Array): Uint8Array;
-export interface VerifyAttestationInput {
-    /**
-     * The DSSE attestation envelope to verify. Its `payloadType` is bound into
-     * the PAE; its `payload` is the canonical UTF-8 string that was signed.
-     */
-    envelope: AttestationEnvelope;
-    /** Raw 32-byte Ed25519 public key. */
-    ed25519_pub: Uint8Array;
-    /** Raw ML-DSA-65 public key bytes. */
-    ml_dsa_pub: Uint8Array;
-    /**
-     * Optional. If supplied, the verifier asserts the envelope's `payloadType`
-     * equals this value before verifying signatures — an explicit type-pinning
-     * check on top of the structural PAE binding. A mismatch fails with
-     * `payload-type-mismatch`.
-     */
-    expectedPayloadType?: string;
-}
-export interface VerifyAttestationResult {
-    /** True only when BOTH required signatures verified over the same PAE. */
-    valid: boolean;
-    /**
-     * Human-readable failure reasons. Empty when valid. Possible values:
-     * 'envelope-malformed', 'payload-type-mismatch', 'missing-ed25519',
-     * 'missing-ml-dsa-65', 'ed25519-malformed', 'ml-dsa-malformed',
-     * 'ed25519-invalid', 'ml-dsa-invalid'.
-     */
-    reasons: string[];
-}
+import { ALG_ED25519, ALG_ML_DSA_65, pae, type VerifyAttestationInput, type VerifyAttestationResult } from './internal/attestation-core.js';
+export { ALG_ED25519, ALG_ML_DSA_65, pae, type VerifyAttestationInput, type VerifyAttestationResult, };
 /**
  * Verify a hybrid DSSE attestation envelope. Returns `valid: true` only when
  * the envelope carries BOTH an `ed25519` and an `ml-dsa-65` signature and

package/dist/attestation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attestation.d.ts","sourceRoot":"","sources":["../src/attestation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,OAAO,KAAK,EAAE,mBAAmB,EAAwB,MAAM,YAAY,CAAA;AAE3E,uEAAuE;AACvE,eAAO,MAAM,WAAW,YAAY,CAAA;AACpC,eAAO,MAAM,aAAa,cAAc,CAAA;AAExC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAYjF;AAED,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,sCAAsC;IACtC,WAAW,EAAE,UAAU,CAAA;IACvB,sCAAsC;IACtC,UAAU,EAAE,UAAU,CAAA;IACtB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,0EAA0E;IAC1E,KAAK,EAAE,OAAO,CAAA;IACd;;;;;OAKG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,CAsExF"}
+{"version":3,"file":"attestation.d.ts","sourceRoot":"","sources":["../src/attestation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAKH,OAAO,EACL,WAAW,EACX,aAAa,EAGb,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC7B,MAAM,gCAAgC,CAAA;AAIvC,OAAO,EACL,WAAW,EACX,aAAa,EACb,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,CA+DxF"}

package/dist/attestation.js

@@ -30,39 +30,21 @@
  * Identity stability: signatures live in a detached `signatures[]` array and
  * are NEVER part of the OID hash input (see `cdroContentCore` in oid.ts), so
  * adding, rotating, or replacing a signature never changes the object's OID.
+ *
+ * NODE ENTRY: this module verifies via node:crypto (Ed25519 native, ML-DSA-65
+ * native-with-@noble-fallback) and is SYNCHRONOUS. The PAE, algorithm ids,
+ * types, AND-policy lookup, and envelope-shape predicate are shared with the
+ * browser verify surface via ./internal/attestation-core.ts (pure, no
+ * node:crypto); only the verify orchestration below is node-specific. The
+ * browser-safe async equivalent lives in ./verify-browser.ts.
  */
 import { verifyEd25519 } from './ed25519.js';
 import { decodeBase64Strict } from './internal/base64.js';
 import { verifyMlDsa65 } from './mldsa.js';
-/** The single supported algorithm identifiers for the JSON profile. */
-export const ALG_ED25519 = 'ed25519';
-export const ALG_ML_DSA_65 = 'ml-dsa-65';
-/**
- * The DSSE Pre-Authentication Encoding (PAE).
- *
- * Per the DSSE spec:
- *
- *   PAE(type, body) = "DSSEv1" SP LEN(type) SP type SP LEN(body) SP body
- *
- * where:
- *   - SP is a single ASCII space (0x20),
- *   - LEN(x) is the ASCII-decimal byte length of x's UTF-8 encoding,
- *   - type and body are the raw UTF-8 bytes (NOT base64).
- *
- * Binding the payloadType (and both lengths) into the signed bytes is what
- * makes a signature non-transferable across object types. Returns the raw
- * bytes to be signed/verified.
- */
-export function pae(payloadType, payload) {
-    const enc = new TextEncoder();
-    const typeBytes = enc.encode(payloadType);
-    const bodyBytes = typeof payload === 'string' ? enc.encode(payload) : payload;
-    const prefix = enc.encode(`DSSEv1 ${typeBytes.length} ${payloadType} ${bodyBytes.length} `);
-    const out = new Uint8Array(prefix.length + bodyBytes.length);
-    out.set(prefix, 0);
-    out.set(bodyBytes, prefix.length);
-    return out;
-}
+import { ALG_ED25519, ALG_ML_DSA_65, findSig, isWellFormedEnvelope, pae, } from './internal/attestation-core.js';
+// Re-export the crypto-agnostic core so the public surface is unchanged:
+// `import { pae, ALG_ED25519, ALG_ML_DSA_65 } from '@synoi/sraid'` still works.
+export { ALG_ED25519, ALG_ML_DSA_65, pae, };
 /**
  * Verify a hybrid DSSE attestation envelope. Returns `valid: true` only when
  * the envelope carries BOTH an `ed25519` and an `ml-dsa-65` signature and
@@ -73,12 +55,7 @@ export function pae(payloadType, payload) {
 export function verifyAttestation(input) {
     const reasons = [];
     const env = input.envelope;
-    if (env === null ||
-        typeof env !== 'object' ||
-        typeof env.payloadType !== 'string' ||
-        env.payloadType.length === 0 ||
-        typeof env.payload !== 'string' ||
-        !Array.isArray(env.signatures)) {
+    if (!isWellFormedEnvelope(env)) {
         return { valid: false, reasons: ['envelope-malformed'] };
     }
     if (input.expectedPayloadType !== undefined &&
@@ -137,18 +114,10 @@ export function verifyAttestation(input) {
     return { valid: edOk && mlOk && !!edEntry && !!mlEntry, reasons };
 }
 // ── Helpers ───────────────────────────────────────────────────────────────────
-function findSig(sigs, alg) {
-    for (const s of sigs) {
-        if (s && typeof s === 'object' && s.alg === alg && typeof s.sig === 'string') {
-            return s;
-        }
-    }
-    return undefined;
-}
 // Strict standard base64. Throws Error('base64-malformed') on any deviation
-// (illegal char, bad length, bad padding) rather than silently truncating.
-// Both call sites wrap this in try/catch and map the throw to a *-malformed
-// reason, so verifyAttestation never throws.
+// (illegal char, bad length, bad padding) rather than silently truncating. The
+// call sites wrap this in try/catch and map the throw to a *-malformed reason,
+// so verifyAttestation never throws.
 function fromBase64(s) {
     return decodeBase64Strict(s);
 }

package/dist/attestation.js.map

@@ -1 +1 @@
-{"version":3,"file":"attestation.js","sourceRoot":"","sources":["../src/attestation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"attestation.js","sourceRoot":"","sources":["../src/attestation.ts"],"names":[],"mappings":"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"}

package/dist/capability.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @synoi/sraid — capability.ts
+ *
+ * Capability-pattern matching and the live-status contract.
+ *
+ * These stay in the core entry, while the grant/delegation VERIFIERS moved to
+ * `@synoi/sraid/authority` in 0.4.0, because they are different things:
+ *
+ *   - `capabilityCovers` is a pure, total string predicate with no crypto, no
+ *     I/O and no policy. It decides whether one dotted-taxonomy pattern covers
+ *     another, and it is the leaf primitive that grant stores build on
+ *     (synoi-app's `in-memory-engine.ts` and `app-store/store.ts` both call it
+ *     directly rather than going through a verifier).
+ *   - `GrantStatus` / `AuthorityResolver` are the CONTRACT for live grant
+ *     state. The contract is a type; satisfying it is somebody else's job.
+ *     Keeping it here lets a store, a resolver and a verifier agree on shape
+ *     without any of them depending on the verifier.
+ *
+ * Nothing in this module makes, or can make, a live claim.
+ */
+/**
+ * Match a capability `target` against a grant `pattern`. Pure string logic,
+ * re-stated here so the core stays dependency-free (the same rule lives in
+ * `@synoi/gap-types` `capabilityMatches`; the object layer must not depend on
+ * the protocol layer).
+ *
+ *   - exact match → true
+ *   - '*' → match-all
+ *   - 'skill.*' matches 'skill.create' and deeper (segment-boundary only).
+ *     A non-boundary 'admin.us*' must NOT match 'admin.users.delete'
+ *     (privilege-escalation footgun) — only a '.'-anchored '*' is a wildcard.
+ */
+export declare function capabilityCovers(pattern: string, target: string): boolean;
+/**
+ * The live-state interface that the OID Resolver implements. It is the ONLY
+ * source of truth for the two properties that cannot be checked offline:
+ * whether a grant currently exists (resolves) and whether it has been revoked.
+ *
+ * RESOLVER-DEPENDENT: undeployed today (SRAID_FOUNDATION_PUNCHLIST C). Defined
+ * here so callers, a future resolver, and the out-of-core verifier all agree
+ * on one contract.
+ */
+export interface AuthorityResolver {
+    /**
+     * Resolve a grant OID to its current status. Implementations should return
+     * `{ exists: false }` for an unknown OID and `{ exists: true, revoked: true,
+     * revoked_at_ms }` for a revoked one.
+     */
+    resolveGrantStatus(grantOid: string): Promise<GrantStatus> | GrantStatus;
+}
+export interface GrantStatus {
+    /** Whether the grant OID resolves to a known, published grant. */
+    exists: boolean;
+    /** Whether the grant has been revoked. Only meaningful when `exists`. */
+    revoked?: boolean;
+    /** When the revocation took effect, if revoked. */
+    revoked_at_ms?: number;
+}
+//# sourceMappingURL=capability.d.ts.map

package/dist/capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../src/capability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAQzE;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAA;CACzE;AAED,MAAM,WAAW,WAAW;IAC1B,kEAAkE;IAClE,MAAM,EAAE,OAAO,CAAA;IACf,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,mDAAmD;IACnD,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB"}

package/dist/capability.js

@@ -0,0 +1,44 @@
+/**
+ * @synoi/sraid — capability.ts
+ *
+ * Capability-pattern matching and the live-status contract.
+ *
+ * These stay in the core entry, while the grant/delegation VERIFIERS moved to
+ * `@synoi/sraid/authority` in 0.4.0, because they are different things:
+ *
+ *   - `capabilityCovers` is a pure, total string predicate with no crypto, no
+ *     I/O and no policy. It decides whether one dotted-taxonomy pattern covers
+ *     another, and it is the leaf primitive that grant stores build on
+ *     (synoi-app's `in-memory-engine.ts` and `app-store/store.ts` both call it
+ *     directly rather than going through a verifier).
+ *   - `GrantStatus` / `AuthorityResolver` are the CONTRACT for live grant
+ *     state. The contract is a type; satisfying it is somebody else's job.
+ *     Keeping it here lets a store, a resolver and a verifier agree on shape
+ *     without any of them depending on the verifier.
+ *
+ * Nothing in this module makes, or can make, a live claim.
+ */
+/**
+ * Match a capability `target` against a grant `pattern`. Pure string logic,
+ * re-stated here so the core stays dependency-free (the same rule lives in
+ * `@synoi/gap-types` `capabilityMatches`; the object layer must not depend on
+ * the protocol layer).
+ *
+ *   - exact match → true
+ *   - '*' → match-all
+ *   - 'skill.*' matches 'skill.create' and deeper (segment-boundary only).
+ *     A non-boundary 'admin.us*' must NOT match 'admin.users.delete'
+ *     (privilege-escalation footgun) — only a '.'-anchored '*' is a wildcard.
+ */
+export function capabilityCovers(pattern, target) {
+    if (pattern === target)
+        return true;
+    if (pattern === '*')
+        return true;
+    if (pattern.endsWith('.*')) {
+        const prefix = pattern.slice(0, -1); // keep trailing '.', e.g. 'skill.'
+        return target.startsWith(prefix);
+    }
+    return false;
+}
+//# sourceMappingURL=capability.js.map

package/dist/capability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.js","sourceRoot":"","sources":["../src/capability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe,EAAE,MAAc;IAC9D,IAAI,OAAO,KAAK,MAAM;QAAE,OAAO,IAAI,CAAA;IACnC,IAAI,OAAO,KAAK,GAAG;QAAE,OAAO,IAAI,CAAA;IAChC,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA,CAAC,mCAAmC;QACvE,OAAO,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;IAClC,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/index.d.ts

@@ -1,19 +1,19 @@
 /**
  * @synoi/sraid — public surface.
  *
- * SRAID (Self-Routing Addressable Identity Data) is L0 of the SynOI SRAID Stack:
+ * SRAID is the object-identity layer: it defines what a signed object IS and
+ * how anyone re-derives and verifies its identity offline.
  *
- *   L0 SRAID            ← this package
- *   L1 Vault / Resolver
- *   L2 Inference Broker / Resonance
- *   L3 GAP (Governed Action Protocol)
- *   L4 Apps
+ * Scope, precisely:
+ *   IN   canonical serializer, OID computation, hybrid Ed25519 + ML-DSA-65
+ *        attestation verification, lineage resolution, shape validators.
+ *   OUT  storage, transport, key resolution, revocation, policy, enforcement.
  *
- * This package is intentionally small: types, canonical serializer,
- * OID computation, hybrid signature verification, and shape validators.
- * No storage, no HTTP, no governance — those are higher layers.
+ * It verifies SIGNATURES, not IDENTITIES: `signer_kid` is an opaque string
+ * this package never resolves, and nothing here checks revocation. Deciding
+ * whether a key was trusted at signing time is a caller/directory concern.
  */
-export type { AttestationEnvelope, AttestationSignature, AuthorityBlock, AuthorityDecision, CDRO, LineageLink, LinkRel, SRO, SROBody, SensitivityTier, SignatureEnvelope, } from './types.js';
+export type { AttestationEnvelope, AttestationSignature, AuthorityBlock, AuthorityDecision, CDRO, LineageLink, LinkRel, SensitivityTier, SignatureEnvelope, } from './types.js';
 export { canonicalize } from './canonicalize.js';
 export { oidOf, oidOfCanonical, cdroOid, cdroContentCore, CDRO_ENVELOPE_FIELDS } from './oid.js';
 export { verifySignature, type VerifySignatureInput, type VerifySignatureResult, } from './signature.js';
@@ -22,7 +22,7 @@ export { evictKeyFromCaches } from './internal/key-cache.js';
 export { verifyAttestation, pae, ALG_ED25519, ALG_ML_DSA_65, type VerifyAttestationInput, type VerifyAttestationResult, } from './attestation.js';
 export { lineageLinks, supersededOids, latestWins, type LatestWinsResult, } from './lineage.js';
 export { SENSITIVITY_TIERS, SENSITIVITY_DEFAULT, isSensitivityTier, sensitivityRank, sensitivityMax, sensitivityCarryForward, sensitivityMonotoneCheck, } from './sensitivity.js';
-export { verifyAuthority, capabilityCovers, type VerifyAuthorityInput, type VerifyAuthorityResult, type AuthorityResolver, type GrantStatus, type GrantBodyShape, } from './authority.js';
-export { verifyDelegationChain, MAX_DELEGATION_DEPTH, type VerifyDelegationChainInput, type VerifyDelegationChainResult, type HopResult, type LinkPubkeys, } from './authority.js';
-export { validateCdro, validateSro, validateSignatureEnvelope, validateAttestationEnvelope, validateAuthorityBlock, validateLineageLink, type ValidationResult, } from './validate.js';
+export { capabilityCovers } from './capability.js';
+export type { AuthorityResolver, GrantStatus } from './capability.js';
+export { validateCdro, validateSignatureEnvelope, validateAttestationEnvelope, validateAuthorityBlock, validateLineageLink, type ValidationResult, } from './validate.js';
 //# sourceMappingURL=index.d.ts.map