@metalabel/dfos-protocol 0.23.0 → 0.25.0

package/dist/credentials/index.d.ts

@@ -1,47 +1,5 @@
-import { z } from 'zod';
-import { V as VerifiedIdentity } from '../schemas-BXye25k7.js';
-
-/**
- * Max byte length of a credential JWS token — the credential's analog of
- * MAX_OPERATION_SIZE. Credentials are EXEMPT from the 64 KiB operation cap (a
- * maximum-depth 16-credential delegation chain embeds each parent token in `prf` and
- * legitimately exceeds it), so they carry their own larger ceiling. Measured
- * over the serialized leaf token, which contains the entire nested chain, so one
- * bound caps the whole delegation. A DoS guard on the nested `prf` structure;
- * generous (a max-depth chain serializes to well under this). VALIDITY-
- * determining: MUST match the Go reference (maxCredentialSize in jwt.go).
- */
-declare const MAX_CREDENTIAL_SIZE = 262144;
-/** Single attenuation entry — resource + action pair */
-declare const Attenuation: z.ZodObject<{
-    resource: z.ZodString;
-    action: z.ZodString;
-}, z.core.$loose>;
-type Attenuation = z.infer<typeof Attenuation>;
-/** DFOS credential payload — UCAN-style authorization token */
-declare const DFOSCredentialPayload: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    type: z.ZodLiteral<"DFOSCredential">;
-    iss: z.ZodString;
-    aud: z.ZodString;
-    att: z.ZodArray<z.ZodObject<{
-        resource: z.ZodString;
-        action: z.ZodString;
-    }, z.core.$loose>>;
-    prf: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    exp: z.ZodNumber;
-    iat: z.ZodNumber;
-}, z.core.$loose>;
-type DFOSCredentialPayload = z.infer<typeof DFOSCredentialPayload>;
-/** Claims for a DID-signed auth token (relay AuthN) */
-declare const AuthTokenClaims: z.ZodObject<{
-    iss: z.ZodString;
-    sub: z.ZodString;
-    aud: z.ZodString;
-    exp: z.ZodNumber;
-    iat: z.ZodNumber;
-}, z.core.$loose>;
-type AuthTokenClaims = z.infer<typeof AuthTokenClaims>;
+export { b as Attenuation, c as AuthTokenClaims, f as CredentialVerificationError, D as DFOSCredentialPayload, i as MAX_CREDENTIAL_SIZE, R as RevocationChecker, V as VerifiedDFOSCredential, r as VerifiedDelegationChain, t as createDFOSCredential, u as decodeDFOSCredentialUnsafe, v as isAttenuated, w as matchesResource, y as verifyDFOSCredential, z as verifyDelegationChain } from '../dfos-credential-CAYCqUCP.js';
+import 'zod';
 
 interface AuthTokenCreateOptions {
     /** The DID proving identity */
@@ -93,122 +51,4 @@ declare class AuthTokenVerificationError extends Error {
     constructor(message: string);
 }
 
-interface VerifiedDFOSCredential {
-    /** Issuer DID */
-    iss: string;
-    /** Audience DID or "*" for public */
-    aud: string;
-    /** Attenuations — resource + action pairs */
-    att: Attenuation[];
-    /** Parent credential JWS tokens */
-    prf: string[];
-    /** Expiry (unix seconds) */
-    exp: number;
-    /** Issued at (unix seconds) */
-    iat: number;
-    /** CID of the credential payload (for revocation references) */
-    credentialCID: string;
-    /** kid from the JWS header */
-    signerKeyId: string;
-}
-interface VerifiedDelegationChain {
-    /** The leaf credential */
-    credential: VerifiedDFOSCredential;
-    /** All credentials in the chain, from leaf to root */
-    chain: VerifiedDFOSCredential[];
-    /** The root DID that ultimately authorized the chain */
-    rootDID: string;
-}
-/**
- * Create a signed DFOS credential
- *
- * The credential is a JWS with `typ: "did:dfos:credential"` and a CID in the
- * protected header for revocation addressability.
- */
-declare const createDFOSCredential: (options: {
-    issuerDID: string;
-    /** Audience DID, or "*" for public credentials */
-    audienceDID: string;
-    att: Attenuation[];
-    /** Parent credential JWS tokens (for delegation chains) */
-    prf?: string[];
-    /** Expiry — unix seconds */
-    exp: number;
-    /** Signer function */
-    signer: (message: Uint8Array) => Promise<Uint8Array>;
-    /** Key ID (without DID prefix — just the key_xxx part) */
-    keyId: string;
-    /** Issued-at override — unix seconds (defaults to Date.now()) */
-    iat?: number;
-}) => Promise<string>;
-/**
- * Verify a DFOS credential — signature, schema, expiry, CID integrity
- *
- * Does NOT verify the delegation chain. Use `verifyDelegationChain` for full
- * chain verification including attenuation enforcement.
- */
-declare const verifyDFOSCredential: (jwsToken: string, options: {
-    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
-    /** Current time in seconds (defaults to Date.now() / 1000) */
-    now?: number;
-}) => Promise<VerifiedDFOSCredential>;
-/**
- * Verify a full delegation chain — walk `prf`, confirm monotonic attenuation,
- * verify each credential's signature, and confirm the chain roots at `rootDID`.
- *
- * The chain is walked from the leaf credential upward through each parent in
- * `prf`. At each hop: the child's `iss` must match a parent's `aud` (or the
- * parent's `aud` must be `"*"`), the child's `att` must be attenuated from the
- * parent's `att`, and the child's `exp` must not exceed the parent's `exp`.
- *
- * The chain terminates when a credential has `prf: []` (root credential). The
- * root credential's `iss` must equal `rootDID`.
- */
-declare const verifyDelegationChain: (credential: VerifiedDFOSCredential, options: {
-    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
-    /** The expected root authority DID (e.g., content chain creator) */
-    rootDID: string;
-    /** Current time in seconds (defaults to Date.now() / 1000) */
-    now?: number;
-    /** Check if a credential has been revoked (checked at every level of the chain) */
-    isRevoked?: (issuerDID: string, credentialCID: string) => Promise<boolean>;
-}) => Promise<VerifiedDelegationChain>;
-/**
- * Check if `childAtt` is a valid attenuation of `parentAtt`
- *
- * Every entry in `childAtt` must be covered by at least one entry in
- * `parentAtt`. Coverage rules:
- *
- * - `chain:X` covered by `chain:X` (exact match)
- * - `chain:X` covered by `chain:*` (narrowing from wildcard — valid)
- * - `chain:*` covered by `chain:*` (exact match)
- * - `chain:*` NOT covered by `chain:X` (widening — invalid)
- * - Actions: child action set must be a subset of parent action set
- */
-declare const isAttenuated: (parentAtt: Attenuation[], childAtt: Attenuation[]) => boolean;
-/**
- * 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.
- */
-declare const matchesResource: (att: Attenuation[], resource: string, action: string) => Promise<boolean>;
-/**
- * Decode a DFOS credential JWS without verifying the signature
- *
- * Returns null if the token is malformed or payload is invalid.
- */
-declare const decodeDFOSCredentialUnsafe: (jwsToken: string) => {
-    header: {
-        alg: string;
-        typ: string;
-        kid: string;
-        cid: string;
-    };
-    payload: DFOSCredentialPayload;
-} | null;
-declare class CredentialVerificationError extends Error {
-    constructor(message: string);
-}
-
-export { Attenuation, AuthTokenClaims, type AuthTokenCreateOptions, AuthTokenVerificationError, type AuthTokenVerifyOptions, CredentialVerificationError, DFOSCredentialPayload, MAX_CREDENTIAL_SIZE, type VerifiedAuthToken, type VerifiedDFOSCredential, type VerifiedDelegationChain, createAuthToken, createDFOSCredential, decodeDFOSCredentialUnsafe, isAttenuated, matchesResource, verifyAuthToken, verifyDFOSCredential, verifyDelegationChain };
+export { type AuthTokenCreateOptions, AuthTokenVerificationError, type AuthTokenVerifyOptions, type VerifiedAuthToken, createAuthToken, verifyAuthToken };

package/dist/credentials/index.js

@@ -13,7 +13,7 @@ import {
   verifyAuthToken,
   verifyDFOSCredential,
   verifyDelegationChain
-} from "../chunk-FMHROCFH.js";
+} from "../chunk-PGFHCBGH.js";
 import "../chunk-4QQ5HK5M.js";
 export {
   Attenuation,

package/dist/dfos-credential-CAYCqUCP.d.ts

@@ -0,0 +1,493 @@
+import { z } from 'zod';
+
+/** Function that signs a byte array and returns a signature */
+type Signer = (message: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Max number of service entries in an identity's services state — a generous
+ * cardinality ceiling on resolution fan-out. Individual entry fields are NOT
+ * separately length-capped (no per-field length zoo): the aggregate byte cap
+ * below, plus the operation-size cap, bound entry size. The op-size cap is the
+ * real arbiter when services and keys are both large.
+ */
+declare const MAX_SERVICES_ENTRIES = 256;
+/**
+ * Max CBOR-encoded size of the services array (bytes) — the SINGLE aggregate that
+ * bounds the services manifest, replacing the former per-field length caps (the
+ * same collapse the op-size cap applied at the operation level). Sized so the
+ * 256-entry ceiling is genuinely reachable with realistic entries.
+ */
+declare const MAX_SERVICES_PAYLOAD_SIZE = 32768;
+/**
+ * Max dag-cbor-encoded size of a single protocol operation payload (bytes) — the
+ * one aggregate validity bound on operation size, measured over the exact bytes
+ * the CID commits to. Generously set (64 KiB) so it never binds a legitimate
+ * proof-layer operation while bounding decode/verify cost (a DoS + determinism
+ * invariant). This is a VALIDITY-determining cap: it MUST be identical across
+ * implementations. Large binary media does NOT travel in operation payloads —
+ * it is referenced, not inlined — so this bound is about proof-layer ops only.
+ */
+declare const MAX_OPERATION_SIZE = 65536;
+declare const MultikeyPublicKey: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"Multikey">;
+    publicKeyMultibase: z.ZodString;
+}, z.core.$loose>;
+type MultikeyPublicKey = z.infer<typeof MultikeyPublicKey>;
+/**
+ * Anchor target shapes — a ContentAnchor references a STABLE content
+ * identifier, dispatched by structural form:
+ *   - 31-char contentId (content chain) → mutable, gateable
+ *   - CIDv1 dag-cbor+sha256 (artifact)  → immutable, public
+ * Both are stable; a chain HEAD CID (also a `bafyrei…` CID but resolves to a
+ * non-artifact op) is rejected by the shape-dispatch + resolution type check,
+ * never anchored.
+ *
+ * The artifact form is the EXACT 59-char CIDv1(dag-cbor 0x71 + sha256 0x12 0x20)
+ * base32 string — 36 raw bytes → 58 base32 chars + the `b` multibase prefix,
+ * fixed `bafyrei` head + 52 base32 chars. Artifact payloads are ALWAYS dag-cbor +
+ * sha256 (ArtifactPayload below), so every real artifact CID is `bafyrei…`. The
+ * regex is pinned to that exact length (not a loose `baf…{20,}`) so an anchor of
+ * any other shape — wrong codec, wrong length — is rejected uniformly across
+ * implementations. New anchor KINDS arrive via a new service `type`, never a new
+ * anchor shape.
+ */
+declare const CONTENT_ID_ANCHOR_RE: RegExp;
+declare const ARTIFACT_CID_ANCHOR_RE: RegExp;
+/**
+ * Service entry — discovery vocabulary in identity-chain state.
+ *
+ * Open namespace: `type` is an arbitrary bounded string. Recognized types
+ * (`DfosRelay`, `ContentAnchor`) are structurally validated; UNRECOGNIZED types
+ * are preserved verbatim and ignored (MUST-ignore-unknown) — only the common
+ * envelope (id + type) and the byte cap apply. New service types therefore
+ * never require a protocol/cross-language change.
+ */
+declare const ServiceEntry: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+type ServiceEntry = z.infer<typeof ServiceEntry>;
+/** Identity services state — full-state, bounded, unique entry ids */
+declare const ServicesArray: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>>;
+type ServicesArray = z.infer<typeof ServicesArray>;
+/**
+ * The canonical DFOS operation timestamp grammar: fixed 3-digit fraction, literal
+ * `Z`, full calendar validation. Deliberately stricter than RFC 3339 (no numeric
+ * offsets, no variable fraction) so two implementations cannot disagree about
+ * whether a signed timestamp is well-formed. The Go twin is
+ * `time.Parse(protocolTimeFormat, …)`; the 22-case vector set asserting they agree
+ * verdict-for-verdict lives in tests/timestamp-grammar.spec.ts and
+ * dfos-protocol-go/timestamp_grammar_test.go.
+ */
+declare const Iso8601: z.ZodISODateTime;
+/**
+ * Parse a canonical DFOS timestamp to integer unix **seconds**, or null when it
+ * does not match the grammar above.
+ *
+ * This is the ONE parse every consumer of a signed timestamp should use when it
+ * needs a comparable instant. A lenient `new Date(value)` accepts inputs the
+ * protocol rejects (numeric offsets, missing `Z` — which some runtimes then read
+ * as LOCAL time), so two verifiers in different timezones could order the same two
+ * signed timestamps differently. Truncates (floors) the millisecond remainder to
+ * match the credential temporal basis — see CREDENTIALS.md "Time Basis Conversion
+ * and Boundaries". Go twin: `ParseProtocolTimestamp`.
+ */
+declare const parseProtocolTimestampUnix: (value: string) => number | null;
+declare const IdentityOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"create">;
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    services: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"update">;
+    previousOperationCID: z.ZodString;
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    services: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"delete">;
+    previousOperationCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>], "type">;
+type IdentityOperation = z.infer<typeof IdentityOperation>;
+declare const VerifiedIdentity: z.ZodObject<{
+    did: z.ZodString;
+    isDeleted: z.ZodBoolean;
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    services: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strict>;
+type VerifiedIdentity = z.infer<typeof VerifiedIdentity>;
+declare const ContentOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"create">;
+    did: z.ZodString;
+    documentCID: z.ZodString;
+    baseDocumentCID: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"update">;
+    did: z.ZodString;
+    previousOperationCID: z.ZodString;
+    documentCID: z.ZodNullable<z.ZodString>;
+    baseDocumentCID: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    authorization: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"delete">;
+    did: z.ZodString;
+    previousOperationCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    authorization: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>], "type">;
+type ContentOperation = z.infer<typeof ContentOperation>;
+/** Max CBOR-encoded payload size for artifacts (bytes) — protocol constant */
+declare const MAX_ARTIFACT_PAYLOAD_SIZE = 16384;
+/** Artifact: standalone signed inline document, immutable, CID-addressable */
+declare const ArtifactPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"artifact">;
+    did: z.ZodString;
+    content: z.ZodObject<{
+        $schema: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>;
+type ArtifactPayload = z.infer<typeof ArtifactPayload>;
+/**
+ * Countersign: standalone witness attestation referencing a target operation by CID.
+ *
+ * `relation` is an OPEN-namespace tag naming the nature of the attestation
+ * (e.g. `coauthors`, `endorses`, `witnessed`, `holds`, `received`). It is an
+ * arbitrary bounded string — recognized values carry social meaning to clients,
+ * unrecognized values MUST be preserved and ignored. Optional, so a bare witness
+ * attestation (no relation) encodes identically (CID-neutral).
+ */
+declare const CountersignPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"countersign">;
+    did: z.ZodString;
+    targetCID: z.ZodString;
+    relation: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>;
+type CountersignPayload = z.infer<typeof CountersignPayload>;
+/** Revocation: signed credential revocation artifact, gossiped on the proof plane */
+declare const RevocationPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"revocation">;
+    did: z.ZodString;
+    credentialCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$loose>;
+type RevocationPayload = z.infer<typeof RevocationPayload>;
+/**
+ * Max byte length of a credit-claim JWS token — the claim's aggregate size bound,
+ * the same register as MAX_CREDENTIAL_SIZE (measured over the serialized token,
+ * checked before any decode as a DoS guard). Claims are small by construction:
+ * two identifiers, a role string, and a timestamp. Deliberately tight because
+ * claims travel INSIDE document bytes — a document embedding many credits carries
+ * one token per claimed entry, so a generous per-claim cap would multiply into the
+ * document blob. `role` therefore carries no separate length cap; this aggregate
+ * is the single byte arbiter. VALIDITY-determining: MUST match the Go reference
+ * (maxCreditClaimSize in credit_claim.go).
+ */
+declare const MAX_CREDIT_CLAIM_SIZE = 4096;
+/**
+ * Credit claim: a claimant's signed assertion that it holds a named role on a
+ * content chain. A document-plane artifact — it is NOT gossiped and relays are not
+ * credit-claim aware; a claim travels inside the document bytes that embed it (see
+ * `specs/CREDITS.md`).
+ *
+ * `contentId` is the binder — the STABLE 31-char content chain id, never a
+ * documentCID or a chain head CID. Binding to the chain (not a document) is what
+ * makes a claim survive edits verbatim and avoids the circularity of a claim
+ * embedded in the very document it would otherwise commit to. It is shape-validated
+ * against the same 31-char contentId form used for anchor dispatch, so an artifact
+ * CID (immutable, chainless, and therefore unable to host a credits slot) is
+ * rejected uniformly across implementations.
+ *
+ * `role` is an OPEN-namespace tag compared by exact, case-sensitive byte equality —
+ * it is the third component of the entry↔claim bind, so no normalization of any kind
+ * is applied to it.
+ *
+ * `asOfDocumentCID` is an OPTIONAL content-strength flavor: the claimant pins the
+ * document state it is crediting itself on. Omitted by default, and omission is
+ * CID-neutral (undefined strips under canonical CBOR). Consumers that ignore it are
+ * conformant — the bind never depends on it. When the key IS present it MUST be a
+ * non-empty string: an empty string is a distinct, CID-changing encoding from an
+ * absent field, so accepting it would mean two different claim CIDs for the same
+ * (absent-flavor) statement.
+ *
+ * `did` is constrained to the `did:` prefix and non-empty, which is STRICTER than
+ * the sibling wire payloads above (`RevocationPayload.did`, `ContentOperation.did`
+ * are bare strings). That is deliberate, not drift: the published
+ * `credit-claim/v1` JSON Schema already mandates `^did:`, so leaving the zod schema
+ * permissive forked validity between the schema, this verifier, and the Go twin.
+ * The check is a PREFIX check, not full did:dfos validation — a claimant DID is not
+ * required to be a did:dfos identifier.
+ */
+declare const CreditClaimPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"credit-claim">;
+    contentId: z.ZodString;
+    did: z.ZodString;
+    role: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    asOfDocumentCID: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+type CreditClaimPayload = z.infer<typeof CreditClaimPayload>;
+
+/**
+ * Max byte length of a credential JWS token — the credential's analog of
+ * MAX_OPERATION_SIZE. Credentials are EXEMPT from the 64 KiB operation cap (a
+ * maximum-depth 16-credential delegation chain embeds each parent token in `prf` and
+ * legitimately exceeds it), so they carry their own larger ceiling. Measured
+ * over the serialized leaf token, which contains the entire nested chain, so one
+ * bound caps the whole delegation. A DoS guard on the nested `prf` structure;
+ * generous (a max-depth chain serializes to well under this). VALIDITY-
+ * determining: MUST match the Go reference (maxCredentialSize in jwt.go).
+ */
+declare const MAX_CREDENTIAL_SIZE = 262144;
+/** Single attenuation entry — resource + action pair */
+declare const Attenuation: z.ZodObject<{
+    resource: z.ZodString;
+    action: z.ZodString;
+}, z.core.$loose>;
+type Attenuation = z.infer<typeof Attenuation>;
+/** DFOS credential payload — UCAN-style authorization token */
+declare const DFOSCredentialPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"DFOSCredential">;
+    iss: z.ZodString;
+    aud: z.ZodString;
+    att: z.ZodArray<z.ZodObject<{
+        resource: z.ZodString;
+        action: z.ZodString;
+    }, z.core.$loose>>;
+    prf: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exp: z.ZodNumber;
+    iat: z.ZodNumber;
+}, z.core.$loose>;
+type DFOSCredentialPayload = z.infer<typeof DFOSCredentialPayload>;
+/** Claims for a DID-signed auth token (relay AuthN) */
+declare const AuthTokenClaims: z.ZodObject<{
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodString;
+    exp: z.ZodNumber;
+    iat: z.ZodNumber;
+}, z.core.$loose>;
+type AuthTokenClaims = z.infer<typeof AuthTokenClaims>;
+
+interface VerifiedDFOSCredential {
+    /** Issuer DID */
+    iss: string;
+    /** Audience DID or "*" for public */
+    aud: string;
+    /** Attenuations — resource + action pairs */
+    att: Attenuation[];
+    /** Parent credential JWS tokens */
+    prf: string[];
+    /** Expiry (unix seconds) */
+    exp: number;
+    /** Issued at (unix seconds) */
+    iat: number;
+    /** CID of the credential payload (for revocation references) */
+    credentialCID: string;
+    /** kid from the JWS header */
+    signerKeyId: string;
+}
+interface VerifiedDelegationChain {
+    /** The leaf credential */
+    credential: VerifiedDFOSCredential;
+    /** All credentials in the chain, from leaf to root */
+    chain: VerifiedDFOSCredential[];
+    /** The root DID that ultimately authorized the chain */
+    rootDID: string;
+}
+/**
+ * Check whether a credential (leaf or any parent) has been revoked.
+ *
+ * `asOfUnix` selects WHICH question is being asked, and the two are different
+ * decisions: **acceptance is a freshness decision; verification of committed
+ * history is a validity decision.**
+ *
+ * - **Omitted, or `<= 0` (timeless)** — "is this credential revoked as far as you
+ *   know right now?". The freshness question. Used by acceptance gates: relay
+ *   ingest (do not admit a NEW operation authorized by a credential we already
+ *   know to be revoked) and live read-path authorization. Non-positive instants
+ *   are timeless because the Go twin uses `0` as its in-band sentinel and cannot
+ *   express "as of epoch 0"; the degenerate case (an operation dated at or before
+ *   1970) therefore gets the stricter answer in both languages.
+ * - **Positive (as-of)** — "was this credential already revoked at `asOfUnix`?".
+ *   The validity question. Return true only if a revocation exists AND its
+ *   signed `createdAt` is ≤ `asOfUnix`. Used when verifying operations already
+ *   committed to a chain, where `asOfUnix` is the operation's own `createdAt`.
+ *   A revocation signed AFTER an operation does not invalidate it — see
+ *   CREDENTIALS.md "Revocation Scope".
+ *
+ * An implementation that ignores `asOfUnix` degrades to the timeless answer,
+ * which is always the stricter (safe) direction — it can only reject history
+ * that as-of semantics would accept.
+ */
+type RevocationChecker = (issuerDID: string, credentialCID: string, asOfUnix?: number) => Promise<boolean>;
+/**
+ * Create a signed DFOS credential
+ *
+ * The credential is a JWS with `typ: "did:dfos:credential"` and a CID in the
+ * protected header for revocation addressability.
+ */
+declare const createDFOSCredential: (options: {
+    issuerDID: string;
+    /** Audience DID, or "*" for public credentials */
+    audienceDID: string;
+    att: Attenuation[];
+    /** Parent credential JWS tokens (for delegation chains) */
+    prf?: string[];
+    /** Expiry — unix seconds */
+    exp: number;
+    /** Signer function */
+    signer: (message: Uint8Array) => Promise<Uint8Array>;
+    /** Key ID (without DID prefix — just the key_xxx part) */
+    keyId: string;
+    /** Issued-at override — unix seconds (defaults to Date.now()) */
+    iat?: number;
+}) => Promise<string>;
+/**
+ * Verify a DFOS credential — signature, schema, expiry, CID integrity
+ *
+ * Does NOT verify the delegation chain. Use `verifyDelegationChain` for full
+ * chain verification including attenuation enforcement.
+ */
+declare const verifyDFOSCredential: (jwsToken: string, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** Current time in seconds (defaults to Date.now() / 1000) */
+    now?: number;
+}) => Promise<VerifiedDFOSCredential>;
+/**
+ * Verify a full delegation chain — walk `prf`, confirm monotonic attenuation,
+ * verify each credential's signature, and confirm the chain roots at `rootDID`.
+ *
+ * The chain is walked from the leaf credential upward through each parent in
+ * `prf`. At each hop: the child's `iss` must match a parent's `aud` (or the
+ * parent's `aud` must be `"*"`), the child's `att` must be attenuated from the
+ * parent's `att`, and the child's `exp` must not exceed the parent's `exp`.
+ *
+ * The chain terminates when a credential has `prf: []` (root credential). The
+ * root credential's `iss` must equal `rootDID`.
+ */
+declare const verifyDelegationChain: (credential: VerifiedDFOSCredential, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** The expected root authority DID (e.g., content chain creator) */
+    rootDID: string;
+    /** Current time in seconds (defaults to Date.now() / 1000) */
+    now?: number;
+    /** Check if a credential has been revoked (checked at every level of the chain) */
+    isRevoked?: RevocationChecker;
+    /**
+     * As-of basis for the revocation check, unix seconds. Kept SEPARATE from
+     * `now` (the expiry basis) on purpose: expiry and revocation are two
+     * different decisions, and a caller evaluating expiry against a deterministic
+     * basis does not automatically want history-relative revocation. Omitted =
+     * timeless revocation (current knowledge). See `RevocationChecker`.
+     */
+    asOfUnix?: number;
+}) => Promise<VerifiedDelegationChain>;
+/**
+ * Check if `childAtt` is a valid attenuation of `parentAtt`
+ *
+ * Every entry in `childAtt` must be covered by at least one entry in
+ * `parentAtt`. Coverage rules:
+ *
+ * - `chain:X` covered by `chain:X` (exact match)
+ * - `chain:X` covered by `chain:*` (narrowing from wildcard — valid)
+ * - `chain:*` covered by `chain:*` (exact match)
+ * - `chain:*` NOT covered by `chain:X` (widening — invalid)
+ * - Actions: child action set must be a subset of parent action set
+ */
+declare const isAttenuated: (parentAtt: Attenuation[], childAtt: Attenuation[]) => boolean;
+/**
+ * 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.
+ */
+declare const matchesResource: (att: Attenuation[], resource: string, action: string) => Promise<boolean>;
+/**
+ * Decode a DFOS credential JWS without verifying the signature
+ *
+ * Returns null if the token is malformed or payload is invalid.
+ */
+declare const decodeDFOSCredentialUnsafe: (jwsToken: string) => {
+    header: {
+        alg: string;
+        typ: string;
+        kid: string;
+        cid: string;
+    };
+    payload: DFOSCredentialPayload;
+} | null;
+declare class CredentialVerificationError extends Error {
+    constructor(message: string);
+}
+
+export { ARTIFACT_CID_ANCHOR_RE as A, CONTENT_ID_ANCHOR_RE as C, DFOSCredentialPayload as D, IdentityOperation as I, MAX_ARTIFACT_PAYLOAD_SIZE as M, type RevocationChecker as R, ServiceEntry as S, type VerifiedDFOSCredential as V, ArtifactPayload as a, Attenuation as b, AuthTokenClaims as c, ContentOperation as d, CountersignPayload as e, CredentialVerificationError as f, CreditClaimPayload as g, Iso8601 as h, MAX_CREDENTIAL_SIZE as i, MAX_CREDIT_CLAIM_SIZE as j, MAX_OPERATION_SIZE as k, MAX_SERVICES_ENTRIES as l, MAX_SERVICES_PAYLOAD_SIZE as m, MultikeyPublicKey as n, RevocationPayload as o, ServicesArray as p, type Signer as q, type VerifiedDelegationChain as r, VerifiedIdentity as s, createDFOSCredential as t, decodeDFOSCredentialUnsafe as u, isAttenuated as v, matchesResource as w, parseProtocolTimestampUnix as x, verifyDFOSCredential as y, verifyDelegationChain as z };