@metalabel/dfos-protocol 0.52.1 → 0.54.0

package/dist/credentials/index.d.ts

@@ -1,4 +1,4 @@
-export { b as Attenuation, e as CredentialVerificationError, D as DFOSCredentialPayload, i as MAX_CREDENTIAL_SIZE, R as ResolvedIdentity, r as RevocationChecker, V as VerifiedDFOSCredential, w as VerifiedDelegationChain, z as createDFOSCredential, B as decodeDFOSCredentialUnsafe, E as isAttenuated, F as matchesResource, H as verifyDFOSCredential, J as verifyDelegationChain } from '../dfos-credential-j-kHtFvG.js';
+export { b as Attenuation, e as CredentialVerificationError, D as DFOSCredentialPayload, i as MAX_CREDENTIAL_SIZE, R as ResolvedIdentity, r as RevocationChecker, V as VerifiedDFOSCredential, w as VerifiedDelegationChain, z as apiResourceCovers, B as createDFOSCredential, E as decodeDFOSCredentialUnsafe, F as isAttenuated, G as matchesResource, H as parseApiResource, K as verifyDFOSCredential, L as verifyDelegationChain } from '../dfos-credential-DgT8XVTm.js';
 import 'zod';
 
 /**
@@ -27,6 +27,11 @@ declare const IDENTITY_PROOF_JWS_TYP = "did:dfos:identity-proof";
 declare const EMPTY_BODY_SHA256 = "47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU";
 /** Size cap on the serialized proof token, checked BEFORE any decode. */
 declare const MAX_REQUEST_PROOF_SIZE = 4096;
+/**
+ * Cap on the `jti` member, in UTF-8 bytes. There is no floor: uniqueness is the
+ * member's job, and a verifier's replay cache is what enforces it.
+ */
+declare const MAX_JTI_BYTES = 256;
 /** RECOMMENDED acceptance window `W` — how old a proof may be, in seconds. */
 declare const DEFAULT_PROOF_WINDOW_SECONDS = 60;
 /** RECOMMENDED clock-skew allowance `S` — how forward-dated a proof may be. */
@@ -64,6 +69,11 @@ interface RequestProofPayload {
     credentialCID: string;
     /** Issued-at — unix seconds (positive integer). */
     iat: number;
+    /**
+     * The registered additive member: a per-request unique value, at most
+     * `MAX_JTI_BYTES` UTF-8 bytes. Emitted after `iat`, in the additive block.
+     */
+    jti?: string;
 }
 /**
  * The identity proof's payload: the request proof's five members MINUS
@@ -81,6 +91,11 @@ interface IdentityProofPayload {
     bodyHash: string;
     /** Issued-at — unix seconds (positive integer). */
     iat: number;
+    /**
+     * The registered additive member: a per-request unique value, at most
+     * `MAX_JTI_BYTES` UTF-8 bytes. Emitted after `iat`, in the additive block.
+     */
+    jti?: string;
 }
 /**
  * ADDITIVE MEMBERS, appended AFTER the canonical order.
@@ -108,7 +123,15 @@ interface ParsedProofPayload {
     bodyHash: string;
     credentialCID?: string;
     iat: number;
+    /** The registered additive member, when the proof carries one. */
+    jti?: string;
 }
+/**
+ * Mint a `jti`: 128 bits from the platform CSPRNG, unpadded base64url (22
+ * characters). Uniqueness is per (presenter DID, freshness window), which this
+ * much randomness makes a collision no deployment will observe.
+ */
+declare const generateJti: () => string;
 /**
  * Validate and normalize additive members into their canonical emission order:
  * lexicographic by name, after every canonical member. Returns `[]` for the
@@ -171,10 +194,17 @@ interface SignApiRequestInput {
     sign: (message: Uint8Array) => Promise<Uint8Array>;
     /** Issued-at override — unix seconds. Default `Math.floor(Date.now() / 1000)`. */
     iat?: number;
+    /**
+     * The registered additive member, per-request unique and at most
+     * `MAX_JTI_BYTES` bytes — required by a deployment that gates WRITES with this
+     * envelope (INTEGRATIONS.md, API security notes). `generateJti()` mints one.
+     * It emits the same bytes as `extraMembers: { jti }`, and naming it both ways
+     * throws.
+     */
+    jti?: string;
     /**
      * ADDITIVE members, appended after the canonical order in lexicographic name
-     * order. `{ jti }` is the registered one — required by a deployment that gates
-     * WRITES with this envelope (INTEGRATIONS.md, API security notes).
+     * order. `{ jti }` is the registered one, and has the typed field above.
      */
     extraMembers?: ProofExtraMembers;
 }
