@metalabel/dfos-protocol 0.50.0 → 0.52.0

package/README.md

@@ -38,17 +38,14 @@ import { signKeyProof, verifyKeyProof } from '@metalabel/dfos-protocol/key-proof
 
 ## Specifications
 
-| Document                                         | Description                                                                       |
-| ------------------------------------------------ | --------------------------------------------------------------------------------- |
-| [PROTOCOL.md](../../specs/PROTOCOL.md)           | Core protocol — chains, signatures, verification, test vectors                    |
-| [DID-METHOD.md](../../specs/DID-METHOD.md)       | W3C DID method specification for `did:dfos`                                       |
-| [CONTENT-MODEL.md](../../specs/CONTENT-MODEL.md) | Standard content schemas (post, profile)                                          |
-| [CREDENTIALS.md](../../specs/CREDENTIALS.md)     | UCAN-style authorization credentials for the DFOS protocol                        |
-| [CREDITS.md](../../specs/CREDITS.md)             | Verifiable attribution for DFOS content                                           |
-| [SIGNING.md](../../specs/SIGNING.md)             | A transport-agnostic way for one party to ask another to produce a DFOS signature |
-| [SIWD.md](../../specs/SIWD.md)                   | Sign In With DFOS — cryptographic identity verification for third-party apps      |
-| [API-AUTH.md](../../specs/API-AUTH.md)           | Proof-of-possession authentication for credential-gated HTTP APIs                 |
-| [KEY-PROOF.md](../../specs/KEY-PROOF.md)         | Challenge-bound, single-shot proof that a candidate key is held                   |
+| Document                                         | Description                                                                     |
+| ------------------------------------------------ | ------------------------------------------------------------------------------- |
+| [PROTOCOL.md](../../specs/PROTOCOL.md)           | Core protocol — chains, signatures, key possession, verification, test vectors  |
+| [DID-METHOD.md](../../specs/DID-METHOD.md)       | W3C DID method specification for `did:dfos`                                     |
+| [CONTENT-MODEL.md](../../specs/CONTENT-MODEL.md) | Standard content schemas (post, profile) and verifiable attribution             |
+| [CREDENTIALS.md](../../specs/CREDENTIALS.md)     | UCAN-style authorization credentials for the DFOS protocol                      |
+| [RELAY.md](../../specs/RELAY.md)                 | The relay HTTP surface, including the sign-request envelope and signing mailbox |
+| [INTEGRATIONS.md](../../specs/INTEGRATIONS.md)   | Sign in, API authentication, origin binding, and key ceremonies                 |
 
 Release history lives at https://github.com/metalabel/dfos/releases.
 

package/dist/chain/index.d.ts

@@ -1,5 +1,5 @@
-import { I as IdentityOperation, u as Signer, w as VerifiedIdentity, S as ServiceEntry, c as ContentOperation, R as RevocationChecker, d as CountersignPayload, a as ArtifactPayload } from '../dfos-credential-BtiYPqBT.js';
-export { A as ARTIFACT_CID_ANCHOR_RE, C as CONTENT_ID_ANCHOR_RE, f as CreditClaimPayload, g as DeclaredKeyState, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_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 RevocationPayload, s as ServicesArray, t as SignRequestPayload, x as VoidKeyMembership, F as parseProtocolTimestampUnix } from '../dfos-credential-BtiYPqBT.js';
+import { I as IdentityOperation, v as Signer, x as VerifiedIdentity, S as ServiceEntry, c as ContentOperation, R as ResolvedIdentity, r as RevocationChecker, d as CountersignPayload, a as ArtifactPayload } from '../dfos-credential-j-kHtFvG.js';
+export { A as ARTIFACT_CID_ANCHOR_RE, C as CONTENT_ID_ANCHOR_RE, f as CreditClaimPayload, g as DeclaredKeyState, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_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, s as RevocationPayload, t as ServicesArray, u as SignRequestPayload, y as VoidKeyMembership, G as parseProtocolTimestampUnix } from '../dfos-credential-j-kHtFvG.js';
 import 'zod';
 
 /** Ed25519 public key multicodec value */
@@ -22,6 +22,17 @@ declare const decodeMultikey: (multibase: string) => {
     keyBytes: Uint8Array;
     codec: number;
 };
