@metalabel/dfos-protocol 0.37.0 → 0.38.0

package/dist/chunk-NXQW6EBF.js

@@ -0,0 +1,672 @@
+import {
+  assertJwsProfile,
+  base64urlDecode,
+  base64urlEncode,
+  createJws,
+  dagCborCanonicalEncode,
+  decodeJwsUnsafe,
+  sha256,
+  verifyJws
+} from "./chunk-4LG2GEB2.js";
+
+// src/credentials/schemas.ts
+import { z } from "zod";
+var MAX_ATT = 32;
+var MAX_PRF = 1;
+var MAX_CREDENTIAL_SIZE = 262144;
+var Attenuation = z.looseObject({
+  resource: z.string().min(1),
+  action: z.string().min(1)
+});
+var DFOSCredentialPayload = z.looseObject({
+  version: z.literal(1),
+  type: z.literal("DFOSCredential"),
+  /** Issuer DID */
+  iss: z.string().min(1),
+  /** Audience DID or "*" for public credentials */
+  aud: z.string().min(1),
+  /** Attenuations — resource + action pairs */
+  att: z.array(Attenuation).min(1).max(MAX_ATT),
+  /** Parent credential JWS tokens (for delegation chains) */
+  prf: z.array(z.string()).max(MAX_PRF).default([]),
+  /** Expiration — unix seconds */
+  exp: z.number().int().positive(),
+  /** Issued at — unix seconds */
+  iat: z.number().int().positive()
+});
+
+// src/chain/multikey.ts
+import { base58btc } from "multiformats/bases/base58";
+var ED25519_PUB_PREFIX = new Uint8Array([237, 1]);
+var ED25519_PRIV_PREFIX = new Uint8Array([128, 38]);
+var ED25519_PUB_MULTICODEC = 237;
+var ED25519_PRIV_MULTICODEC = 4864;
+var encodeEd25519Multikey = (publicKeyBytes) => {
+  if (publicKeyBytes.length !== 32) {
+    throw new Error(`expected 32-byte Ed25519 public key, got ${publicKeyBytes.length}`);
+  }
+  const prefixed = new Uint8Array(ED25519_PUB_PREFIX.length + publicKeyBytes.length);
+  prefixed.set(ED25519_PUB_PREFIX);
+  prefixed.set(publicKeyBytes, ED25519_PUB_PREFIX.length);
+  return base58btc.encode(prefixed);
+};
+var decodeMultikey = (multibase) => {
+  const bytes = base58btc.decode(multibase);
+  if (bytes.length < 2) {
+    throw new Error("multikey too short");
+  }
+  if (bytes[0] === ED25519_PUB_PREFIX[0] && bytes[1] === ED25519_PUB_PREFIX[1]) {
+    const keyBytes = bytes.slice(2);
+    if (keyBytes.length !== 32) {
+      throw new Error(`expected 32-byte Ed25519 public key, got ${keyBytes.length}`);
+    }
+    return { keyBytes, codec: ED25519_PUB_MULTICODEC };
+  }
+  if (bytes[0] === ED25519_PRIV_PREFIX[0] && bytes[1] === ED25519_PRIV_PREFIX[1]) {
+    const keyBytes = bytes.slice(2);
+    if (keyBytes.length !== 32) {
+      throw new Error(`expected 32-byte Ed25519 private key, got ${keyBytes.length}`);
+    }
+    return { keyBytes, codec: ED25519_PRIV_MULTICODEC };
+  }
+  throw new Error(
+    `unsupported multikey codec: [0x${bytes[0]?.toString(16)}, 0x${bytes[1]?.toString(16)}]`
+  );
+};
+
+// src/credentials/api-auth.ts
+var REQUEST_PROOF_JWS_TYP = "did:dfos:request-proof";
+var IDENTITY_PROOF_JWS_TYP = "did:dfos:identity-proof";
+var EMPTY_BODY_SHA256 = "47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU";
+var MAX_REQUEST_PROOF_SIZE = 4096;
+var DEFAULT_PROOF_WINDOW_SECONDS = 60;
+var DEFAULT_PROOF_SKEW_SECONDS = 60;
+var MAX_PROOF_FRESHNESS_SPAN_SECONDS = 300;
+var MAX_BODY_BYTES = 1048576;
+var DFOS_AUTH_SCHEME = "DFOS";
+var REQUEST_PROOF_SHAPE = {
+  label: "request proof",
+  typ: REQUEST_PROOF_JWS_TYP,
+  credentialed: true
+};
+var IDENTITY_PROOF_SHAPE = {
+  label: "identity proof",
+  typ: IDENTITY_PROOF_JWS_TYP,
+  credentialed: false
+};
+var encoder = new TextEncoder();
+var EMPTY_BODY = new Uint8Array(0);
+var UPPERCASE_METHOD = /^[A-Z0-9!#$%&'*+.^_`|~-]+$/;
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+var CTL_OR_SPACE = /[\u0000-\u0020\u007f]/;
+var BASE64URL_32 = /^[A-Za-z0-9_-]{43}$/;
+var EXTRA_MEMBER_NAME = /^[A-Za-z0-9_.-]+$/;
+var CANONICAL_MEMBERS = /* @__PURE__ */ new Set(["method", "host", "path", "bodyHash", "credentialCID", "iat"]);
+var assertNoLoneSurrogate = (value, field, label) => {
+  if (LONE_SURROGATE.test(value)) {
+    throw new Error(`invalid ${label}: ${field} must be well-formed Unicode`);
+  }
+};
+var validateProofPayload = (value, shape) => {
+  const label = shape.label;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`invalid ${label}: expected a JSON object`);
+  }
+  const raw = value;
+  const stringFields = ["method", "host", "path", "bodyHash"];
+  if (shape.credentialed) stringFields.push("credentialCID");
+  for (const field of stringFields) {
+    if (typeof raw[field] !== "string" || raw[field] === "") {
+      throw new Error(`invalid ${label}: ${field} must be a non-empty string`);
+    }
+    assertNoLoneSurrogate(raw[field], field, label);
+  }
+  const method = raw["method"];
+  if (!UPPERCASE_METHOD.test(method)) {
+    throw new Error(`invalid ${label}: method must be an uppercase HTTP method token`);
+  }
+  const host = raw["host"];
+  if (host !== host.toLowerCase() || /[\s/\\?#]/.test(host)) {
+    throw new Error(`invalid ${label}: host must be a lowercase authority, without a scheme`);
+  }
+  const path = raw["path"];
+  if (!path.startsWith("/")) {
+    throw new Error(`invalid ${label}: path must begin with /`);
+  }
+  if (path.includes("#")) {
+    throw new Error(`invalid ${label}: path must not carry a fragment`);
+  }
+  if (CTL_OR_SPACE.test(path)) {
+    throw new Error(`invalid ${label}: path must not contain whitespace or control characters`);
+  }
+  const bodyHash = raw["bodyHash"];
+  if (!BASE64URL_32.test(bodyHash) || base64urlEncode(base64urlDecode(bodyHash)) !== bodyHash) {
+    throw new Error(
+      `invalid ${label}: bodyHash must be the canonical unpadded base64url of 32 bytes`
+    );
+  }
+  const iat = raw["iat"];
+  if (typeof iat !== "number" || !Number.isSafeInteger(iat) || iat <= 0) {
+    throw new Error(`invalid ${label}: iat must be a positive integer`);
+  }
+  return shape.credentialed ? { method, host, path, bodyHash, credentialCID: raw["credentialCID"], iat } : { method, host, path, bodyHash, iat };
+};
+var validateRequestProofPayload = (value) => {
+  const parsed = validateProofPayload(value, REQUEST_PROOF_SHAPE);
+  return {
+    method: parsed.method,
+    host: parsed.host,
+    path: parsed.path,
+    bodyHash: parsed.bodyHash,
+    credentialCID: parsed.credentialCID,
+    iat: parsed.iat
+  };
+};
+var validateIdentityProofPayload = (value) => {
+  const parsed = validateProofPayload(value, IDENTITY_PROOF_SHAPE);
+  return {
+    method: parsed.method,
+    host: parsed.host,
+    path: parsed.path,
+    bodyHash: parsed.bodyHash,
+    iat: parsed.iat
+  };
+};
+var canonicalExtraMembers = (extra, label) => {
+  if (!extra) return [];
+  const entries = [];
+  for (const name of Object.keys(extra)) {
+    if (!EXTRA_MEMBER_NAME.test(name)) {
+      throw new Error(
+        `invalid ${label}: additive member name ${JSON.stringify(name)} is not [A-Za-z0-9_.-]+`
+      );
+    }
+    if (CANONICAL_MEMBERS.has(name)) {
+      throw new Error(`invalid ${label}: ${name} is a canonical member and cannot be added`);
+    }
+    const value = extra[name];
+    if (typeof value !== "string" || value === "") {
+      throw new Error(`invalid ${label}: additive member ${name} must be a non-empty string`);
+    }
+    assertNoLoneSurrogate(value, name, label);
+    entries.push([name, value]);
+  }
+  entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  return entries;
+};
+var proofSigningInput = (parsed, shape, extra) => encoder.encode(JSON.stringify(proofPayloadObject(parsed, shape, extra)));
+var proofPayloadObject = (parsed, shape, extra) => {
+  const out = {
+    method: parsed.method,
+    host: parsed.host,
+    path: parsed.path,
+    bodyHash: parsed.bodyHash
+  };
+  if (shape.credentialed) out["credentialCID"] = parsed.credentialCID;
+  out["iat"] = parsed.iat;
+  for (const [name, value] of extra) out[name] = value;
+  return out;
+};
+var apiRequestSigningInput = (payload, extraMembers) => proofSigningInput(
+  validateProofPayload(payload, REQUEST_PROOF_SHAPE),
+  REQUEST_PROOF_SHAPE,
+  canonicalExtraMembers(extraMembers, REQUEST_PROOF_SHAPE.label)
+);
+var apiIdentitySigningInput = (payload, extraMembers) => proofSigningInput(
+  validateProofPayload(payload, IDENTITY_PROOF_SHAPE),
+  IDENTITY_PROOF_SHAPE,
+  canonicalExtraMembers(extraMembers, IDENTITY_PROOF_SHAPE.label)
+);
+var sha256BodyHash = (body) => base64urlEncode(sha256(body));
+var parseDfosAuthorization = (header) => {
+  if (!header) return null;
+  const trimmed = header.trim();
+  const space = trimmed.search(/\s/);
+  if (space < 0) return null;
+  if (trimmed.slice(0, space).toLowerCase() !== "dfos") return null;
+  const token = trimmed.slice(space).trim();
+  if (token === "" || /\s/.test(token)) return null;
+  return token;
+};
+var signApiRequest = async (input) => {
+  const payload = validateRequestProofPayload({
+    method: input.method,
+    host: input.host,
+    path: input.path,
+    bodyHash: sha256BodyHash(input.body ?? EMPTY_BODY),
+    credentialCID: input.credentialCID,
+    iat: input.iat ?? Math.floor(Date.now() / 1e3)
+  });
+  if (!input.kid.includes("#")) {
+    throw new Error("invalid request proof: kid must be a DID URL");
+  }
+  const extra = canonicalExtraMembers(input.extraMembers, REQUEST_PROOF_SHAPE.label);
+  const proof = await createJws({
+    header: { alg: "EdDSA", typ: REQUEST_PROOF_JWS_TYP, kid: input.kid },
+    payload: proofPayloadObject(payload, REQUEST_PROOF_SHAPE, extra),
+    sign: input.sign
+  });
+  if (proof.length > MAX_REQUEST_PROOF_SIZE) {
+    throw new Error(`request proof exceeds max size: ${proof.length} > ${MAX_REQUEST_PROOF_SIZE}`);
+  }
+  return { proof, payload };
+};
+var signApiIdentityRequest = async (input) => {
+  const payload = validateIdentityProofPayload({
+    method: input.method,
+    host: input.host,
+    path: input.path,
+    bodyHash: sha256BodyHash(input.body ?? EMPTY_BODY),
+    iat: input.iat ?? Math.floor(Date.now() / 1e3)
+  });
+  if (!input.kid.includes("#")) {
+    throw new Error("invalid identity proof: kid must be a DID URL");
+  }
+  const extra = canonicalExtraMembers(input.extraMembers, IDENTITY_PROOF_SHAPE.label);
+  const proof = await createJws({
+    header: { alg: "EdDSA", typ: IDENTITY_PROOF_JWS_TYP, kid: input.kid },
+    payload: proofPayloadObject(payload, IDENTITY_PROOF_SHAPE, extra),
+    sign: input.sign
+  });
+  if (proof.length > MAX_REQUEST_PROOF_SIZE) {
+    throw new Error(`identity proof exceeds max size: ${proof.length} > ${MAX_REQUEST_PROOF_SIZE}`);
+  }
+  return { proof, payload };
+};
+var buildApiAuthHeaders = (input) => ({
+  Authorization: `${DFOS_AUTH_SCHEME} ${input.proof}`,
+  "X-Credential": input.credential
+});
+var buildApiIdentityHeaders = (input) => ({
+  Authorization: `${DFOS_AUTH_SCHEME} ${input.proof}`
+});
+var ApiRequestVerifyError = class extends Error {
+  reason;
+  phase;
+  /** Recommended HTTP status: 401 proof-invalid, 403 credential-invalid, 503 unverifiable, 500 config. */
+  status;
+  constructor(reason, phase, status, message) {
+    super(message);
+    this.name = "ApiRequestVerifyError";
+    this.reason = reason;
+    this.phase = phase;
+    this.status = status;
+  }
+};
+var invalidProof = (message) => new ApiRequestVerifyError("invalid", "proof", 401, message);
+var unverifiableProof = (message) => new ApiRequestVerifyError("unverifiable", "proof", 503, message);
+var misconfiguredProof = (message) => new ApiRequestVerifyError("config", "config", 500, message);
+var assertProofVerifierConfig = (input) => {
+  const window = input.windowSeconds ?? DEFAULT_PROOF_WINDOW_SECONDS;
+  const skew = input.skewSeconds ?? DEFAULT_PROOF_SKEW_SECONDS;
+  for (const [name, value] of [
+    ["windowSeconds", window],
+    ["skewSeconds", skew]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw misconfiguredProof(`${name} must be a non-negative integer`);
+    }
+  }
+  if (window + skew > MAX_PROOF_FRESHNESS_SPAN_SECONDS) {
+    throw misconfiguredProof(
+      `proof freshness span W + S exceeds ${MAX_PROOF_FRESHNESS_SPAN_SECONDS} seconds: ${window} + ${skew}`
+    );
+  }
+  const maxBodyBytes = input.maxBodyBytes ?? MAX_BODY_BYTES;
+  if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes < 0) {
+    throw misconfiguredProof("maxBodyBytes must be a non-negative integer");
+  }
+  return { window, skew, maxBodyBytes };
+};
+var verifyProofEnvelope = async (input, shape, resolvePresenter) => {
+  const { window, skew, maxBodyBytes } = assertProofVerifierConfig(input);
+  if (input.proof.length > MAX_REQUEST_PROOF_SIZE) {
+    throw invalidProof(
+      `${shape.label} exceeds max size: ${input.proof.length} > ${MAX_REQUEST_PROOF_SIZE}`
+    );
+  }
+  const decoded = decodeJwsUnsafe(input.proof);
+  if (!decoded) throw invalidProof(`failed to decode ${shape.label} JWS`);
+  const rawHeader = decoded.header;
+  if (typeof rawHeader !== "object" || rawHeader === null || Array.isArray(rawHeader)) {
+    throw invalidProof(`${shape.label} protected header must be an object`);
+  }
+  assertJwsProfile(rawHeader, invalidProof);
+  if (decoded.header.typ !== shape.typ) {
+    throw invalidProof(`invalid typ: expected ${shape.typ}, got ${decoded.header.typ}`);
+  }
+  const kid = decoded.header.kid;
+  if (typeof kid !== "string" || !kid.includes("#")) {
+    throw invalidProof(`${shape.label} kid must be a DID URL`);
+  }
+  const presenterDID = kid.substring(0, kid.indexOf("#"));
+  const presenterKeyId = kid.substring(kid.indexOf("#") + 1);
+  const payloadSegment = input.proof.split(".")[1];
+  if (payloadSegment === void 0) throw invalidProof(`failed to decode ${shape.label} payload`);
+  let payload;
+  let rawPayload;
+  try {
+    const source = new TextDecoder("utf-8", { fatal: true }).decode(
+      base64urlDecode(payloadSegment)
+    );
+    const parsed = JSON.parse(source);
+    payload = validateProofPayload(parsed, shape);
+    rawPayload = parsed;
+  } catch (err) {
+    throw invalidProof(err instanceof Error ? err.message : `invalid ${shape.label} payload`);
+  }
+  const now = Math.floor((input.now ? input.now() : Date.now()) / 1e3);
+  if (now - payload.iat > window) throw invalidProof(`${shape.label} is stale`);
+  if (payload.iat - now > skew) {
+    throw invalidProof(`${shape.label} iat is beyond the clock-skew allowance`);
+  }
+  if (payload.method !== input.method) throw invalidProof(`${shape.label} method mismatch`);
+  if (payload.host !== input.host) throw invalidProof(`${shape.label} host mismatch`);
+  if (payload.path !== input.path) throw invalidProof(`${shape.label} path mismatch`);
+  const body = input.body ?? EMPTY_BODY;
+  if (body.length > maxBodyBytes) {
+    throw new ApiRequestVerifyError(
+      "invalid",
+      "proof",
+      413,
+      `request body exceeds max size: ${body.length} > ${maxBodyBytes}`
+    );
+  }
+  if (payload.bodyHash !== sha256BodyHash(body)) {
+    throw invalidProof(`${shape.label} bodyHash mismatch`);
+  }
+  let state;
+  try {
+    state = await resolvePresenter(presenterDID);
+  } catch (err) {
+    if (err instanceof ApiRequestVerifyError) throw err;
+    throw unverifiableProof(
+      `failed to resolve ${shape.label} presenter: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!state) {
+    throw unverifiableProof(`failed to resolve ${shape.label} presenter: ${presenterDID}`);
+  }
+  if (state.isDeleted) throw invalidProof(`${shape.label} presenter identity is deleted`);
+  const key = state.keys.find((candidate) => candidate.id === presenterKeyId);
+  if (!key) throw invalidProof(`${shape.label} signing key is not a current key of the presenter`);
+  try {
+    verifyJws({ token: input.proof, publicKey: decodeMultikey(key.publicKeyMultibase).keyBytes });
+  } catch (err) {
+    throw invalidProof(err instanceof Error ? err.message : `invalid ${shape.label} signature`);
+  }
+  return { payload, rawPayload, presenterDID, kid, now };
+};
+var verifyIdentityProofEnvelope = (input, resolvePresenter) => verifyProofEnvelope(input, IDENTITY_PROOF_SHAPE, resolvePresenter);
+var verifyRequestProofEnvelope = (input, resolvePresenter) => verifyProofEnvelope(input, REQUEST_PROOF_SHAPE, resolvePresenter);
+
+// src/credentials/dfos-credential.ts
+var resolveKeyFromIdentity = (identity, kid) => {
+  const hashIdx = kid.indexOf("#");
+  if (hashIdx < 0) throw new CredentialVerificationError("kid must be a DID URL");
+  const keyId = kid.substring(hashIdx + 1);
+  const allKeys = [...identity.authKeys, ...identity.assertKeys, ...identity.controllerKeys];
+  const key = allKeys.find((k) => k.id === keyId);
+  if (!key) {
+    throw new CredentialVerificationError(`key ${keyId} not found on identity ${identity.did}`);
+  }
+  const { keyBytes } = decodeMultikey(key.publicKeyMultibase);
+  return keyBytes;
+};
+var createDFOSCredential = async (options) => {
+  const kid = `${options.issuerDID}#${options.keyId}`;
+  const now = options.iat ?? Math.floor(Date.now() / 1e3);
+  const payload = {
+    version: 1,
+    type: "DFOSCredential",
+    iss: options.issuerDID,
+    aud: options.audienceDID,
+    att: options.att,
+    prf: options.prf ?? [],
+    exp: options.exp,
+    iat: now
+  };
+  const parseResult = DFOSCredentialPayload.safeParse(payload);
+  if (!parseResult.success) {
+    const messages = parseResult.error.issues.map((e) => e.message).join(", ");
+    throw new Error(`invalid credential payload: ${messages}`);
+  }
+  const encoded = await dagCborCanonicalEncode(payload);
+  const credentialCID = encoded.cid.toString();
+  const jwsToken = await createJws({
+    header: { alg: "EdDSA", typ: "did:dfos:credential", kid, cid: credentialCID },
+    payload,
+    sign: options.signer
+  });
+  return jwsToken;
+};
+var verifyDFOSCredential = async (jwsToken, options) => {
+  if (jwsToken.length > MAX_CREDENTIAL_SIZE) {
+    throw new CredentialVerificationError(
+      `credential exceeds max size: ${jwsToken.length} > ${MAX_CREDENTIAL_SIZE}`
+    );
+  }
+  const decoded = decodeJwsUnsafe(jwsToken);
+  if (!decoded) throw new CredentialVerificationError("failed to decode credential JWS");
+  if (decoded.header.typ !== "did:dfos:credential") {
+    throw new CredentialVerificationError(`invalid typ: ${decoded.header.typ}`);
+  }
+  const result = DFOSCredentialPayload.safeParse(decoded.payload);
+  if (!result.success) {
+    const messages = result.error.issues.map((e) => e.message).join(", ");
+    throw new CredentialVerificationError(`invalid credential payload: ${messages}`);
+  }
+  const payload = result.data;
+  const kid = decoded.header.kid;
+  const hashIdx = kid.indexOf("#");
+  if (hashIdx < 0) throw new CredentialVerificationError("credential kid must be a DID URL");
+  const kidDid = kid.substring(0, hashIdx);
+  if (kidDid !== payload.iss) {
+    throw new CredentialVerificationError("credential kid DID does not match iss");
+  }
+  const identity = await options.resolveIdentity(payload.iss);
+  if (!identity) {
+    throw new CredentialVerificationError(`issuer identity not found: ${payload.iss}`);
+  }
+  if (identity.isDeleted) {
+    throw new CredentialVerificationError(`issuer identity is deleted: ${payload.iss}`);
+  }
+  const publicKey = resolveKeyFromIdentity(identity, kid);
+  try {
+    verifyJws({ token: jwsToken, publicKey });
+  } catch {
+    throw new CredentialVerificationError("invalid credential signature");
+  }
+  const encoded = await dagCborCanonicalEncode(payload);
+  const credentialCID = encoded.cid.toString();
+  if (!decoded.header.cid) {
+    throw new CredentialVerificationError("missing cid in credential header");
+  }
+  if (decoded.header.cid !== credentialCID) {
+    throw new CredentialVerificationError("credential cid mismatch");
+  }
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  if (payload.iat > now) {
+    throw new CredentialVerificationError("credential not yet valid (iat is in the future)");
+  }
+  if (payload.exp <= now) {
+    throw new CredentialVerificationError("credential expired");
+  }
+  return {
+    iss: payload.iss,
+    aud: payload.aud,
+    att: payload.att,
+    prf: payload.prf,
+    exp: payload.exp,
+    iat: payload.iat,
+    credentialCID,
+    signerKeyId: kid
+  };
+};
+var verifyDelegationChain = async (credential, options) => {
+  const chain = [credential];
+  let current = credential;
+  const maxDepth = 16;
+  for (let depth = 0; depth < maxDepth; depth++) {
+    if (current.prf.length === 0) {
+      if (current.iss !== options.rootDID) {
+        throw new CredentialVerificationError(
+          `delegation chain root issuer ${current.iss} does not match expected root ${options.rootDID}`
+        );
+      }
+      return { credential, chain, rootDID: options.rootDID };
+    }
+    if (current.prf.length > 1) {
+      throw new CredentialVerificationError(
+        "delegation chain: multi-parent credentials are not supported (prf must have at most one entry)"
+      );
+    }
+    const parent = await verifyDFOSCredential(current.prf[0], {
+      resolveIdentity: options.resolveIdentity,
+      ...options.now !== void 0 ? { now: options.now } : {}
+    });
+    if (options.isRevoked) {
+      const revoked = await options.isRevoked(parent.iss, parent.credentialCID, options.asOfUnix);
+      if (revoked) {
+        throw new CredentialVerificationError("parent credential in delegation chain is revoked");
+      }
+    }
+    if (parent.aud !== "*" && parent.aud !== current.iss) {
+      throw new CredentialVerificationError(
+        `delegation gap: parent credential audience ${parent.aud} does not match child issuer ${current.iss}`
+      );
+    }
+    if (current.exp > parent.exp) {
+      throw new CredentialVerificationError(
+        "delegation chain: child credential expiry exceeds parent expiry"
+      );
+    }
+    if (!isAttenuated(parent.att, current.att)) {
+      throw new CredentialVerificationError(
+        "delegation chain: child credential scope exceeds parent scope"
+      );
+    }
+    chain.push(parent);
+    current = parent;
+  }
+  throw new CredentialVerificationError("delegation chain too deep (max 16 credentials)");
+};
+var parseResource = (resource) => {
+  const colonIdx = resource.indexOf(":");
+  if (colonIdx < 0) return null;
+  return { type: resource.substring(0, colonIdx), id: resource.substring(colonIdx + 1) };
+};
+var parseActions = (action) => new Set(
+  action.split(",").map((a) => a.trim()).filter((a) => a !== "")
+);
+var isAttenuated = (parentAtt, childAtt) => {
+  return childAtt.every((childEntry) => {
+    const childRes = parseResource(childEntry.resource);
+    if (!childRes) return false;
+    const childActions = parseActions(childEntry.action);
+    return parentAtt.some((parentEntry) => {
+      const parentRes = parseResource(parentEntry.resource);
+      if (!parentRes) return false;
+      const parentActions = parseActions(parentEntry.action);
+      for (const a of childActions) {
+        if (!parentActions.has(a)) return false;
+      }
+      if (parentRes.type === "chain" && parentRes.id === "*") {
+        return childRes.type === "chain";
+      }
+      if (childRes.type === "chain" && childRes.id === "*") {
+        return false;
+      }
+      if (childRes.type === "chain" && parentRes.type === "chain") {
+        return childRes.id === parentRes.id;
+      }
+      if (childRes.type !== "chain" && parentRes.type !== "chain") {
+        return childEntry.resource === parentEntry.resource;
+      }
+      return false;
+    });
+  });
+};
+var matchesResource = async (att, resource, action) => {
+  const requestedRes = parseResource(resource);
+  if (!requestedRes) return false;
+  const requestedActions = parseActions(action);
+  for (const entry of att) {
+    const entryRes = parseResource(entry.resource);
+    if (!entryRes) continue;
+    const entryActions = parseActions(entry.action);
+    let actionsCovered = true;
+    for (const a of requestedActions) {
+      if (!entryActions.has(a)) {
+        actionsCovered = false;
+        break;
+      }
+    }
+    if (!actionsCovered) continue;
+    if (entryRes.type === "chain" && entryRes.id === "*" && requestedRes.type === "chain") {
+      return true;
+    }
+    if (entryRes.type === requestedRes.type && entryRes.id === requestedRes.id) {
+      return true;
+    }
+  }
+  return false;
+};
+var decodeDFOSCredentialUnsafe = (jwsToken) => {
+  const decoded = decodeJwsUnsafe(jwsToken);
+  if (!decoded) return null;
+  const result = DFOSCredentialPayload.safeParse(decoded.payload);
+  if (!result.success) return null;
+  return {
+    header: decoded.header,
+    payload: result.data
+  };
+};
+var CredentialVerificationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CredentialVerificationError";
+  }
+};
+
+export {
+  ED25519_PUB_MULTICODEC,
+  ED25519_PRIV_MULTICODEC,
+  encodeEd25519Multikey,
+  decodeMultikey,
+  MAX_CREDENTIAL_SIZE,
+  Attenuation,
+  DFOSCredentialPayload,
+  REQUEST_PROOF_JWS_TYP,
+  IDENTITY_PROOF_JWS_TYP,
+  EMPTY_BODY_SHA256,
+  MAX_REQUEST_PROOF_SIZE,
+  DEFAULT_PROOF_WINDOW_SECONDS,
+  DEFAULT_PROOF_SKEW_SECONDS,
+  MAX_PROOF_FRESHNESS_SPAN_SECONDS,
+  MAX_BODY_BYTES,
+  DFOS_AUTH_SCHEME,
+  canonicalExtraMembers,
+  apiRequestSigningInput,
+  apiIdentitySigningInput,
+  sha256BodyHash,
+  parseDfosAuthorization,
+  signApiRequest,
+  signApiIdentityRequest,
+  buildApiAuthHeaders,
+  buildApiIdentityHeaders,
+  ApiRequestVerifyError,
+  invalidProof,
+  unverifiableProof,
+  misconfiguredProof,
+  assertProofVerifierConfig,
+  verifyIdentityProofEnvelope,
+  verifyRequestProofEnvelope,
+  createDFOSCredential,
+  verifyDFOSCredential,
+  verifyDelegationChain,
+  isAttenuated,
+  matchesResource,
+  decodeDFOSCredentialUnsafe,
+  CredentialVerificationError
+};

package/dist/{chunk-W7IFQNUH.js → chunk-SGPSXM56.js}

@@ -5,7 +5,7 @@ import {
   matchesResource,
   verifyDFOSCredential,
   verifyDelegationChain
-} from "./chunk-XP644GQK.js";
+} from "./chunk-NXQW6EBF.js";
 import {
   assertJwsProfile,
   base64urlDecode,