@@ -209,10 +239,17 @@ interface SignApiIdentityRequestInput {
     sign: (message: Uint8Array) => Promise<Uint8Array>;
     /** Issued-at override — unix seconds. Default `Math.floor(Date.now() / 1000)`. */
     iat?: number;
+    /**
+     * The registered additive member, per-request unique and at most
+     * `MAX_JTI_BYTES` bytes. A WRITE-SHAPED surface — relay ingestion, blob
+     * upload — REQUIRES it (INTEGRATIONS.md, API security notes). `generateJti()`
+     * mints one. It emits the same bytes as `extraMembers: { jti }`, and naming it
+     * both ways throws.
+     */
+    jti?: string;
     /**
      * ADDITIVE members, appended after the canonical order in lexicographic name
-     * order. `{ jti }` is the registered one, and a WRITE-SHAPED surface — relay
-     * ingestion, blob upload — REQUIRES it (INTEGRATIONS.md, API security notes).
+     * order. `{ jti }` is the registered one, and has the typed field above.
      */
     extraMembers?: ProofExtraMembers;
 }
@@ -261,13 +298,21 @@ declare const buildApiIdentityHeaders: (input: {
  * The verdict class. Branch on `reason`, never on message text.
  *
  * - `invalid` — checked and failed.
+ * - `replayed` — checked, VALID, and already spent: this `jti` was seen inside
+ *   the proof's own freshness window. Its own verdict rather than an `invalid`
+ *   one because the caller's answer differs — re-read state, do not re-sign the
+ *   same request.
+ * - `uncovered` — the credential is VALID and simply does not reach this route's
+ *   resource and action. Distinct from `invalid` because nothing is wrong with
+ *   the artifact: a route offering optional authentication serves its anonymous
+ *   projection on an `uncovered` verdict, and still refuses an `invalid` one.
  * - `unverifiable` — could not check (an unresolvable presenter, an unreachable
  *   revocation source). A transient resolution failure is the server's
  *   condition, not the caller's.
  * - `config` — the DEPLOYMENT is misconfigured (a `W + S` over the 300-second
  *   ceiling, or an empty required action). Not a judgment about the artifact.
  */
-type RequestProofFailureReason = 'invalid' | 'unverifiable' | 'config';
+type RequestProofFailureReason = 'invalid' | 'replayed' | 'uncovered' | 'unverifiable' | 'config';
 /**
  * The verification phase a failure arose in. Load-bearing for HTTP mapping: an
  * `invalid` proof-layer failure is a 401 (with a `WWW-Authenticate: DFOS`
@@ -279,12 +324,26 @@ type RequestProofFailurePhase = 'proof' | 'credential' | 'config';
 declare class ApiRequestVerifyError extends Error {
     readonly reason: RequestProofFailureReason;
     readonly phase: RequestProofFailurePhase;
-    /** Recommended HTTP status: 401 proof-invalid, 403 credential-invalid, 503 unverifiable, 500 config. */
+    /** Recommended HTTP status: 401 proof-invalid, 403 credential-invalid or uncovered, 409 replayed, 503 unverifiable, 500 config. */
     readonly status: number;
     constructor(reason: RequestProofFailureReason, phase: RequestProofFailurePhase, status: number, message: string);
 }
 /** invalid, proof phase → 401. */
 declare const invalidProof: (message: string) => ApiRequestVerifyError;
+/**
+ * replayed, proof phase → 409. The proof verified; its `jti` was already spent.
+ * The cache belongs to the deployment, so this is the constructor every consumer
+ * classifies a replay with rather than a status each one picks.
+ */
+declare const replayedProof: (message: string) => ApiRequestVerifyError;
+/**
+ * uncovered, credential phase → 403. The credential verified and simply does not
+ * reach this route's resource and action. Its own verdict because a route
+ * offering optional authentication answers it with the anonymous projection a
+ * caller presenting nothing would get — a credential only ever ADDS — while an
+ * `invalid` credential is refused outright.
+ */
+declare const uncoveredProof: (message: string) => ApiRequestVerifyError;
 /** unverifiable, proof phase → 503. */
 declare const unverifiableProof: (message: string) => ApiRequestVerifyError;
 /** the DEPLOYMENT is misconfigured → 500. Never a judgment about the artifact. */
@@ -301,10 +360,16 @@ declare const misconfiguredProof: (message: string) => ApiRequestVerifyError;
 interface ProofPresenterState {
     /** Current-state deletion. A deleted presenter's proofs are INVALID (401). */
     isDeleted: boolean;
-    /** Current keys, any role. */
+    /**
+     * Current keys, any role. `roles` is OPTIONAL and the resolver's to supply: a
+     * key may hold several, and a deployment gating writes decides for itself
+     * which role may sign. The verifier never reads it — it hands the matched
+     * key's roles back on the verified envelope.
+     */
     keys: readonly {
         id: string;
         publicKeyMultibase: string;
+        roles?: readonly ('auth' | 'assert' | 'controller')[];
     }[];
 }
 /**
@@ -345,6 +410,12 @@ interface ProofEnvelopeInput {
     skewSeconds?: number;
     /** Clock injection (unix ms). Default `Date.now()`. */
     now?: () => number;
+    /**
+     * Require the registered `jti` member. Default false. A verifier gating WRITES
+     * sets it on every write-shaped route and records the value in its own replay
+     * cache; a read-shaped route may ignore the member entirely.
+     */
+    requireJti?: boolean;
 }
 /**
  * INTEGRATIONS.md, Verification algorithm step 4's freshness configuration,
@@ -372,11 +443,10 @@ interface VerifiedProofEnvelope {
     /**
      * The DECODED payload object, unknown members included.
      *
-     * ADDITIVE MEMBERS ARE READ FROM HERE, at the consuming layer, AFTER
-     * verification — the signature already covers them, and the canonical member
-     * set stays closed. `jti` is the case this exists for: the envelope verifier
-     * ignores it per MUST-ignore-unknown, and a write-gating deployment reads it
-     * off this object and applies its own replay discipline.
+     * UNREGISTERED ADDITIVE MEMBERS ARE READ FROM HERE, at the consuming layer,
+     * AFTER verification — the signature already covers them, and the canonical
+     * member set stays closed. The registered `jti` has its own field above; every
+     * other additive member is ignored per MUST-ignore-unknown and survives here.
      */
     rawPayload: Record<string, unknown>;
     /** THE PRINCIPAL — the `kid`'s DID. */