+/**
+ * Decode a Multikey multibase string that MUST carry an Ed25519 PUBLIC key
+ *
+ * `decodeMultikey` also accepts the `ed25519-priv` prefix and reports it in
+ * `codec`, which a caller that destructures only `{ keyBytes }` silently
+ * discards — so a private-key-tagged multibase string would verify as if it were
+ * a public key, where the Go reference (DecodeMultikey) accepts the 0xed01
+ * prefix and nothing else. This is the decode every signature path takes, so the
+ * codec assertion cannot be forgotten at the next call site.
+ */
+declare const decodeEd25519PublicMultikey: (multibase: string) => Uint8Array;
 
 /**
  * Derive a prefixed chain identifier from CID bytes
@@ -54,13 +65,26 @@ declare const signIdentityOperation: (input: {
  * Verify a log of JWS identity operations and derive the identity
  *
  * Walks the chain from genesis, verifying signatures and chain integrity, and
- * folds the possession proofs alongside. Returns the final verified identity
- * state: EFFECTIVE key arrays, with the declared arrays and the void memberships
+ * folds the possession proofs alongside. Returns the verified identity state:
+ * EFFECTIVE key arrays, with the declared arrays and the void memberships
  * beside them.
+ *
+ * THE BASIS SELECTS WHICH STATE COMES BACK, never how much of the log is
+ * verified. With `asOf` set, the whole log is walked and validated exactly as
+ * without it, and the state returned is the one the last operation dated at or
+ * before the basis folds to — the identity's state as of that instant
+ * (PROTOCOL, Time basis). The comparison is byte-wise on the `createdAt`
+ * strings, per PROTOCOL's Comparison basis. A basis earlier than genesis has no
+ * state to name and throws, and so does an empty basis.
  */
 declare const verifyIdentityChain: (input: {
     didPrefix: string;
     log: string[];
+    /**
+     * Basis time, in the `createdAt` grammar. Omitted = the chain head, which is
+     * the state as of now.
+     */
+    asOf?: string;
 }) => Promise<VerifiedIdentity>;
 /**
  * Verify a single new operation against already-verified identity state
@@ -70,10 +94,13 @@ declare const verifyIdentityChain: (input: {
  * verified genesis). This function performs one signature verification and one
  * state transition — constant time regardless of chain length.
  *
- * Note: key-ID consistency across the full chain history is NOT checked here.
- * That invariant is established during genesis verification and maintained by
- * the protocol's key consistency rules. Periodic full re-verification can
- * audit this property.
+ * KEY-ID CONSISTENCY IS CHECKED HERE, on the same terms as the full walk. The
+ * trusted state carries `seenKeys` — the id-to-material binding the walk already
+ * enforced — so an operation that re-points an existing key id at new material
+ * is REJECTED on this path exactly as a replay of the same two operations would
+ * reject it. Without that the fast path would accept a chain its own
+ * re-verification refuses, and a relay's linear path is the path almost every
+ * operation takes.
  *
  * THE POSSESSION FOLD RUNS HERE TOO, and it needs both halves of the trusted
  * state: the EFFECTIVE arrays (to know what an introduction is a transition out
@@ -164,8 +191,11 @@ declare const signContentOperation: (input: {
  */
 declare const verifyContentChain: (input: {
     log: string[];
-    /** Resolve a kid (DID URL) to the raw Ed25519 public key bytes */
-    resolveKey: (kid: string) => Promise<Uint8Array>;
+    /**
+     * Resolve a kid (DID URL) to the raw Ed25519 public key bytes, in the signing
+     * identity's state as of `basis` — each operation's own `createdAt`.
+     */
+    resolveKey: (kid: string, basis?: string) => Promise<Uint8Array>;
     /**
      * Enforce creator-sovereignty authorization. When true, non-creator signers
      * must include a DFOS credential in the operation's `authorization` field
@@ -173,10 +203,11 @@ declare const verifyContentChain: (input: {
      */
     enforceAuthorization?: boolean;
     /**
-     * Resolve a DID to a VerifiedIdentity. Required when `enforceAuthorization`
-     * is true, as credential verification needs identity resolution.
+     * Resolve a DID to a ResolvedIdentity as of `basis`. Required when
+     * `enforceAuthorization` is true, as credential verification needs identity
+     * resolution.
      */
-    resolveIdentity?: (did: string) => Promise<VerifiedIdentity | undefined>;
+    resolveIdentity?: (did: string, basis?: string) => Promise<ResolvedIdentity | undefined>;
     /**
      * Check whether a credential (leaf or parent) has been revoked. Called with
      * `asOfUnix` = each operation's own `createdAt`, so a fold of committed
@@ -198,12 +229,15 @@ declare const verifyContentExtensionFromTrustedState: (input: {
     lastCreatedAt: string;
     /** The new JWS operation to verify */
     newOp: string;
-    /** Resolve a kid (DID URL) to the raw Ed25519 public key bytes */
-    resolveKey: (kid: string) => Promise<Uint8Array>;
+    /**
+     * Resolve a kid (DID URL) to the raw Ed25519 public key bytes, in the signing
+     * identity's state as of `basis` — the new operation's own `createdAt`.
+     */
+    resolveKey: (kid: string, basis?: string) => Promise<Uint8Array>;
     /** Enforce creator-sovereignty authorization (see verifyContentChain) */
     enforceAuthorization?: boolean;
-    /** Resolve a DID to a VerifiedIdentity. Required when enforceAuthorization is true. */
-    resolveIdentity?: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** Resolve a DID to a ResolvedIdentity as of `basis`. Required when enforceAuthorization is true. */
+    resolveIdentity?: (did: string, basis?: string) => Promise<ResolvedIdentity | undefined>;
     /**
      * Check whether a credential (leaf or parent) has been revoked. Called with
      * `asOfUnix` = the new operation's own `createdAt`. See `RevocationChecker`.
@@ -242,10 +276,15 @@ declare const signCountersignature: (input: {
  * Checks: valid signature, CID integrity, payload schema. Does NOT check
  * whether the target exists or whether the witness differs from the target
  * author — those are relay-level semantic checks.
+ *
+ * The countersignature's own `createdAt` is the basis: a committed statement
+ * resolves its signer in the state that held when it was signed (PROTOCOL, Time
+ * basis).
  */
 declare const verifyCountersignature: (input: {
     jwsToken: string;
-    resolveKey: (kid: string) => Promise<Uint8Array>;
+    /** Resolve a kid to key bytes in the signer's state as of `basis`. */
+    resolveKey: (kid: string, basis?: string) => Promise<Uint8Array>;
 }) => Promise<VerifiedCountersignature>;
 
 interface VerifiedArtifact {
@@ -267,10 +306,14 @@ declare const signArtifact: (input: {
 }>;
 /**
  * Verify an artifact JWS — signature, CID, payload schema, size limit
+ *
+ * The artifact's own `createdAt` is the basis: a committed statement resolves
+ * its signer in the state that held when it was signed (PROTOCOL, Time basis).
  */
 declare const verifyArtifact: (input: {
     jwsToken: string;
-    resolveKey: (kid: string) => Promise<Uint8Array>;
+    /** Resolve a kid to key bytes in the signer's state as of `basis`. */
+    resolveKey: (kid: string, basis?: string) => Promise<Uint8Array>;
 }) => Promise<VerifiedArtifact>;
 
 interface VerifiedRevocation {
@@ -299,10 +342,14 @@ declare const signRevocation: (input: {
 }>;
 /**
  * Verify a revocation JWS — signature, CID, payload schema, signer match
+ *
+ * The revocation's own `createdAt` is the basis: a committed statement resolves
+ * its signer in the state that held when it was signed (PROTOCOL, Time basis).
  */
 declare const verifyRevocation: (input: {
     jwsToken: string;
-    resolveKey: (kid: string) => Promise<Uint8Array>;
+    /** Resolve a kid to key bytes in the signer's state as of `basis`. */
+    resolveKey: (kid: string, basis?: string) => Promise<Uint8Array>;
 }) => Promise<VerifiedRevocation>;
 
 interface VerifiedCreditClaim {
@@ -322,7 +369,7 @@ interface VerifiedCreditClaim {
     claimCID: string;
 }
 /**
- * The four states a `credits[]` entry resolves to (see `specs/CREDITS.md`).
+ * The four states a `credits[]` entry resolves to (see `specs/CONTENT-MODEL.md`).
  *
  * `invalid` and `unverifiable` are deliberately distinct and MUST NOT be
  * collapsed: `invalid` means "checked and failed" (a positive signal that
@@ -493,7 +540,8 @@ declare const buildSignRequest: (input: {
     requestCID: string;
 }>;
 /**
- * Verify a sign-request envelope in SIGNING.md's exact 1–9 order.
+ * Verify a sign-request envelope in RELAY.md, Envelope verification's exact 1–9
+ * order.
  *
  * `resolveIdentity` supplies CURRENT identity state. A missing identity or
  * resolver failure is `unverifiable`; a deleted identity, missing current key,
@@ -512,4 +560,4 @@ declare const assertCanonicalSignRequestPayload: (payloadTyp: string, payloadByt
     subject: string;
 }) => void;
 
-export { type AnchorKind, ArtifactPayload, ContentOperation, CountersignPayload, type CreditClaimFailureReason, CreditClaimVerifyError, type CreditEntry, type CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, IdentityOperation, RECOGNIZED_SERVICE_TYPES, ServiceEntry, type SignRequestFailureReason, SignRequestVerifyError, Signer, type VerifiedArtifact, type VerifiedContentChain, type VerifiedCountersignature, type VerifiedCreditClaim, type VerifiedCreditEntry, VerifiedIdentity, type VerifiedRevocation, type VerifiedSignRequest, anchorsByLabel, assertCanonicalSignRequestPayload, assertServicesWithinCap, buildSignRequest, classifyAnchor, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signCreditClaim, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyCreditClaim, verifyCreditEntry, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation, verifySignRequest };
+export { type AnchorKind, ArtifactPayload, ContentOperation, CountersignPayload, type CreditClaimFailureReason, CreditClaimVerifyError, type CreditEntry, type CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, IdentityOperation, RECOGNIZED_SERVICE_TYPES, ServiceEntry, type SignRequestFailureReason, SignRequestVerifyError, Signer, type VerifiedArtifact, type VerifiedContentChain, type VerifiedCountersignature, type VerifiedCreditClaim, type VerifiedCreditEntry, VerifiedIdentity, type VerifiedRevocation, type 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 };

package/dist/chain/index.js

@@ -52,16 +52,17 @@ import {
   verifyIdentityExtensionFromTrustedState,
   verifyRevocation,
   verifySignRequest
-} from "../chunk-JGFFADPR.js";
-import "../chunk-MHSBBYDO.js";
-import "../chunk-JVSC67DC.js";
+} from "../chunk-OU2DPHCN.js";
+import "../chunk-IV3TIYKP.js";
+import "../chunk-QRCOMLAP.js";
 import {
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
+  decodeEd25519PublicMultikey,
   decodeMultikey,
   encodeEd25519Multikey
-} from "../chunk-IDVYITX7.js";
-import "../chunk-4LG2GEB2.js";
+} from "../chunk-F7RHI2CK.js";
+import "../chunk-QTJZGXMH.js";
 export {
   ARTIFACT_CID_ANCHOR_RE,
   ArtifactPayload,
@@ -97,6 +98,7 @@ export {
   assertServicesWithinCap,
   buildSignRequest,
   classifyAnchor,
+  decodeEd25519PublicMultikey,
   decodeMultikey,
   deriveChainIdentifier,
   deriveContentId,

package/dist/{chunk-IDVYITX7.js → chunk-F7RHI2CK.js}

@@ -36,10 +36,18 @@ var decodeMultikey = (multibase) => {
     `unsupported multikey codec: [0x${bytes[0]?.toString(16)}, 0x${bytes[1]?.toString(16)}]`
   );
 };
+var decodeEd25519PublicMultikey = (multibase) => {
+  const { keyBytes, codec } = decodeMultikey(multibase);
+  if (codec !== ED25519_PUB_MULTICODEC) {
+    throw new Error("publicKeyMultibase is not an Ed25519 public key");
+  }
+  return keyBytes;
+};
 
 export {
   ED25519_PUB_MULTICODEC,
   ED25519_PRIV_MULTICODEC,
   encodeEd25519Multikey,
-  decodeMultikey
+  decodeMultikey,
+  decodeEd25519PublicMultikey
 };

package/dist/{chunk-MHSBBYDO.js → chunk-IV3TIYKP.js}

@@ -1,6 +1,6 @@
 import {
-  decodeMultikey
-} from "./chunk-IDVYITX7.js";
+  decodeEd25519PublicMultikey
+} from "./chunk-F7RHI2CK.js";
 import {
   assertJwsProfile,
   base64urlDecode,
@@ -10,7 +10,7 @@ import {
   decodeJwsUnsafe,
   sha256,
   verifyJws
-} from "./chunk-4LG2GEB2.js";
+} from "./chunk-QTJZGXMH.js";
 
 // src/credentials/schemas.ts
 import { z } from "zod";
@@ -355,7 +355,10 @@ var verifyProofEnvelope = async (input, shape, resolvePresenter) => {
   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 });
+    verifyJws({
+      token: input.proof,
+      publicKey: decodeEd25519PublicMultikey(key.publicKeyMultibase)
+    });
   } catch (err) {
     throw invalidProof(err instanceof Error ? err.message : `invalid ${shape.label} signature`);
   }
@@ -370,20 +373,26 @@ var isDependencyMissing = (err) => err instanceof Error && err.dependencyMissing
 var carryDependencyMissing = (cause, wrapped) => isDependencyMissing(cause) ? markDependencyMissing(wrapped) : wrapped;
 
 // src/credentials/dfos-credential.ts
-var resolveKeyFromIdentity = (identity, kid) => {
+var resolveKeyFromIdentity = (identity, kid, determinate) => {
   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 markDependencyMissing(
-      new CredentialVerificationError(`key ${keyId} not found on identity ${identity.did}`)
+    const miss = new CredentialVerificationError(
+      `unknown key ${keyId} on identity ${identity.did}`
     );
+    throw determinate ? miss : markDependencyMissing(miss);
   }
-  const { keyBytes } = decodeMultikey(key.publicKeyMultibase);
+  const keyBytes = decodeEd25519PublicMultikey(key.publicKeyMultibase);
   return keyBytes;
 };
+var basisUnixSeconds = (basis) => {
+  const ms = Date.parse(basis);
+  if (Number.isNaN(ms)) throw new CredentialVerificationError(`invalid basis time: ${basis}`);
+  return Math.floor(ms / 1e3);
+};
 var createDFOSCredential = async (options) => {
   const kid = `${options.issuerDID}#${options.keyId}`;
   const now = options.iat ?? Math.floor(Date.now() / 1e3);
@@ -435,7 +444,7 @@ var verifyDFOSCredential = async (jwsToken, options) => {
   if (kidDid !== payload.iss) {
     throw new CredentialVerificationError("credential kid DID does not match iss");
   }
-  const identity = await options.resolveIdentity(payload.iss);
+  const identity = await options.resolveIdentity(payload.iss, options.basis);
   if (!identity) {
     throw markDependencyMissing(
       new CredentialVerificationError(`issuer identity not found: ${payload.iss}`)
@@ -444,13 +453,13 @@ var verifyDFOSCredential = async (jwsToken, options) => {
   if (identity.isDeleted) {
     throw new CredentialVerificationError(`issuer identity is deleted: ${payload.iss}`);
   }
-  const publicKey = resolveKeyFromIdentity(identity, kid);
+  const publicKey = resolveKeyFromIdentity(identity, kid, identity.basisDeterminate === true);
   try {
     verifyJws({ token: jwsToken, publicKey });
   } catch {
     throw new CredentialVerificationError("invalid credential signature");
   }
-  const encoded = await dagCborCanonicalEncode(payload);
+  const encoded = await dagCborCanonicalEncode(decoded.payload);
   const credentialCID = encoded.cid.toString();
   if (!decoded.header.cid) {
     throw new CredentialVerificationError("missing cid in credential header");
@@ -458,11 +467,8 @@ var verifyDFOSCredential = async (jwsToken, options) => {
   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) {
+  const basisSeconds = options.basis !== void 0 ? basisUnixSeconds(options.basis) : options.nowUnix ?? Math.floor(Date.now() / 1e3);
+  if (payload.exp <= basisSeconds) {
     throw new CredentialVerificationError("credential expired");
   }
   return {
@@ -478,6 +484,7 @@ var verifyDFOSCredential = async (jwsToken, options) => {
 };
 var verifyDelegationChain = async (credential, options) => {
   const chain = [credential];
+  const revocationBasis = options.basis !== void 0 ? basisUnixSeconds(options.basis) : void 0;
   let current = credential;
   const maxDepth = 16;
   for (let depth = 0; depth < maxDepth; depth++) {
@@ -496,10 +503,11 @@ var verifyDelegationChain = async (credential, options) => {
     }
     const parent = await verifyDFOSCredential(current.prf[0], {
       resolveIdentity: options.resolveIdentity,
-      ...options.now !== void 0 ? { now: options.now } : {}
+      ...options.basis !== void 0 ? { basis: options.basis } : {},
+      ...options.nowUnix !== void 0 ? { nowUnix: options.nowUnix } : {}
     });
     if (options.isRevoked) {
-      const revoked = await options.isRevoked(parent.iss, parent.credentialCID, options.asOfUnix);
+      const revoked = await options.isRevoked(parent.iss, parent.credentialCID, revocationBasis);
       if (revoked) {
         throw new CredentialVerificationError("parent credential in delegation chain is revoked");
       }
@@ -529,8 +537,9 @@ var parseResource = (resource) => {
   if (colonIdx < 0) return null;
   return { type: resource.substring(0, colonIdx), id: resource.substring(colonIdx + 1) };
 };
+var ASCII_TRIM_RE = /^[\t\n\v\f\r ]+|[\t\n\v\f\r ]+$/g;
 var parseActions = (action) => new Set(
-  action.split(",").map((a) => a.trim()).filter((a) => a !== "")
+  action.split(",").map((a) => a.replace(ASCII_TRIM_RE, "")).filter((a) => a !== "")
 );
 var isAttenuated = (parentAtt, childAtt) => {
   return childAtt.every((childEntry) => {