@metalabel/dfos-protocol 0.24.0 → 0.26.0

package/README.md

@@ -5,9 +5,14 @@ Ed25519 signed chain primitives for cryptographic identity and verifiable conten
 ## Install
 
 ```bash
-npm install @metalabel/dfos-protocol
+npm install @metalabel/dfos-protocol zod
 ```
 
+`zod` is a peer dependency. The package exports Zod schema objects directly
+(`IdentityOperation`, `ContentOperation`, `MultikeyPublicKey`, …) so you can
+compose them into your own schemas — which only works if your app and this
+package share one Zod install.
+
 ## Usage
 
 ```ts
@@ -21,11 +26,11 @@ import { createJws, dagCborCanonicalEncode, verifyJws } from '@metalabel/dfos-pr
 
 ## Subpath Exports
 
-| Export                                 | Description                                                               |
-| -------------------------------------- | ------------------------------------------------------------------------- |
-| `@metalabel/dfos-protocol/chain`       | Identity & content chains, services, artifacts, countersigns, revocations |
-| `@metalabel/dfos-protocol/credentials` | Auth tokens (DID-signed JWT) and DFOS credentials for authorization       |
-| `@metalabel/dfos-protocol/crypto`      | Ed25519, JWS, JWT, dag-cbor, base64url, ID generation                     |
+| Export                                 | Description                                                                              |
+| -------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `@metalabel/dfos-protocol/chain`       | Identity & content chains, services, artifacts, countersigns, revocations, credit claims |
+| `@metalabel/dfos-protocol/credentials` | Auth tokens (DID-signed JWT) and DFOS credentials for authorization                      |
+| `@metalabel/dfos-protocol/crypto`      | Ed25519, JWS, JWT, dag-cbor, base64url, ID generation                                    |
 
 ## Specifications
 

package/dist/chain/index.d.ts

@@ -1,5 +1,5 @@
-import { I as IdentityOperation, i as Signer, V as VerifiedIdentity, S as ServiceEntry, b as ContentOperation, c as CountersignPayload, a as ArtifactPayload } from '../schemas-BXye25k7.js';
-export { A as ARTIFACT_CID_ANCHOR_RE, C as CONTENT_ID_ANCHOR_RE, M as MAX_ARTIFACT_PAYLOAD_SIZE, d as MAX_OPERATION_SIZE, e as MAX_SERVICES_ENTRIES, f as MAX_SERVICES_PAYLOAD_SIZE, g as MultikeyPublicKey, R as RevocationPayload, h as ServicesArray } from '../schemas-BXye25k7.js';
+import { I as IdentityOperation, q as Signer, s as VerifiedIdentity, S as ServiceEntry, d as ContentOperation, R as RevocationChecker, e as CountersignPayload, a as ArtifactPayload } from '../dfos-credential-CAYCqUCP.js';
+export { A as ARTIFACT_CID_ANCHOR_RE, C as CONTENT_ID_ANCHOR_RE, g as CreditClaimPayload, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, j as MAX_CREDIT_CLAIM_SIZE, k as MAX_OPERATION_SIZE, l as MAX_SERVICES_ENTRIES, m as MAX_SERVICES_PAYLOAD_SIZE, n as MultikeyPublicKey, o as RevocationPayload, p as ServicesArray, x as parseProtocolTimestampUnix } from '../dfos-credential-CAYCqUCP.js';
 import 'zod';
 
 /** Ed25519 public key multicodec value */
@@ -168,10 +168,11 @@ declare const verifyContentChain: (input: {
      */
     resolveIdentity?: (did: string) => Promise<VerifiedIdentity | undefined>;
     /**
-     * Check whether a credential (leaf or parent) has been revoked. Threaded onto
-     * the WRITE path so revoked credentials no longer authorize writes.
+     * Check whether a credential (leaf or parent) has been revoked. Called with
+     * `asOfUnix` = each operation's own `createdAt`, so a fold of committed
+     * history is stable under later revocations. See `RevocationChecker`.
      */
-    isRevoked?: (issuerDID: string, credentialCID: string) => Promise<boolean>;
+    isRevoked?: RevocationChecker;
 }) => Promise<VerifiedContentChain>;
 /**
  * Verify a single new content operation against already-verified chain state
@@ -193,8 +194,11 @@ declare const verifyContentExtensionFromTrustedState: (input: {
     enforceAuthorization?: boolean;
     /** Resolve a DID to a VerifiedIdentity. Required when enforceAuthorization is true. */
     resolveIdentity?: (did: string) => Promise<VerifiedIdentity | undefined>;
-    /** Check whether a credential (leaf or parent) has been revoked. */
-    isRevoked?: (issuerDID: string, credentialCID: string) => Promise<boolean>;
+    /**
+     * Check whether a credential (leaf or parent) has been revoked. Called with
+     * `asOfUnix` = the new operation's own `createdAt`. See `RevocationChecker`.
+     */
+    isRevoked?: RevocationChecker;
 }) => Promise<{
     state: VerifiedContentChain;
     operationCID: string;
@@ -291,4 +295,146 @@ declare const verifyRevocation: (input: {
     resolveKey: (kid: string) => Promise<Uint8Array>;
 }) => Promise<VerifiedRevocation>;
 
-export { type AnchorKind, ArtifactPayload, ContentOperation, CountersignPayload, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, IdentityOperation, RECOGNIZED_SERVICE_TYPES, ServiceEntry, Signer, type VerifiedArtifact, type VerifiedContentChain, type VerifiedCountersignature, VerifiedIdentity, type VerifiedRevocation, anchorsByLabel, assertServicesWithinCap, classifyAnchor, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation };
+interface VerifiedCreditClaim {
+    /** The claimant DID that signed this claim */
+    did: string;
+    /** The content chain this claim binds to — the 31-char contentId */
+    contentId: string;
+    /** The claimed role, compared by exact byte equality */
+    role: string;
+    /** Timestamp of the claim */
+    createdAt: string;
+    /** Optional pinned document state the claimant credited itself on */
+    asOfDocumentCID?: string;
+    /** kid from the JWS header */
+    signerKeyId: string;
+    /** CID of the claim artifact itself */
+    claimCID: string;
+}
+/**
+ * The four states a `credits[]` entry resolves to (see `specs/CREDITS.md`).
+ *
+ * `invalid` and `unverifiable` are deliberately distinct and MUST NOT be
+ * collapsed: `invalid` means "checked and failed" (a positive signal that
+ * something is wrong), `unverifiable` means "could not check" (the claim may be
+ * perfectly valid). Rendering `invalid` as `unclaimed` launders a failure into
+ * the ordinary case.
+ */
+type CreditEntryState = 'claimed' | 'unclaimed' | 'invalid' | 'unverifiable';
+/** Why a credit-claim verification failed — the consumer-visible verdict split */
+type CreditClaimFailureReason = 'invalid' | 'unverifiable';
+/**
+ * Thrown by `verifyCreditClaim`, carrying the spec's verdict as a FIELD.
+ *
+ * Consumers MUST branch on `reason`, never on the message text. The message is
+ * diagnostic prose and may be reworded at any time; `reason` is the contract.
+ */
+declare class CreditClaimVerifyError extends Error {
+    readonly reason: CreditClaimFailureReason;
+    constructor(reason: CreditClaimFailureReason, message: string);
+}
+/** A `credits[]` entry as it appears in document bytes — every field untrusted */
+interface CreditEntry {
+    did?: unknown;
+    role?: unknown;
+    name?: unknown;
+    claim?: unknown;
+}
+interface VerifiedCreditEntry {
+    /** The resolved state of this entry */
+    state: CreditEntryState;
+    /** Human-readable diagnosis — display prose, never a branch target */
+    note: string;
+    /** The verified claim, present only when `state` is 'claimed' */
+    claim?: VerifiedCreditClaim;
+}
+/**
+ * Sign a credit claim as a JWS
+ *
+ * The claim binds to the content chain's stable `contentId`, not to a document —
+ * so a signed claim stays valid verbatim across every subsequent edit of the
+ * chain. Callers SHOULD sign a given (contentId, did, role) triple exactly once
+ * and reuse the token: re-signing mints a fresh `createdAt`, which changes the
+ * claim bytes, which changes the embedding document's CID. Pass `createdAt` to
+ * re-derive a previously issued claim's exact bytes (the same override register
+ * as `createDFOSCredential`'s `iat`).
+ *
+ * The `kid` is derived from `did` + `keyId` here rather than accepted from the
+ * caller, so a claim whose kid DID disagrees with its payload DID — the shape
+ * every verifier MUST reject — is unrepresentable at sign time.
+ */
+declare const signCreditClaim: (input: {
+    contentId: string;
+    did: string;
+    role: string;
+    /** Optional document state the claimant pins its credit to */
+    asOfDocumentCID?: string;
+    /**
+     * ISO 8601 override; defaults to now. NORMALIZED to whole seconds either way —
+     * a sub-second component you pass is discarded, not signed. See
+     * `normalizeClaimCreatedAt`.
+     */
+    createdAt?: string;
+    signer: Signer;
+    keyId: string;
+}) => Promise<{
+    jwsToken: string;
+    claimCID: string;
+}>;
+/**
+ * Verify a credit claim JWS — size, signature, CID, payload schema, signer match
+ *
+ * Prefer `verifyCreditEntry` when you have a `credits[]` entry: this function
+ * checks only the `contentId` component of the three-component bind, leaving
+ * `did` and `role` to the caller.
+ *
+ * Pass `expectedContentId` to enforce the anti-replay half of the bind: without
+ * it, a valid claim lifted from one chain's document verifies when replayed in
+ * another chain's document. A consumer verifying a credits entry ALWAYS knows
+ * which chain it is reading, so it should always pass it. Omit the option
+ * entirely to skip the check; passing an EMPTY STRING is an error, never a skip
+ * (a zero-valued content id is a bug, not a request for unbound semantics).
+ *
+ * `resolveIdentity` MUST supply the claimant's historical keys — see
+ * `resolveKeyFromIdentity` above for why, and what breaks if it does not.
+ *
+ * Failures throw `CreditClaimVerifyError` carrying `reason: 'invalid' |
+ * 'unverifiable'`. Branch on that field, never on the message.
+ *
+ * **A deleted claimant still verifies.** This function does not consult
+ * `identity.isDeleted`, and that omission is the doctrine, not an oversight: a
+ * credit claim is a statement of historical fact, and the fact does not stop
+ * having happened when the claimant tombstones its identity. Credentials take
+ * the opposite rule (a deleted issuer's credentials are dead) because a
+ * credential is a live grant of authority, and authority must die with the
+ * identity that holds it. Attribution is history; authorization is standing.
+ */
+declare const verifyCreditClaim: (jwsToken: string, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** The content chain the embedding document belongs to — enforces the binder */
+    expectedContentId?: string;
+}) => Promise<VerifiedCreditClaim>;
+/**
+ * Resolve one `credits[]` entry to its spec state, performing the FULL bind
+ *
+ * This is the call most consumers want. `verifyCreditClaim` alone checks only
+ * the `contentId` component; the `did` and `role` comparisons are what make a
+ * claim an assertion about THIS entry, and skipping them verifies the wrong
+ * proposition — that some valid claim exists, not that it is about this credit.
+ * Shipping the whole comparison here is deliberate: the safe call should be the
+ * easy one.
+ *
+ * `contentId` is the chain whose document contains the entry. It is REQUIRED,
+ * because a consumer reading an entry always knows it, and without it the claim
+ * is replayable across chains.
+ *
+ * Never throws for claim-level problems — every outcome is one of the four
+ * states. It throws only when `contentId` is missing, which is a caller bug
+ * rather than a verdict about the entry.
+ */
+declare const verifyCreditEntry: (entry: CreditEntry, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    contentId: string;
+}) => Promise<VerifiedCreditEntry>;
+
+export { type AnchorKind, ArtifactPayload, ContentOperation, CountersignPayload, type CreditClaimFailureReason, CreditClaimVerifyError, type CreditEntry, type CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, IdentityOperation, RECOGNIZED_SERVICE_TYPES, ServiceEntry, Signer, type VerifiedArtifact, type VerifiedContentChain, type VerifiedCountersignature, type VerifiedCreditClaim, type VerifiedCreditEntry, VerifiedIdentity, type VerifiedRevocation, anchorsByLabel, assertServicesWithinCap, classifyAnchor, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signCreditClaim, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyCreditClaim, verifyCreditEntry, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation };

package/dist/chain/index.js

@@ -4,8 +4,12 @@ import {
   CONTENT_ID_ANCHOR_RE,
   ContentOperation,
   CountersignPayload,
+  CreditClaimPayload,
+  CreditClaimVerifyError,
   IdentityOperation,
+  Iso8601,
   MAX_ARTIFACT_PAYLOAD_SIZE,
+  MAX_CREDIT_CLAIM_SIZE,
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
@@ -21,26 +25,30 @@ import {
   deriveChainIdentifier,
   deriveContentId,
   isRecognizedServiceType,
+  parseProtocolTimestampUnix,
   relayEndpoints,
   signArtifact,
   signContentOperation,
   signCountersignature,
+  signCreditClaim,
   signIdentityOperation,
   signRevocation,
   verifyArtifact,
   verifyContentChain,
   verifyContentExtensionFromTrustedState,
   verifyCountersignature,
+  verifyCreditClaim,
+  verifyCreditEntry,
   verifyIdentityChain,
   verifyIdentityExtensionFromTrustedState,
   verifyRevocation
-} from "../chunk-4EJCATUC.js";
+} from "../chunk-3USIENKC.js";
 import {
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
   decodeMultikey,
   encodeEd25519Multikey
-} from "../chunk-FMHROCFH.js";
+} from "../chunk-PGFHCBGH.js";
 import "../chunk-4QQ5HK5M.js";
 export {
   ARTIFACT_CID_ANCHOR_RE,
@@ -48,10 +56,14 @@ export {
   CONTENT_ID_ANCHOR_RE,
   ContentOperation,
   CountersignPayload,
+  CreditClaimPayload,
+  CreditClaimVerifyError,
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
   IdentityOperation,
+  Iso8601,
   MAX_ARTIFACT_PAYLOAD_SIZE,
+  MAX_CREDIT_CLAIM_SIZE,
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
@@ -69,16 +81,20 @@ export {
   deriveContentId,
   encodeEd25519Multikey,
   isRecognizedServiceType,
+  parseProtocolTimestampUnix,
   relayEndpoints,
   signArtifact,
   signContentOperation,
   signCountersignature,
+  signCreditClaim,
   signIdentityOperation,
   signRevocation,
   verifyArtifact,
   verifyContentChain,
   verifyContentExtensionFromTrustedState,
   verifyCountersignature,
+  verifyCreditClaim,
+  verifyCreditEntry,
   verifyIdentityChain,
   verifyIdentityExtensionFromTrustedState,
   verifyRevocation

package/dist/{chunk-4EJCATUC.js → chunk-3USIENKC.js}

@@ -5,7 +5,7 @@ import {
   matchesResource,
   verifyDFOSCredential,
   verifyDelegationChain
-} from "./chunk-FMHROCFH.js";
+} from "./chunk-PGFHCBGH.js";
 import {
   createJws,
   dagCborCanonicalEncode,
@@ -59,6 +59,11 @@ var ServicesArray = z.array(ServiceEntry).max(MAX_SERVICES_ENTRIES).refine(
   "service entry ids must be unique"
 );
 var Iso8601 = z.iso.datetime({ offset: false, precision: 3 });
+var parseProtocolTimestampUnix = (value) => {
+  if (!Iso8601.safeParse(value).success) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? Math.floor(ms / 1e3) : null;
+};
 var CIDString = z.string();
 var IdentityCreate = z.looseObject({
   version: z.literal(1),
@@ -159,6 +164,16 @@ var RevocationPayload = z.looseObject({
   credentialCID: CIDString,
   createdAt: Iso8601
 });
+var MAX_CREDIT_CLAIM_SIZE = 4096;
+var CreditClaimPayload = z.looseObject({
+  version: z.literal(1),
+  type: z.literal("credit-claim"),
+  contentId: z.string().regex(CONTENT_ID_ANCHOR_RE, "contentId must be a 31-char content chain id"),
+  did: z.string().regex(/^did:/, "did must be a DID (did: prefix)"),
+  role: z.string().min(1),
+  createdAt: Iso8601,
+  asOfDocumentCID: CIDString.min(1, "asOfDocumentCID must be non-empty when present").optional()
+});
 
 // src/chain/derivation.ts
 var deriveChainIdentifier = (cidBytes, prefix) => {
@@ -467,14 +482,14 @@ var verifyOperationAuthorization = async (input) => {
     resolveIdentity: input.resolveIdentity,
     now: opCreatedAtUnix
   });
-  if (input.isRevoked && await input.isRevoked(credential.iss, credential.credentialCID)) {
+  if (input.isRevoked && await input.isRevoked(credential.iss, credential.credentialCID, opCreatedAtUnix)) {
     throw new Error("credential is revoked");
   }
   await verifyDelegationChain(credential, {
     resolveIdentity: input.resolveIdentity,
     rootDID: input.creatorDID,
     now: opCreatedAtUnix,
-    ...input.isRevoked ? { isRevoked: input.isRevoked } : {}
+    ...input.isRevoked ? { isRevoked: input.isRevoked, asOfUnix: opCreatedAtUnix } : {}
   });
   if (credential.aud !== "*" && credential.aud !== input.operationDID) {
     throw new Error(
@@ -850,6 +865,186 @@ var verifyRevocation = async (input) => {
   };
 };
 
+// src/chain/credit-claim.ts
+var CreditClaimVerifyError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "CreditClaimVerifyError";
+    this.reason = reason;
+  }
+};
+var invalid = (message) => new CreditClaimVerifyError("invalid", message);
+var unverifiable = (message) => new CreditClaimVerifyError("unverifiable", message);
+var resolveKeyFromIdentity = (identity, kid) => {
+  const hashIdx = kid.indexOf("#");
+  if (hashIdx < 0) throw invalid("credit claim 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 invalid(`key ${keyId} not found on identity ${identity.did}`);
+  }
+  const { keyBytes } = decodeMultikey(key.publicKeyMultibase);
+  return keyBytes;
+};
+var normalizeClaimCreatedAt = (createdAt) => {
+  if (createdAt === void 0) {
+    return (/* @__PURE__ */ new Date()).toISOString().replace(/\d{3}Z$/, "000Z");
+  }
+  const ms = Date.parse(createdAt);
+  if (Number.isNaN(ms)) {
+    throw new Error(`invalid credit claim payload: unparseable createdAt: ${createdAt}`);
+  }
+  return new Date(Math.floor(ms / 1e3) * 1e3).toISOString();
+};
+var signCreditClaim = async (input) => {
+  const kid = `${input.did}#${input.keyId}`;
+  const now = normalizeClaimCreatedAt(input.createdAt);
+  if (input.asOfDocumentCID === "") {
+    throw new Error(
+      "invalid credit claim payload: asOfDocumentCID must be non-empty when present (omit the field instead)"
+    );
+  }
+  const payload = {
+    version: 1,
+    type: "credit-claim",
+    contentId: input.contentId,
+    did: input.did,
+    role: input.role,
+    createdAt: now,
+    // omitted when absent — undefined strips under canonical CBOR, so a claim
+    // without the flavor encodes identically to one that never had the field
+    ...input.asOfDocumentCID !== void 0 ? { asOfDocumentCID: input.asOfDocumentCID } : {}
+  };
+  const parseResult = CreditClaimPayload.safeParse(payload);
+  if (!parseResult.success) {
+    const messages = parseResult.error.issues.map((e) => e.message).join(", ");
+    throw new Error(`invalid credit claim payload: ${messages}`);
+  }
+  const encoded = await dagCborCanonicalEncode(payload);
+  const claimCID = encoded.cid.toString();
+  const jwsToken = await createJws({
+    header: { alg: "EdDSA", typ: "did:dfos:credit-claim", kid, cid: claimCID },
+    payload,
+    sign: input.signer
+  });
+  if (jwsToken.length > MAX_CREDIT_CLAIM_SIZE) {
+    throw new Error(`credit claim exceeds max size: ${jwsToken.length} > ${MAX_CREDIT_CLAIM_SIZE}`);
+  }
+  return { jwsToken, claimCID };
+};
+var verifyCreditClaim = async (jwsToken, options) => {
+  if (options.expectedContentId === "") {
+    throw invalid(
+      "expectedContentId must be a non-empty contentId \u2014 omit the option for the unbound form"
+    );
+  }
+  if (jwsToken.length > MAX_CREDIT_CLAIM_SIZE) {
+    throw invalid(`credit claim exceeds max size: ${jwsToken.length} > ${MAX_CREDIT_CLAIM_SIZE}`);
+  }
+  const decoded = decodeJwsUnsafe(jwsToken);
+  if (!decoded) throw invalid("failed to decode credit claim JWS");
+  const rawHeader = decoded.header;
+  if (typeof rawHeader["typ"] !== "string" || typeof rawHeader["kid"] !== "string") {
+    throw invalid("credit claim header must carry a string typ and kid");
+  }
+  if (decoded.header.typ !== "did:dfos:credit-claim") {
+    throw invalid(`invalid credit claim typ: ${decoded.header.typ}`);
+  }
+  const result = CreditClaimPayload.safeParse(decoded.payload);
+  if (!result.success) {
+    const messages = result.error.issues.map((e) => e.message).join(", ");
+    throw invalid(`invalid credit claim payload: ${messages}`);
+  }
+  const payload = result.data;
+  const kid = decoded.header.kid;
+  const hashIdx = kid.indexOf("#");
+  if (hashIdx < 0) throw invalid("credit claim kid must be a DID URL");
+  const kidDid = kid.substring(0, hashIdx);
+  if (kidDid !== payload.did) {
+    throw invalid("credit claim kid DID does not match payload did");
+  }
+  let identity;
+  try {
+    identity = await options.resolveIdentity(payload.did);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw unverifiable(`could not resolve claimant identity ${payload.did}: ${detail}`);
+  }
+  if (!identity) {
+    throw unverifiable(`claimant identity not found: ${payload.did}`);
+  }
+  const publicKey = resolveKeyFromIdentity(identity, kid);
+  try {
+    verifyJws({ token: jwsToken, publicKey });
+  } catch {
+    throw invalid("invalid credit claim signature");
+  }
+  const encoded = await dagCborCanonicalEncode(payload);
+  const claimCID = encoded.cid.toString();
+  if (!decoded.header.cid) throw invalid("missing cid in credit claim header");
+  if (decoded.header.cid !== claimCID) throw invalid("credit claim cid mismatch");
+  if (options.expectedContentId !== void 0 && payload.contentId !== options.expectedContentId) {
+    throw invalid(
+      `credit claim contentId ${payload.contentId} does not match expected ${options.expectedContentId}`
+    );
+  }
+  return {
+    did: payload.did,
+    contentId: payload.contentId,
+    role: payload.role,
+    createdAt: payload.createdAt,
+    ...payload.asOfDocumentCID !== void 0 ? { asOfDocumentCID: payload.asOfDocumentCID } : {},
+    signerKeyId: kid,
+    claimCID
+  };
+};
+var verifyCreditEntry = async (entry, options) => {
+  if (!options.contentId) {
+    throw new Error("verifyCreditEntry requires the hosting chain contentId");
+  }
+  if (entry.claim === void 0) {
+    return {
+      state: "unclaimed",
+      note: "the document signer asserts this credit; the claimant has not signed it"
+    };
+  }
+  if (typeof entry.claim !== "string" || entry.claim === "") {
+    return { state: "invalid", note: "claim is present but is not a JWS string" };
+  }
+  if (typeof entry.did !== "string" || entry.did === "") {
+    return { state: "invalid", note: "claim-bearing entry has no credited DID to bind to" };
+  }
+  if (typeof entry.role !== "string" || entry.role === "") {
+    return { state: "invalid", note: "claim-bearing entry has no role to bind to" };
+  }
+  let verified;
+  try {
+    verified = await verifyCreditClaim(entry.claim, {
+      resolveIdentity: options.resolveIdentity,
+      expectedContentId: options.contentId
+    });
+  } catch (error) {
+    if (error instanceof CreditClaimVerifyError) {
+      return { state: error.reason, note: error.message };
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    return { state: "unverifiable", note: `verification could not complete: ${detail}` };
+  }
+  if (verified.did !== entry.did) {
+    return { state: "invalid", note: "signed claimant DID does not match the credited DID" };
+  }
+  if (verified.role !== entry.role) {
+    return { state: "invalid", note: "signed role does not match the credited role" };
+  }
+  return {
+    state: "claimed",
+    note: "signature and the exact (contentId, did, role) bind verified",
+    claim: verified
+  };
+};
+
 export {
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
@@ -859,6 +1054,8 @@ export {
   ARTIFACT_CID_ANCHOR_RE,
   ServiceEntry,
   ServicesArray,
+  Iso8601,
+  parseProtocolTimestampUnix,
   IdentityOperation,
   VerifiedIdentity,
   ContentOperation,
@@ -866,6 +1063,8 @@ export {
   ArtifactPayload,
   CountersignPayload,
   RevocationPayload,
+  MAX_CREDIT_CLAIM_SIZE,
+  CreditClaimPayload,
   deriveChainIdentifier,
   deriveContentId,
   assertServicesWithinCap,
@@ -885,5 +1084,9 @@ export {
   signArtifact,
   verifyArtifact,
   signRevocation,
-  verifyRevocation
+  verifyRevocation,
+  CreditClaimVerifyError,
+  signCreditClaim,
+  verifyCreditClaim,
+  verifyCreditEntry
 };

package/dist/{chunk-FMHROCFH.js → chunk-PGFHCBGH.js}

@@ -269,7 +269,7 @@ var verifyDelegationChain = async (credential, options) => {
       ...options.now !== void 0 ? { now: options.now } : {}
     });
     if (options.isRevoked) {
-      const revoked = await options.isRevoked(parent.iss, parent.credentialCID);
+      const revoked = await options.isRevoked(parent.iss, parent.credentialCID, options.asOfUnix);
       if (revoked) {
         throw new CredentialVerificationError("parent credential in delegation chain is revoked");
       }