@@ -385,6 +455,17 @@ interface VerifiedProofEnvelope {
     kid: string;
     /** The integer unix seconds the freshness check used. */
     now: number;
+    /**
+     * The registered `jti`, when the proof carried one — the value a write-gating
+     * deployment records in its replay cache, keyed with `presenterDID`.
+     */
+    jti?: string;
+    /**
+     * The matched key's roles, when the resolver supplied them. A deployment
+     * gating writes with an identity proof applies its own rule here: a key whose
+     * only effective role is `controller` should not stand for a write.
+     */
+    keyRoles?: readonly ('auth' | 'assert' | 'controller')[];
 }
 /**
  * Verify an IDENTITY proof's envelope — for this artifact steps 1–7 ARE the whole
@@ -406,4 +487,4 @@ declare const verifyIdentityProofEnvelope: (input: ProofEnvelopeInput, resolvePr
  */
 declare const verifyRequestProofEnvelope: (input: ProofEnvelopeInput, resolvePresenter: ResolveProofPresenter) => Promise<VerifiedProofEnvelope>;
 
-export { ApiRequestVerifyError, DEFAULT_PROOF_SKEW_SECONDS, DEFAULT_PROOF_WINDOW_SECONDS, DFOS_AUTH_SCHEME, EMPTY_BODY_SHA256, IDENTITY_PROOF_JWS_TYP, type IdentityProofPayload, MAX_BODY_BYTES, MAX_PROOF_FRESHNESS_SPAN_SECONDS, MAX_REQUEST_PROOF_SIZE, type ParsedProofPayload, type ProofEnvelopeInput, type ProofExtraMembers, type ProofPresenterState, REQUEST_PROOF_JWS_TYP, type RequestProofFailurePhase, type RequestProofFailureReason, type RequestProofPayload, type ResolveProofPresenter, type SignApiIdentityRequestInput, type SignApiRequestInput, type VerifiedProofEnvelope, apiIdentitySigningInput, apiRequestSigningInput, assertProofVerifierConfig, buildApiAuthHeaders, buildApiIdentityHeaders, canonicalExtraMembers, invalidProof, misconfiguredProof, parseDfosAuthorization, sha256BodyHash, signApiIdentityRequest, signApiRequest, unverifiableProof, verifyIdentityProofEnvelope, verifyRequestProofEnvelope };
+export { ApiRequestVerifyError, DEFAULT_PROOF_SKEW_SECONDS, DEFAULT_PROOF_WINDOW_SECONDS, DFOS_AUTH_SCHEME, EMPTY_BODY_SHA256, IDENTITY_PROOF_JWS_TYP, type IdentityProofPayload, MAX_BODY_BYTES, MAX_JTI_BYTES, MAX_PROOF_FRESHNESS_SPAN_SECONDS, MAX_REQUEST_PROOF_SIZE, type ParsedProofPayload, type ProofEnvelopeInput, type ProofExtraMembers, type ProofPresenterState, REQUEST_PROOF_JWS_TYP, type RequestProofFailurePhase, type RequestProofFailureReason, type RequestProofPayload, type ResolveProofPresenter, type SignApiIdentityRequestInput, type SignApiRequestInput, type VerifiedProofEnvelope, apiIdentitySigningInput, apiRequestSigningInput, assertProofVerifierConfig, buildApiAuthHeaders, buildApiIdentityHeaders, canonicalExtraMembers, generateJti, invalidProof, misconfiguredProof, parseDfosAuthorization, replayedProof, sha256BodyHash, signApiIdentityRequest, signApiRequest, uncoveredProof, unverifiableProof, verifyIdentityProofEnvelope, verifyRequestProofEnvelope };

package/dist/credentials/index.js

@@ -10,33 +10,39 @@ import {
   IDENTITY_PROOF_JWS_TYP,
   MAX_BODY_BYTES,
   MAX_CREDENTIAL_SIZE,
+  MAX_JTI_BYTES,
   MAX_PROOF_FRESHNESS_SPAN_SECONDS,
   MAX_REQUEST_PROOF_SIZE,
   REQUEST_PROOF_JWS_TYP,
   apiIdentitySigningInput,
   apiRequestSigningInput,
+  apiResourceCovers,
   assertProofVerifierConfig,
   buildApiAuthHeaders,
   buildApiIdentityHeaders,
   canonicalExtraMembers,
   createDFOSCredential,
   decodeDFOSCredentialUnsafe,
+  generateJti,
   invalidProof,
   isAttenuated,
   matchesResource,
   misconfiguredProof,
+  parseApiResource,
   parseDfosAuthorization,
+  replayedProof,
   sha256BodyHash,
   signApiIdentityRequest,
   signApiRequest,
+  uncoveredProof,
   unverifiableProof,
   verifyDFOSCredential,
   verifyDelegationChain,
   verifyIdentityProofEnvelope,
   verifyRequestProofEnvelope
-} from "../chunk-FZHHSC5N.js";
+} from "../chunk-RPA44ND4.js";
 import "../chunk-F7RHI2CK.js";
-import "../chunk-KAW4MT4P.js";
+import "../chunk-NUIIVAZ3.js";
 export {
   ApiRequestVerifyError,
   Attenuation,
@@ -49,25 +55,31 @@ export {
   IDENTITY_PROOF_JWS_TYP,
   MAX_BODY_BYTES,
   MAX_CREDENTIAL_SIZE,
+  MAX_JTI_BYTES,
   MAX_PROOF_FRESHNESS_SPAN_SECONDS,
   MAX_REQUEST_PROOF_SIZE,
   REQUEST_PROOF_JWS_TYP,
   apiIdentitySigningInput,
   apiRequestSigningInput,
+  apiResourceCovers,
   assertProofVerifierConfig,
   buildApiAuthHeaders,
   buildApiIdentityHeaders,
   canonicalExtraMembers,
   createDFOSCredential,
   decodeDFOSCredentialUnsafe,
+  generateJti,
   invalidProof,
   isAttenuated,
   matchesResource,
   misconfiguredProof,
+  parseApiResource,
   parseDfosAuthorization,
+  replayedProof,
   sha256BodyHash,
   signApiIdentityRequest,
   signApiRequest,
+  uncoveredProof,
   unverifiableProof,
   verifyDFOSCredential,
   verifyDelegationChain,

package/dist/crypto/index.js

@@ -23,7 +23,7 @@ import {
   signPayloadEd25519,
   verifyJws,
   verifyJwt
-} from "../chunk-KAW4MT4P.js";
+} from "../chunk-NUIIVAZ3.js";
 export {
   JwsVerificationError,
   JwtVerificationError,

package/dist/{dfos-credential-j-kHtFvG.d.ts → dfos-credential-DgT8XVTm.d.ts}

@@ -648,6 +648,26 @@ declare const verifyDelegationChain: (credential: VerifiedDFOSCredential, option
      */
     nowUnix?: number;
 }) => Promise<VerifiedDelegationChain>;
+/**
+ * Parse an `api:` resource into its host and, when present, its space id.
+ * Returns `null` for any other resource type and for a malformed `api:` id —
+ * `null` IS the malformed verdict, and a malformed resource covers nothing.
+ *
+ * Two forms are well-formed and no others: `api:<host>` with a non-empty host
+ * carrying no `/`, and `api:<host>/spaces/<id>`. The id half splits on the FIRST
+ * `/`, so a host keeps its port and anything past `spaces/<id>` is malformed.
+ */
+declare const parseApiResource: (resource: string) => {
+    host: string;
+    spaceId?: string;
+} | null;
+/**
+ * Whether one `api:` resource covers another: same host, and either the entry is
+ * the bare host (the registered ancestor of every space on it) or the two name
+ * the same space. False when either side is malformed or is not `api:` —
+ * coverage never crosses hosts and never crosses resource types.
+ */
+declare const apiResourceCovers: (entryResource: string, requiredResource: string) => boolean;
 /**
  * Check if `childAtt` is a valid attenuation of `parentAtt`
  *
@@ -658,11 +678,14 @@ declare const verifyDelegationChain: (credential: VerifiedDFOSCredential, option
  * - `chain:X` covered by `chain:*` (narrowing from wildcard — valid)
  * - `chain:*` covered by `chain:*` (exact match)
  * - `chain:*` NOT covered by `chain:X` (widening — invalid)
- * - Non-`chain` types (`mailbox:<id>`, and any form a future capability
- *   registers): exact byte equality of the full resource string, nothing else.
- *   The wildcard is a `chain:`-only concept — a literal `*` id in any other
- *   type is an ordinary id covering only itself — and coverage never crosses
- *   resource types. See CREDENTIALS.md "Resource Types".
+ * - `api:<host>/spaces/<id>` covered by `api:<host>` (narrowing onto one space)
+ *   or by the same child. A MALFORMED `api:` id narrows only from a
+ *   byte-identical parent, under the rule below — a bare host does not carry it.
+ * - Other types (`mailbox:<id>`, and any form a future capability registers):
+ *   exact byte equality of the full resource string, nothing else. The wildcard
+ *   is a `chain:`-only concept — a literal `*` id in any other type is an
+ *   ordinary id covering only itself — and coverage never crosses resource
+ *   types. See CREDENTIALS.md "Resource Types".
  * - Actions: child action set must be a subset of parent action set
  */
 declare const isAttenuated: (parentAtt: Attenuation[], childAtt: Attenuation[]) => boolean;
@@ -670,7 +693,14 @@ declare const isAttenuated: (parentAtt: Attenuation[], childAtt: Attenuation[])
  * Check if an `att` array covers a requested resource
  *
  * Used at the relay to determine if a credential authorizes access to a
- * specific content chain.
+ * specific content chain, and by an API verifier to decide whether a grant
+ * reaches the route's resource.
+ *
+ * `chain:*` covers any `chain:` request; an `api:` entry covers an `api:`
+ * request under the host/space hierarchy; every other form is exact byte
+ * equality. A malformed `api:` resource covers nothing and is covered by
+ * nothing, itself included — a resource a verifier cannot parse must not
+ * authorize a request. Every entry is scanned, so any one of them may cover.
  */
 declare const matchesResource: (att: Attenuation[], resource: string, action: string) => Promise<boolean>;
 /**
@@ -691,4 +721,4 @@ declare class CredentialVerificationError extends Error {
     constructor(message: string);
 }
 
-export { ARTIFACT_CID_ANCHOR_RE as A, decodeDFOSCredentialUnsafe as B, CONTENT_ID_ANCHOR_RE as C, DFOSCredentialPayload as D, isAttenuated as E, matchesResource as F, parseProtocolTimestampUnix as G, verifyDFOSCredential as H, IdentityOperation as I, verifyDelegationChain as J, MAX_ARTIFACT_PAYLOAD_SIZE as M, type ResolvedIdentity as R, ServiceEntry as S, type VerifiedDFOSCredential as V, ArtifactPayload as a, Attenuation as b, ContentOperation as c, CountersignPayload as d, CredentialVerificationError as e, CreditClaimPayload as f, DeclaredKeyState as g, Iso8601 as h, MAX_CREDENTIAL_SIZE as i, MAX_CREDIT_CLAIM_SIZE as j, MAX_KEY_PROOFS as k, MAX_OPERATION_SIZE as l, MAX_SERVICES_ENTRIES as m, MAX_SERVICES_PAYLOAD_SIZE as n, MAX_SIGN_REQUEST_PAYLOAD_SIZE as o, MAX_SIGN_REQUEST_SIZE as p, MultikeyPublicKey as q, type RevocationChecker as r, RevocationPayload as s, ServicesArray as t, SignRequestPayload as u, type Signer as v, type VerifiedDelegationChain as w, VerifiedIdentity as x, VoidKeyMembership as y, createDFOSCredential as z };
+export { ARTIFACT_CID_ANCHOR_RE as A, createDFOSCredential as B, CONTENT_ID_ANCHOR_RE as C, DFOSCredentialPayload as D, decodeDFOSCredentialUnsafe as E, isAttenuated as F, matchesResource as G, parseApiResource as H, IdentityOperation as I, parseProtocolTimestampUnix as J, verifyDFOSCredential as K, verifyDelegationChain as L, MAX_ARTIFACT_PAYLOAD_SIZE as M, type ResolvedIdentity as R, ServiceEntry as S, type VerifiedDFOSCredential as V, ArtifactPayload as a, Attenuation as b, ContentOperation as c, CountersignPayload as d, CredentialVerificationError as e, CreditClaimPayload as f, DeclaredKeyState as g, Iso8601 as h, MAX_CREDENTIAL_SIZE as i, MAX_CREDIT_CLAIM_SIZE as j, MAX_KEY_PROOFS as k, MAX_OPERATION_SIZE as l, MAX_SERVICES_ENTRIES as m, MAX_SERVICES_PAYLOAD_SIZE as n, MAX_SIGN_REQUEST_PAYLOAD_SIZE as o, MAX_SIGN_REQUEST_SIZE as p, MultikeyPublicKey as q, type RevocationChecker as r, RevocationPayload as s, ServicesArray as t, SignRequestPayload as u, type Signer as v, type VerifiedDelegationChain as w, VerifiedIdentity as x, VoidKeyMembership as y, apiResourceCovers as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { JwsHeader, JwsVerificationError, JwtClaims, JwtCreateOptions, JwtHeader, JwtVerificationError, JwtVerifyOptions, PrefixedID, assertCanonicalJsonText, assertJwsProfile, base64urlDecode, base64urlEncode, createJws, createJwt, createNewEd25519Keypair, dagCborCanonicalEncode, decodeJwsUnsafe, decodeJwtUnsafe, generateId, generateIdNoPrefix, importEd25519Keypair, isCanonicallyEqual, isValidEd25519Signature, isValidId, normalizedId, parseDagCborCID, sha256, signPayloadEd25519, verifyJws, verifyJwt } from './crypto/index.js';
-export { A as ARTIFACT_CID_ANCHOR_RE, a as ArtifactPayload, b as Attenuation, C as CONTENT_ID_ANCHOR_RE, c as ContentOperation, d as CountersignPayload, e as CredentialVerificationError, f as CreditClaimPayload, D as DFOSCredentialPayload, g as DeclaredKeyState, I as IdentityOperation, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, i as MAX_CREDENTIAL_SIZE, j as MAX_CREDIT_CLAIM_SIZE, k as MAX_KEY_PROOFS, l as MAX_OPERATION_SIZE, m as MAX_SERVICES_ENTRIES, n as MAX_SERVICES_PAYLOAD_SIZE, o as MAX_SIGN_REQUEST_PAYLOAD_SIZE, p as MAX_SIGN_REQUEST_SIZE, q as MultikeyPublicKey, R as ResolvedIdentity, r as RevocationChecker, s as RevocationPayload, S as ServiceEntry, t as ServicesArray, u as SignRequestPayload, v as Signer, V as VerifiedDFOSCredential, w as VerifiedDelegationChain, x as VerifiedIdentity, y as VoidKeyMembership, z as createDFOSCredential, B as decodeDFOSCredentialUnsafe, E as isAttenuated, F as matchesResource, G as parseProtocolTimestampUnix, H as verifyDFOSCredential, J as verifyDelegationChain } from './dfos-credential-j-kHtFvG.js';
-export { AnchorKind, CreditClaimFailureReason, CreditClaimVerifyError, CreditEntry, CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, RECOGNIZED_SERVICE_TYPES, SignRequestFailureReason, SignRequestVerifyError, VerifiedArtifact, VerifiedContentChain, VerifiedCountersignature, VerifiedCreditClaim, VerifiedCreditEntry, VerifiedRevocation, VerifiedSignRequest, anchorsByLabel, assertCanonicalSignRequestPayload, assertServicesWithinCap, buildSignRequest, classifyAnchor, decodeEd25519PublicMultikey, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signCreditClaim, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyCreditClaim, verifyCreditEntry, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation, verifySignRequest } from './chain/index.js';
-export { ApiRequestVerifyError, DEFAULT_PROOF_SKEW_SECONDS, DEFAULT_PROOF_WINDOW_SECONDS, DFOS_AUTH_SCHEME, EMPTY_BODY_SHA256, IDENTITY_PROOF_JWS_TYP, IdentityProofPayload, MAX_BODY_BYTES, MAX_PROOF_FRESHNESS_SPAN_SECONDS, MAX_REQUEST_PROOF_SIZE, ParsedProofPayload, ProofEnvelopeInput, ProofExtraMembers, ProofPresenterState, REQUEST_PROOF_JWS_TYP, RequestProofFailurePhase, RequestProofFailureReason, RequestProofPayload, ResolveProofPresenter, SignApiIdentityRequestInput, SignApiRequestInput, VerifiedProofEnvelope, apiIdentitySigningInput, apiRequestSigningInput, assertProofVerifierConfig, buildApiAuthHeaders, buildApiIdentityHeaders, canonicalExtraMembers, invalidProof, misconfiguredProof, parseDfosAuthorization, sha256BodyHash, signApiIdentityRequest, signApiRequest, unverifiableProof, verifyIdentityProofEnvelope, verifyRequestProofEnvelope } from './credentials/index.js';
+export { A as ARTIFACT_CID_ANCHOR_RE, a as ArtifactPayload, b as Attenuation, C as CONTENT_ID_ANCHOR_RE, c as ContentOperation, d as CountersignPayload, e as CredentialVerificationError, f as CreditClaimPayload, D as DFOSCredentialPayload, g as DeclaredKeyState, I as IdentityOperation, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, i as MAX_CREDENTIAL_SIZE, j as MAX_CREDIT_CLAIM_SIZE, k as MAX_KEY_PROOFS, l as MAX_OPERATION_SIZE, m as MAX_SERVICES_ENTRIES, n as MAX_SERVICES_PAYLOAD_SIZE, o as MAX_SIGN_REQUEST_PAYLOAD_SIZE, p as MAX_SIGN_REQUEST_SIZE, q as MultikeyPublicKey, R as ResolvedIdentity, r as RevocationChecker, s as RevocationPayload, S as ServiceEntry, t as ServicesArray, u as SignRequestPayload, v as Signer, V as VerifiedDFOSCredential, w as VerifiedDelegationChain, x as VerifiedIdentity, y as VoidKeyMembership, z as apiResourceCovers, B as createDFOSCredential, E as decodeDFOSCredentialUnsafe, F as isAttenuated, G as matchesResource, H as parseApiResource, J as parseProtocolTimestampUnix, K as verifyDFOSCredential, L as verifyDelegationChain } from './dfos-credential-DgT8XVTm.js';
+export { AnchorKind, CreditClaimFailureReason, CreditClaimVerifyError, CreditEntry, CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, IdentityStateNoSeenKeysError, RECOGNIZED_SERVICE_TYPES, SignRequestFailureReason, SignRequestVerifyError, VerifiedArtifact, VerifiedContentChain, VerifiedCountersignature, VerifiedCreditClaim, VerifiedCreditEntry, VerifiedRevocation, VerifiedSignRequest, anchorsByLabel, assertCanonicalSignRequestPayload, assertServicesWithinCap, buildSignRequest, classifyAnchor, decodeEd25519PublicMultikey, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signCreditClaim, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyCreditClaim, verifyCreditEntry, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation, verifySignRequest } from './chain/index.js';
+export { ApiRequestVerifyError, DEFAULT_PROOF_SKEW_SECONDS, DEFAULT_PROOF_WINDOW_SECONDS, DFOS_AUTH_SCHEME, EMPTY_BODY_SHA256, IDENTITY_PROOF_JWS_TYP, IdentityProofPayload, MAX_BODY_BYTES, MAX_JTI_BYTES, MAX_PROOF_FRESHNESS_SPAN_SECONDS, MAX_REQUEST_PROOF_SIZE, ParsedProofPayload, ProofEnvelopeInput, ProofExtraMembers, ProofPresenterState, REQUEST_PROOF_JWS_TYP, RequestProofFailurePhase, RequestProofFailureReason, RequestProofPayload, ResolveProofPresenter, SignApiIdentityRequestInput, SignApiRequestInput, VerifiedProofEnvelope, apiIdentitySigningInput, apiRequestSigningInput, assertProofVerifierConfig, buildApiAuthHeaders, buildApiIdentityHeaders, canonicalExtraMembers, generateJti, invalidProof, misconfiguredProof, parseDfosAuthorization, replayedProof, sha256BodyHash, signApiIdentityRequest, signApiRequest, uncoveredProof, unverifiableProof, verifyIdentityProofEnvelope, verifyRequestProofEnvelope } from './credentials/index.js';
 export { DEFAULT_KEY_PROOF_SKEW_SECONDS, KEY_ADD_JWS_TYP, KEY_ROLES, KeyProofFailureReason, KeyProofPayload, KeyProofVerifyError, KeyRole, MAX_KEY_PROOF_SIZE, SignKeyProofInput, VerifiedKeyProof, VerifyChainKeyProofOptions, VerifyKeyProofOptions, isCanonicalRoleSet, keyProofSigningInput, keyWordFingerprint, parseRoleSet, roleSetCovers, serializeRoleSet, signKeyProof, unsafeKeyProofSubject, verifyChainKeyProof, verifyKeyProof } from './key-proof/index.js';
 export { FoldOperation, INDEX_V1_SCHEMA, IndexDelta, IndexDocument, IndexEntry, LwwDelta, OrderKey, byteCompare, compareHeadPreference, compareLinear, foldIndexV1, foldLwwMap, linearize } from './fold/index.js';
 import 'multiformats';

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   CreditClaimVerifyError,
   DeclaredKeyState,
   IdentityOperation,
+  IdentityStateNoSeenKeysError,
   Iso8601,
   MAX_ARTIFACT_PAYLOAD_SIZE,
   MAX_CREDIT_CLAIM_SIZE,
@@ -52,7 +53,7 @@ import {
   verifyIdentityExtensionFromTrustedState,
   verifyRevocation,
   verifySignRequest
-} from "./chunk-Q7FREWMY.js";
+} from "./chunk-QIM3KZXZ.js";
 import {
   ApiRequestVerifyError,
   Attenuation,
@@ -65,11 +66,13 @@ import {
   IDENTITY_PROOF_JWS_TYP,
   MAX_BODY_BYTES,
   MAX_CREDENTIAL_SIZE,
+  MAX_JTI_BYTES,
   MAX_PROOF_FRESHNESS_SPAN_SECONDS,
   MAX_REQUEST_PROOF_SIZE,
   REQUEST_PROOF_JWS_TYP,
   apiIdentitySigningInput,
   apiRequestSigningInput,
+  apiResourceCovers,
   assertProofVerifierConfig,
   buildApiAuthHeaders,
   buildApiIdentityHeaders,
@@ -77,22 +80,26 @@ import {
   carryDependencyMissing,
   createDFOSCredential,
   decodeDFOSCredentialUnsafe,
+  generateJti,
   invalidProof,
   isAttenuated,
   isDependencyMissing,
   markDependencyMissing,
   matchesResource,
   misconfiguredProof,
+  parseApiResource,
   parseDfosAuthorization,
+  replayedProof,
   sha256BodyHash,
   signApiIdentityRequest,
   signApiRequest,
+  uncoveredProof,
   unverifiableProof,
   verifyDFOSCredential,
   verifyDelegationChain,
   verifyIdentityProofEnvelope,
   verifyRequestProofEnvelope
-} from "./chunk-FZHHSC5N.js";
+} from "./chunk-RPA44ND4.js";
 import {
   DEFAULT_KEY_PROOF_SKEW_SECONDS,
   KEY_ADD_JWS_TYP,
@@ -109,7 +116,7 @@ import {
   unsafeKeyProofSubject,
   verifyChainKeyProof,
   verifyKeyProof
-} from "./chunk-BMIOY5W5.js";
+} from "./chunk-ISHAX5WN.js";
 import {
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
@@ -142,7 +149,7 @@ import {
   signPayloadEd25519,
   verifyJws,
   verifyJwt
-} from "./chunk-KAW4MT4P.js";
+} from "./chunk-NUIIVAZ3.js";
 import {
   INDEX_V1_SCHEMA,
   byteCompare,
@@ -175,6 +182,7 @@ export {
   IDENTITY_PROOF_JWS_TYP,
   INDEX_V1_SCHEMA,
   IdentityOperation,
+  IdentityStateNoSeenKeysError,
   Iso8601,
   JwsVerificationError,
   JwtVerificationError,
@@ -185,6 +193,7 @@ export {
   MAX_BODY_BYTES,
   MAX_CREDENTIAL_SIZE,
   MAX_CREDIT_CLAIM_SIZE,
+  MAX_JTI_BYTES,
   MAX_KEY_PROOFS,
   MAX_KEY_PROOF_SIZE,
   MAX_OPERATION_SIZE,
@@ -207,6 +216,7 @@ export {
   anchorsByLabel,
   apiIdentitySigningInput,
   apiRequestSigningInput,
+  apiResourceCovers,
   assertCanonicalJsonText,
   assertCanonicalSignRequestPayload,
   assertJwsProfile,
@@ -240,6 +250,7 @@ export {
   foldLwwMap,
   generateId,
   generateIdNoPrefix,
+  generateJti,
   importEd25519Keypair,
   invalidProof,
   isAttenuated,
@@ -256,11 +267,13 @@ export {
   matchesResource,
   misconfiguredProof,
   normalizedId,
+  parseApiResource,
   parseDagCborCID,
   parseDfosAuthorization,
   parseProtocolTimestampUnix,
   parseRoleSet,
   relayEndpoints,
+  replayedProof,
   roleSetCovers,
   serializeRoleSet,
   sha256,
@@ -275,6 +288,7 @@ export {
   signKeyProof,
   signPayloadEd25519,
   signRevocation,
+  uncoveredProof,
   unsafeKeyProofSubject,
   unverifiableProof,
   verifyArtifact,

package/dist/key-proof/index.js

@@ -14,9 +14,9 @@ import {
   unsafeKeyProofSubject,
   verifyChainKeyProof,
   verifyKeyProof
-} from "../chunk-BMIOY5W5.js";
+} from "../chunk-ISHAX5WN.js";
 import "../chunk-F7RHI2CK.js";
-import "../chunk-KAW4MT4P.js";
+import "../chunk-NUIIVAZ3.js";
 export {
   DEFAULT_KEY_PROOF_SKEW_SECONDS,
   KEY_ADD_JWS_TYP,