@metalabel/dfos-protocol 0.26.0 → 0.28.0

package/README.md

@@ -26,19 +26,25 @@ import { createJws, dagCborCanonicalEncode, verifyJws } from '@metalabel/dfos-pr
 
 ## Subpath Exports
 
-| 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                                    |
+| Export                                 | Description                                                                                             |
+| -------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `@metalabel/dfos-protocol/chain`       | Identity & content chains, services, artifacts, countersigns, revocations, credit claims, sign requests |
+| `@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                                                   |
+| `@metalabel/dfos-protocol/fold`        | Canonical linearization and LWW-map folds for index documents                                           |
 
 ## 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)                       |
+| 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 |
+
+Release history lives at https://github.com/metalabel/dfos/releases.
 
 ## Examples
 

package/dist/chain/index.d.ts

@@ -1,5 +1,5 @@
-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 { I as IdentityOperation, t as Signer, v as VerifiedIdentity, S as ServiceEntry, d as ContentOperation, R as RevocationChecker, e as CountersignPayload, a as ArtifactPayload } from '../dfos-credential-DU7WvoHE.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 MAX_SIGN_REQUEST_PAYLOAD_SIZE, o as MAX_SIGN_REQUEST_SIZE, p as MultikeyPublicKey, q as RevocationPayload, r as ServicesArray, s as SignRequestPayload, B as parseProtocolTimestampUnix } from '../dfos-credential-DU7WvoHE.js';
 import 'zod';
 
 /** Ed25519 public key multicodec value */
@@ -437,4 +437,69 @@ declare const verifyCreditEntry: (entry: CreditEntry, options: {
     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 };
+interface VerifiedSignRequest {
+    /** Requester DID */
+    did: string;
+    /** The one identity being asked to sign */
+    subject: string;
+    /** JWS typ the produced artifact must carry */
+    payloadTyp: string;
+    /** Exact decoded target bytes; never re-serialized by the envelope path */
+    payloadBytes: Uint8Array;
+    createdAt: string;
+    expiresAt: string;
+    /** kid from the JWS header */
+    signerKeyId: string;
+    /** CID of the sign-request payload */
+    requestCID: string;
+}
+type SignRequestFailureReason = 'invalid' | 'unverifiable';
+/**
+ * Thrown by sign-request verification and canonical-payload refusal paths.
+ * Consumers branch on `reason`, never on diagnostic message text.
+ */
+declare class SignRequestVerifyError extends Error {
+    readonly reason: SignRequestFailureReason;
+    constructor(reason: SignRequestFailureReason, message: string);
+}
+/**
+ * Build a sign-request envelope around exact target bytes.
+ *
+ * The kid is derived from `did` + `keyId`, so a requester mismatch is
+ * unrepresentable on the build path. Both timestamps, including overrides, are
+ * floor-normalized to whole seconds before signing.
+ */
+declare const buildSignRequest: (input: {
+    did: string;
+    subject: string;
+    payloadTyp: string;
+    payload: Uint8Array;
+    expiresAt: string;
+    createdAt?: string;
+    signer: Signer;
+    keyId: string;
+}) => Promise<{
+    jwsToken: string;
+    requestCID: string;
+}>;
+/**
+ * Verify a sign-request envelope in SIGNING.md's exact 1–9 order.
+ *
+ * `resolveIdentity` supplies CURRENT identity state. A missing identity or
+ * resolver failure is `unverifiable`; a deleted identity, missing current key,
+ * or any checked-and-failed condition is `invalid`.
+ */
+declare const verifySignRequest: (jwsToken: string, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** Unix milliseconds; defaults to Date.now() */
+    now?: number;
+}) => Promise<VerifiedSignRequest>;
+/**
+ * Assert that exact target bytes are the unique canonical representation the
+ * signer understands. SIGNING 0.1 implements only `did:dfos:credit-claim`.
+ */
+declare const assertCanonicalSignRequestPayload: (payloadTyp: string, payloadBytes: Uint8Array, context: {
+    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 };

package/dist/chain/index.js

@@ -13,14 +13,20 @@ import {
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_SIZE,
   MultikeyPublicKey,
   RECOGNIZED_SERVICE_TYPES,
   RevocationPayload,
   ServiceEntry,
   ServicesArray,
+  SignRequestPayload,
+  SignRequestVerifyError,
   VerifiedIdentity,
   anchorsByLabel,
+  assertCanonicalSignRequestPayload,
   assertServicesWithinCap,
+  buildSignRequest,
   classifyAnchor,
   deriveChainIdentifier,
   deriveContentId,
@@ -41,14 +47,15 @@ import {
   verifyCreditEntry,
   verifyIdentityChain,
   verifyIdentityExtensionFromTrustedState,
-  verifyRevocation
-} from "../chunk-3USIENKC.js";
+  verifyRevocation,
+  verifySignRequest
+} from "../chunk-W4ESJVMO.js";
 import {
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
   decodeMultikey,
   encodeEd25519Multikey
-} from "../chunk-PGFHCBGH.js";
+} from "../chunk-6HVYO5OS.js";
 import "../chunk-4QQ5HK5M.js";
 export {
   ARTIFACT_CID_ANCHOR_RE,
@@ -67,14 +74,20 @@ export {
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_SIZE,
   MultikeyPublicKey,
   RECOGNIZED_SERVICE_TYPES,
   RevocationPayload,
   ServiceEntry,
   ServicesArray,
+  SignRequestPayload,
+  SignRequestVerifyError,
   VerifiedIdentity,
   anchorsByLabel,
+  assertCanonicalSignRequestPayload,
   assertServicesWithinCap,
+  buildSignRequest,
   classifyAnchor,
   decodeMultikey,
   deriveChainIdentifier,
@@ -97,5 +110,6 @@ export {
   verifyCreditEntry,
   verifyIdentityChain,
   verifyIdentityExtensionFromTrustedState,
-  verifyRevocation
+  verifyRevocation,
+  verifySignRequest
 };

package/dist/{chunk-PGFHCBGH.js → chunk-6HVYO5OS.js}

@@ -323,6 +323,9 @@ var isAttenuated = (parentAtt, childAtt) => {
       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;
     });
   });

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

@@ -5,8 +5,11 @@ import {
   matchesResource,
   verifyDFOSCredential,
   verifyDelegationChain
-} from "./chunk-PGFHCBGH.js";
+} from "./chunk-6HVYO5OS.js";
 import {
+  assertJwsProfile,
+  base64urlDecode,
+  base64urlEncode,
   createJws,
   dagCborCanonicalEncode,
   decodeJwsUnsafe,
@@ -93,10 +96,17 @@ var IdentityDelete = z.looseObject({
   previousOperationCID: CIDString,
   createdAt: Iso8601
 });
+var IdentityRestore = z.looseObject({
+  version: z.literal(1),
+  type: z.literal("restore"),
+  previousOperationCID: CIDString,
+  createdAt: Iso8601
+});
 var IdentityOperation = z.discriminatedUnion("type", [
   IdentityCreate,
   IdentityUpdate,
-  IdentityDelete
+  IdentityDelete,
+  IdentityRestore
 ]);
 var VerifiedIdentity = z.strictObject({
   did: z.string(),
@@ -174,6 +184,18 @@ var CreditClaimPayload = z.looseObject({
   createdAt: Iso8601,
   asOfDocumentCID: CIDString.min(1, "asOfDocumentCID must be non-empty when present").optional()
 });
+var MAX_SIGN_REQUEST_SIZE = 8192;
+var MAX_SIGN_REQUEST_PAYLOAD_SIZE = 4096;
+var SignRequestPayload = z.looseObject({
+  version: z.literal(1),
+  type: z.literal("sign-request"),
+  did: z.string().regex(/^did:/, "did must be a DID (did: prefix)"),
+  subject: z.string().regex(/^did:/, "subject must be a DID (did: prefix)"),
+  payloadTyp: z.string().min(1),
+  payload: z.string().min(1),
+  createdAt: Iso8601,
+  expiresAt: Iso8601
+});
 
 // src/chain/derivation.ts
 var deriveChainIdentifier = (cidBytes, prefix) => {
@@ -242,7 +264,12 @@ var verifyIdentityChain = async (input) => {
     if (decoded.header.typ !== "did:dfos:identity-op") {
       throw new Error(`log[${idx}]: invalid typ: ${decoded.header.typ}`);
     }
-    if (state.isDeleted) throw new Error(`log[${idx}]: cannot modify a deleted identity`);
+    if (state.isDeleted && op.type !== "restore") {
+      throw new Error(`log[${idx}]: cannot modify a deleted identity`);
+    }
+    if (!state.isDeleted && op.type === "restore") {
+      throw new Error(`log[${idx}]: restore must immediately follow delete`);
+    }
     if (idx === 0 && op.type !== "create") {
       throw new Error(`log[${idx}]: first operation must be create`);
     }
@@ -258,7 +285,7 @@ var verifyIdentityChain = async (input) => {
       state.controllerKeys = op.controllerKeys;
       state.services = op.services ?? [];
     }
-    if (op.type === "update" || op.type === "delete") {
+    if (op.type !== "create") {
       if (op.previousOperationCID !== state.previousOperationCID) {
         throw new Error(`log[${idx}]: previousCID is incorrect`);
       }
@@ -355,6 +382,9 @@ var verifyIdentityChain = async (input) => {
       case "delete":
         state.isDeleted = true;
         break;
+      case "restore":
+        state.isDeleted = false;
+        break;
     }
   }
   if (!state.did) throw new Error("did is not set");
@@ -369,9 +399,6 @@ var verifyIdentityChain = async (input) => {
 };
 var verifyIdentityExtensionFromTrustedState = async (input) => {
   const { currentState, headCID, lastCreatedAt, newOp } = input;
-  if (currentState.isDeleted) {
-    throw new Error("cannot extend a deleted identity");
-  }
   const decoded = decodeJwsUnsafe(newOp);
   if (!decoded) throw new Error("failed to decode JWS");
   const result = IdentityOperation.safeParse(decoded.payload);
@@ -380,6 +407,12 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
     throw new Error(messages);
   }
   const op = result.data;
+  if (currentState.isDeleted && op.type !== "restore") {
+    throw new Error("cannot extend a deleted identity");
+  }
+  if (!currentState.isDeleted && op.type === "restore") {
+    throw new Error("restore must immediately follow delete");
+  }
   if (decoded.header.typ !== "did:dfos:identity-op") {
     throw new Error(`invalid typ: ${decoded.header.typ}`);
   }
@@ -428,21 +461,37 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
     });
     if (op.services) await assertServicesWithinCap(op.services);
   }
-  const newState = op.type === "update" ? {
-    did: currentState.did,
-    isDeleted: false,
-    authKeys: op.authKeys,
-    assertKeys: op.assertKeys,
-    controllerKeys: op.controllerKeys,
-    services: op.services ?? []
-  } : {
-    did: currentState.did,
-    isDeleted: true,
-    authKeys: currentState.authKeys,
-    assertKeys: currentState.assertKeys,
-    controllerKeys: currentState.controllerKeys,
-    services: currentState.services
-  };
+  const newState = (() => {
+    switch (op.type) {
+      case "update":
+        return {
+          did: currentState.did,
+          isDeleted: false,
+          authKeys: op.authKeys,
+          assertKeys: op.assertKeys,
+          controllerKeys: op.controllerKeys,
+          services: op.services ?? []
+        };
+      case "delete":
+        return {
+          did: currentState.did,
+          isDeleted: true,
+          authKeys: currentState.authKeys,
+          assertKeys: currentState.assertKeys,
+          controllerKeys: currentState.controllerKeys,
+          services: currentState.services
+        };
+      case "restore":
+        return {
+          did: currentState.did,
+          isDeleted: false,
+          authKeys: currentState.authKeys,
+          assertKeys: currentState.assertKeys,
+          controllerKeys: currentState.controllerKeys,
+          services: currentState.services
+        };
+    }
+  })();
   return { state: newState, operationCID, createdAt: op.createdAt };
 };
 
@@ -1045,6 +1094,248 @@ var verifyCreditEntry = async (entry, options) => {
   };
 };
 
+// src/chain/sign-request.ts
+var SignRequestVerifyError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "SignRequestVerifyError";
+    this.reason = reason;
+  }
+};
+var invalid2 = (message) => new SignRequestVerifyError("invalid", message);
+var unverifiable2 = (message) => new SignRequestVerifyError("unverifiable", message);
+var normalizeSignRequestTimestamp = (value, field) => {
+  if (value === void 0) {
+    return (/* @__PURE__ */ new Date()).toISOString().replace(/\d{3}Z$/, "000Z");
+  }
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new Error(`invalid sign request payload: unparseable ${field}: ${value}`);
+  }
+  return new Date(Math.floor(ms / 1e3) * 1e3).toISOString();
+};
+var assertTemporalWindow = (createdAt, expiresAt, makeError) => {
+  const createdMs = Date.parse(createdAt);
+  const expiresMs = Date.parse(expiresAt);
+  if (expiresMs <= createdMs) {
+    throw makeError("sign request expiresAt must be strictly after createdAt");
+  }
+  if (expiresMs - createdMs > 6048e5) {
+    throw makeError("sign request validity window exceeds 604800 seconds");
+  }
+};
+var decodeTargetPayload = (encoded) => {
+  if (!/^[A-Za-z0-9_-]+$/.test(encoded)) {
+    throw invalid2("sign request payload must be unpadded base64url");
+  }
+  let decoded;
+  try {
+    decoded = base64urlDecode(encoded);
+  } catch {
+    throw invalid2("sign request payload is not valid base64url");
+  }
+  if (base64urlEncode(decoded) !== encoded) {
+    throw invalid2("sign request payload is not canonical unpadded base64url");
+  }
+  if (decoded.length === 0) {
+    throw invalid2("sign request payload must decode to non-empty bytes");
+  }
+  if (decoded.length > MAX_SIGN_REQUEST_PAYLOAD_SIZE) {
+    throw invalid2(
+      `sign request payload exceeds max decoded size: ${decoded.length} > ${MAX_SIGN_REQUEST_PAYLOAD_SIZE}`
+    );
+  }
+  return decoded;
+};
+var resolveCurrentKey = (identity, kid) => {
+  const hashIdx = kid.indexOf("#");
+  if (hashIdx < 0) throw invalid2("sign request kid must be a DID URL");
+  const keyId = kid.substring(hashIdx + 1);
+  const key = [...identity.authKeys, ...identity.assertKeys, ...identity.controllerKeys].find(
+    (candidate) => candidate.id === keyId
+  );
+  if (!key) throw invalid2(`key ${keyId} not found on current identity ${identity.did}`);
+  try {
+    return decodeMultikey(key.publicKeyMultibase).keyBytes;
+  } catch {
+    throw invalid2(`key ${keyId} on identity ${identity.did} is not a valid Ed25519 multikey`);
+  }
+};
+var buildSignRequest = async (input) => {
+  if (input.payload.length === 0) {
+    throw new Error("invalid sign request payload: target payload must be non-empty");
+  }
+  if (input.payload.length > MAX_SIGN_REQUEST_PAYLOAD_SIZE) {
+    throw new Error(
+      `sign request payload exceeds max decoded size: ${input.payload.length} > ${MAX_SIGN_REQUEST_PAYLOAD_SIZE}`
+    );
+  }
+  const createdAt = normalizeSignRequestTimestamp(input.createdAt, "createdAt");
+  const expiresAt = normalizeSignRequestTimestamp(input.expiresAt, "expiresAt");
+  assertTemporalWindow(createdAt, expiresAt, (message) => new Error(message));
+  const payload = {
+    version: 1,
+    type: "sign-request",
+    did: input.did,
+    subject: input.subject,
+    payloadTyp: input.payloadTyp,
+    payload: base64urlEncode(input.payload),
+    createdAt,
+    expiresAt
+  };
+  const parsed = SignRequestPayload.safeParse(payload);
+  if (!parsed.success) {
+    const messages = parsed.error.issues.map((issue) => issue.message).join(", ");
+    throw new Error(`invalid sign request payload: ${messages}`);
+  }
+  const encoded = await dagCborCanonicalEncode(payload);
+  const requestCID = encoded.cid.toString();
+  const jwsToken = await createJws({
+    header: {
+      alg: "EdDSA",
+      typ: "did:dfos:sign-request",
+      kid: `${input.did}#${input.keyId}`,
+      cid: requestCID
+    },
+    payload,
+    sign: input.signer
+  });
+  if (new TextEncoder().encode(jwsToken).length > MAX_SIGN_REQUEST_SIZE) {
+    throw new Error(
+      `sign request exceeds max size: ${new TextEncoder().encode(jwsToken).length} > ${MAX_SIGN_REQUEST_SIZE}`
+    );
+  }
+  return { jwsToken, requestCID };
+};
+var verifySignRequest = async (jwsToken, options) => {
+  try {
+    const tokenSize = new TextEncoder().encode(jwsToken).length;
+    if (tokenSize > MAX_SIGN_REQUEST_SIZE) {
+      throw invalid2(`sign request exceeds max size: ${tokenSize} > ${MAX_SIGN_REQUEST_SIZE}`);
+    }
+    const decoded = decodeJwsUnsafe(jwsToken);
+    if (!decoded) throw invalid2("failed to decode sign request JWS");
+    const rawHeader = decoded.header;
+    if (typeof rawHeader !== "object" || rawHeader === null || Array.isArray(rawHeader)) {
+      throw invalid2("sign request protected header must be an object");
+    }
+    assertJwsProfile(rawHeader, invalid2);
+    if (typeof rawHeader["typ"] !== "string" || typeof rawHeader["kid"] !== "string") {
+      throw invalid2("sign request header must carry a string typ and kid");
+    }
+    if (decoded.header.typ !== "did:dfos:sign-request") {
+      throw invalid2(`invalid sign request typ: ${decoded.header.typ}`);
+    }
+    const parsed = SignRequestPayload.safeParse(decoded.payload);
+    if (!parsed.success) {
+      const messages = parsed.error.issues.map((issue) => issue.message).join(", ");
+      throw invalid2(`invalid sign request payload: ${messages}`);
+    }
+    const payload = parsed.data;
+    const payloadBytes = decodeTargetPayload(payload.payload);
+    const kid = decoded.header.kid;
+    const hashIdx = kid.indexOf("#");
+    if (hashIdx < 0) throw invalid2("sign request kid must be a DID URL");
+    if (kid.substring(0, hashIdx) !== payload.did) {
+      throw invalid2("sign request 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 unverifiable2(`could not resolve requester identity ${payload.did}: ${detail}`);
+    }
+    if (!identity) throw unverifiable2(`requester identity not found: ${payload.did}`);
+    if (identity.isDeleted) throw invalid2(`requester identity is deleted: ${payload.did}`);
+    const publicKey = resolveCurrentKey(identity, kid);
+    try {
+      verifyJws({ token: jwsToken, publicKey });
+    } catch {
+      throw invalid2("invalid sign request signature");
+    }
+    let encoded;
+    try {
+      encoded = await dagCborCanonicalEncode(payload);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw invalid2(`failed to derive sign request CID: ${detail}`);
+    }
+    const requestCID = encoded.cid.toString();
+    if (decoded.header.cid !== requestCID) throw invalid2("sign request cid mismatch");
+    assertTemporalWindow(payload.createdAt, payload.expiresAt, invalid2);
+    if ((options.now ?? Date.now()) >= Date.parse(payload.expiresAt)) {
+      throw invalid2("sign request is expired");
+    }
+    return {
+      did: payload.did,
+      subject: payload.subject,
+      payloadTyp: payload.payloadTyp,
+      payloadBytes,
+      createdAt: payload.createdAt,
+      expiresAt: payload.expiresAt,
+      signerKeyId: kid,
+      requestCID
+    };
+  } catch (error) {
+    if (error instanceof SignRequestVerifyError) throw error;
+    const detail = error instanceof Error ? error.message : String(error);
+    throw unverifiable2(`sign request verification could not complete: ${detail}`);
+  }
+};
+var assertCanonicalSignRequestPayload = (payloadTyp, payloadBytes, context) => {
+  if (payloadTyp !== "did:dfos:credit-claim") {
+    throw invalid2(`unsupported sign request payloadTyp: ${payloadTyp}`);
+  }
+  let source;
+  try {
+    source = new TextDecoder("utf-8", { fatal: true }).decode(payloadBytes);
+  } catch {
+    throw invalid2("sign request payload is not valid UTF-8 JSON");
+  }
+  if (source.startsWith("\uFEFF")) {
+    throw invalid2("sign request payload must not carry a UTF-8 BOM");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(source);
+  } catch {
+    throw invalid2("sign request payload is not valid JSON");
+  }
+  const parsed = CreditClaimPayload.strict().safeParse(raw);
+  if (!parsed.success) {
+    const messages = parsed.error.issues.map((issue) => issue.message).join(", ");
+    throw invalid2(`invalid canonical credit-claim payload: ${messages}`);
+  }
+  const payload = parsed.data;
+  if (!payload.createdAt.endsWith(".000Z")) {
+    throw invalid2("credit-claim createdAt must be normalized to whole seconds");
+  }
+  if (payload.asOfDocumentCID !== void 0 && payload.asOfDocumentCID.length === 0) {
+    throw invalid2("credit-claim asOfDocumentCID must be non-empty when present");
+  }
+  if (payload.did !== context.subject) {
+    throw invalid2("credit-claim payload did does not match sign request subject");
+  }
+  if (/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(payload.role)) {
+    throw invalid2("credit-claim role is not well-formed unicode (lone surrogate)");
+  }
+  const canonical = JSON.stringify({
+    version: payload.version,
+    type: payload.type,
+    contentId: payload.contentId,
+    did: payload.did,
+    role: payload.role,
+    createdAt: payload.createdAt,
+    ...payload.asOfDocumentCID !== void 0 ? { asOfDocumentCID: payload.asOfDocumentCID } : {}
+  });
+  const canonicalBytes = new TextEncoder().encode(canonical);
+  if (canonicalBytes.length !== payloadBytes.length || !canonicalBytes.every((byte, index) => byte === payloadBytes[index])) {
+    throw invalid2("credit-claim payload bytes are not canonical");
+  }
+};
+
 export {
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
@@ -1065,6 +1356,9 @@ export {
   RevocationPayload,
   MAX_CREDIT_CLAIM_SIZE,
   CreditClaimPayload,
+  MAX_SIGN_REQUEST_SIZE,
+  MAX_SIGN_REQUEST_PAYLOAD_SIZE,
+  SignRequestPayload,
   deriveChainIdentifier,
   deriveContentId,
   assertServicesWithinCap,
@@ -1088,5 +1382,9 @@ export {
   CreditClaimVerifyError,
   signCreditClaim,
   verifyCreditClaim,
-  verifyCreditEntry
+  verifyCreditEntry,
+  SignRequestVerifyError,
+  buildSignRequest,
+  verifySignRequest,
+  assertCanonicalSignRequestPayload
 };

package/dist/credentials/index.d.ts

@@ -1,4 +1,4 @@
-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';
+export { b as Attenuation, c as AuthTokenClaims, f as CredentialVerificationError, D as DFOSCredentialPayload, i as MAX_CREDENTIAL_SIZE, R as RevocationChecker, V as VerifiedDFOSCredential, u as VerifiedDelegationChain, w as createDFOSCredential, x as decodeDFOSCredentialUnsafe, y as isAttenuated, z as matchesResource, E as verifyDFOSCredential, F as verifyDelegationChain } from '../dfos-credential-DU7WvoHE.js';
 import 'zod';
 
 interface AuthTokenCreateOptions {

package/dist/credentials/index.js

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

package/dist/{dfos-credential-CAYCqUCP.d.ts → dfos-credential-DU7WvoHE.d.ts}

@@ -148,6 +148,11 @@ declare const IdentityOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"delete">;
     previousOperationCID: z.ZodString;
     createdAt: z.ZodISODateTime;
+}, z.core.$loose>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"restore">;
+    previousOperationCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
 }, z.core.$loose>], "type">;
 type IdentityOperation = z.infer<typeof IdentityOperation>;
 declare const VerifiedIdentity: z.ZodObject<{
@@ -295,6 +300,37 @@ declare const CreditClaimPayload: z.ZodObject<{
     asOfDocumentCID: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 type CreditClaimPayload = z.infer<typeof CreditClaimPayload>;
+/**
+ * Max byte length of a sign-request JWS token. Checked before any decode on the
+ * verify path and after construction on the build path. VALIDITY-determining:
+ * MUST match maxSignRequestSize in the Go reference.
+ */
+declare const MAX_SIGN_REQUEST_SIZE = 8192;
+/**
+ * Max decoded byte length of the exact target payload carried by a sign request.
+ * This is the single aggregate cap on target bytes; there are no per-field caps.
+ * VALIDITY-determining: MUST match maxSignRequestPayloadSize in Go.
+ */
+declare const MAX_SIGN_REQUEST_PAYLOAD_SIZE = 4096;
+/**
+ * Sign request: a requester's signed ask that one subject sign exact target bytes
+ * as one named artifact type before a bounded deadline.
+ *
+ * Unknown envelope fields are preserved-and-ignored, matching every other wire
+ * payload in this file. The signer-side target-payload check is deliberately
+ * strict instead: a signer refuses fields it cannot render (see SIGNING.md).
+ */
+declare const SignRequestPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"sign-request">;
+    did: z.ZodString;
+    subject: z.ZodString;
+    payloadTyp: z.ZodString;
+    payload: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$loose>;
+type SignRequestPayload = z.infer<typeof SignRequestPayload>;
 
 /**
  * Max byte length of a credential JWS token — the credential's analog of
@@ -462,6 +498,11 @@ declare const verifyDelegationChain: (credential: VerifiedDFOSCredential, option
  * - `chain:X` covered by `chain:*` (narrowing from wildcard — valid)
  * - `chain:*` covered by `chain:*` (exact match)
  * - `chain:*` NOT covered by `chain:X` (widening — invalid)
+ * - Non-`chain` types (`mailbox:<id>`, and any form a future capability
+ *   registers): exact byte equality of the full resource string, nothing else.
+ *   The wildcard is a `chain:`-only concept — a literal `*` id in any other
+ *   type is an ordinary id covering only itself — and coverage never crosses
+ *   resource types. See CREDENTIALS.md "Resource Types".
  * - Actions: child action set must be a subset of parent action set
  */
 declare const isAttenuated: (parentAtt: Attenuation[], childAtt: Attenuation[]) => boolean;
@@ -490,4 +531,4 @@ 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 };
+export { ARTIFACT_CID_ANCHOR_RE as A, parseProtocolTimestampUnix as B, CONTENT_ID_ANCHOR_RE as C, DFOSCredentialPayload as D, verifyDFOSCredential as E, verifyDelegationChain as F, 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, MAX_SIGN_REQUEST_PAYLOAD_SIZE as n, MAX_SIGN_REQUEST_SIZE as o, MultikeyPublicKey as p, RevocationPayload as q, ServicesArray as r, SignRequestPayload as s, type Signer as t, type VerifiedDelegationChain as u, VerifiedIdentity as v, createDFOSCredential as w, decodeDFOSCredentialUnsafe as x, isAttenuated as y, matchesResource as z };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { JwsHeader, JwsVerificationError, JwtClaims, JwtCreateOptions, JwtHeader, JwtVerificationError, JwtVerifyOptions, PrefixedID, assertJwsProfile, base64urlDecode, base64urlEncode, createJws, createJwt, createNewEd25519Keypair, dagCborCanonicalEncode, decodeJwsUnsafe, decodeJwtUnsafe, generateId, generateIdNoPrefix, importEd25519Keypair, isCanonicallyEqual, isValidEd25519Signature, isValidId, normalizedId, parseDagCborCID, signPayloadEd25519, verifyJws, verifyJwt } from './crypto/index.js';
-export { A as ARTIFACT_CID_ANCHOR_RE, a as ArtifactPayload, b as Attenuation, c as AuthTokenClaims, C as CONTENT_ID_ANCHOR_RE, d as ContentOperation, e as CountersignPayload, f as CredentialVerificationError, g as CreditClaimPayload, D as DFOSCredentialPayload, I as IdentityOperation, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, i as MAX_CREDENTIAL_SIZE, j as MAX_CREDIT_CLAIM_SIZE, k as MAX_OPERATION_SIZE, l as MAX_SERVICES_ENTRIES, m as MAX_SERVICES_PAYLOAD_SIZE, n as MultikeyPublicKey, R as RevocationChecker, o as RevocationPayload, S as ServiceEntry, p as ServicesArray, q as Signer, V as VerifiedDFOSCredential, r as VerifiedDelegationChain, s as VerifiedIdentity, t as createDFOSCredential, u as decodeDFOSCredentialUnsafe, v as isAttenuated, w as matchesResource, x as parseProtocolTimestampUnix, y as verifyDFOSCredential, z as verifyDelegationChain } from './dfos-credential-CAYCqUCP.js';
-export { AnchorKind, CreditClaimFailureReason, CreditClaimVerifyError, CreditEntry, CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, RECOGNIZED_SERVICE_TYPES, VerifiedArtifact, VerifiedContentChain, VerifiedCountersignature, VerifiedCreditClaim, VerifiedCreditEntry, 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 } from './chain/index.js';
+export { A as ARTIFACT_CID_ANCHOR_RE, a as ArtifactPayload, b as Attenuation, c as AuthTokenClaims, C as CONTENT_ID_ANCHOR_RE, d as ContentOperation, e as CountersignPayload, f as CredentialVerificationError, g as CreditClaimPayload, D as DFOSCredentialPayload, I as IdentityOperation, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, i as MAX_CREDENTIAL_SIZE, j as MAX_CREDIT_CLAIM_SIZE, k as MAX_OPERATION_SIZE, l as MAX_SERVICES_ENTRIES, m as MAX_SERVICES_PAYLOAD_SIZE, n as MAX_SIGN_REQUEST_PAYLOAD_SIZE, o as MAX_SIGN_REQUEST_SIZE, p as MultikeyPublicKey, R as RevocationChecker, q as RevocationPayload, S as ServiceEntry, r as ServicesArray, s as SignRequestPayload, t as Signer, V as VerifiedDFOSCredential, u as VerifiedDelegationChain, v as VerifiedIdentity, w as createDFOSCredential, x as decodeDFOSCredentialUnsafe, y as isAttenuated, z as matchesResource, B as parseProtocolTimestampUnix, E as verifyDFOSCredential, F as verifyDelegationChain } from './dfos-credential-DU7WvoHE.js';
+export { AnchorKind, CreditClaimFailureReason, CreditClaimVerifyError, CreditEntry, CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, RECOGNIZED_SERVICE_TYPES, SignRequestFailureReason, SignRequestVerifyError, VerifiedArtifact, VerifiedContentChain, VerifiedCountersignature, VerifiedCreditClaim, VerifiedCreditEntry, VerifiedRevocation, VerifiedSignRequest, anchorsByLabel, assertCanonicalSignRequestPayload, assertServicesWithinCap, buildSignRequest, classifyAnchor, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signCreditClaim, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyCreditClaim, verifyCreditEntry, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation, verifySignRequest } from './chain/index.js';
 export { AuthTokenCreateOptions, AuthTokenVerificationError, AuthTokenVerifyOptions, VerifiedAuthToken, createAuthToken, verifyAuthToken } from './credentials/index.js';
 export { FoldOperation, INDEX_V1_SCHEMA, IndexDelta, IndexDocument, IndexEntry, LwwDelta, OrderKey, byteCompare, compareHeadPreference, compareLinear, foldIndexV1, foldLwwMap, linearize } from './fold/index.js';
 import 'multiformats';

package/dist/index.js

@@ -13,14 +13,20 @@ import {
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_SIZE,
   MultikeyPublicKey,
   RECOGNIZED_SERVICE_TYPES,
   RevocationPayload,
   ServiceEntry,
   ServicesArray,
+  SignRequestPayload,
+  SignRequestVerifyError,
   VerifiedIdentity,
   anchorsByLabel,
+  assertCanonicalSignRequestPayload,
   assertServicesWithinCap,
+  buildSignRequest,
   classifyAnchor,
   deriveChainIdentifier,
   deriveContentId,
@@ -41,8 +47,9 @@ import {
   verifyCreditEntry,
   verifyIdentityChain,
   verifyIdentityExtensionFromTrustedState,
-  verifyRevocation
-} from "./chunk-3USIENKC.js";
+  verifyRevocation,
+  verifySignRequest
+} from "./chunk-W4ESJVMO.js";
 import {
   Attenuation,
   AuthTokenClaims,
@@ -62,7 +69,7 @@ import {
   verifyAuthToken,
   verifyDFOSCredential,
   verifyDelegationChain
-} from "./chunk-PGFHCBGH.js";
+} from "./chunk-6HVYO5OS.js";
 import {
   JwsVerificationError,
   JwtVerificationError,
@@ -122,17 +129,23 @@ export {
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_PAYLOAD_SIZE,
+  MAX_SIGN_REQUEST_SIZE,
   MultikeyPublicKey,
   RECOGNIZED_SERVICE_TYPES,
   RevocationPayload,
   ServiceEntry,
   ServicesArray,
+  SignRequestPayload,
+  SignRequestVerifyError,
   VerifiedIdentity,
   anchorsByLabel,
+  assertCanonicalSignRequestPayload,
   assertJwsProfile,
   assertServicesWithinCap,
   base64urlDecode,
   base64urlEncode,
+  buildSignRequest,
   byteCompare,
   classifyAnchor,
   compareHeadPreference,
@@ -186,5 +199,6 @@ export {
   verifyIdentityExtensionFromTrustedState,
   verifyJws,
   verifyJwt,
-  verifyRevocation
+  verifyRevocation,
+  verifySignRequest
 };

package/examples/identity-restore.json

@@ -0,0 +1,21 @@
+{
+  "description": "Identity chain: genesis + key rotation + delete + restore",
+  "type": "identity",
+  "chain": [
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJjaWQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiY3JlYXRlIiwiYXV0aEtleXMiOlt7ImlkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJ0eXBlIjoiTXVsdGlrZXkiLCJwdWJsaWNLZXlNdWx0aWJhc2UiOiJ6Nk1rcnpMTU53b0pTVjRQM1ljY1djYnRrOHZkOUx0Z01LbkxlYURMVXFMdUFTamIifV0sImFzc2VydEtleXMiOlt7ImlkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJ0eXBlIjoiTXVsdGlrZXkiLCJwdWJsaWNLZXlNdWx0aWJhc2UiOiJ6Nk1rcnpMTU53b0pTVjRQM1ljY1djYnRrOHZkOUx0Z01LbkxlYURMVXFMdUFTamIifV0sImNvbnRyb2xsZXJLZXlzIjpbeyJpZCI6ImtleV9yOWV2MzRmdmMyM3o5OTl2ZWFhZnQ4M25uMjl6dmhlIiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa3J6TE1Od29KU1Y0UDNZY2NXY2J0azh2ZDlMdGdNS25MZWFETFVxTHVBU2piIn1dLCJjcmVhdGVkQXQiOiIyMDI2LTAzLTA3VDAwOjAwOjAwLjAwMFoifQ.TeznHnzrtKOGTr0FzkDL2z-luMWnAbKXrmDbi-Exgw_xMPCnYwGHORMjw-BM28f0RoTirIAeD7d20W5RSuGuBg",
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfcjlldjM0ZnZjMjN6OTk5dmVhYWZ0ODNubjI5enZoZSIsImNpZCI6ImJhZnlyZWliZnVoNjN1djMzaTJpNWVvb2UzYm9pdDJydXlqZWh1YnNyeWVtdXV6Nm1ydGxlajI2cmVpIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoidXBkYXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSIsImF1dGhLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJhc3NlcnRLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJjb250cm9sbGVyS2V5cyI6W3siaWQiOiJrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsInR5cGUiOiJNdWx0aWtleSIsInB1YmxpY0tleU11bHRpYmFzZSI6Ino2TWtmVWQ2NUpyQWhmZGdGdU1DY2NVOVRoUXZqQjJmSkFNVUhrdXVhakY5OTJnSyJ9XSwiY3JlYXRlZEF0IjoiMjAyNi0wMy0wN1QwMDowMTowMC4wMDBaIn0.7fqvWGEVYW9atA1uqpp7lIUOWp4dATLpLjOmFWzJN-8gTL-QnXDCeyGcBu5AXhHzO52fauwUavh1KrB6wBYuCw",
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsImNpZCI6ImJhZnlyZWljbDNhMnQ2dmh6NXZndnM1b2pkdzV3Y3dnb3ozdGF4cXF3ZXhwYnBsdG0yZ2gzcTQyenlpIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiZGVsZXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpYmZ1aDYzdXYzM2kyaTVlb29lM2JvaXQycnV5amVodWJzcnllbXV1ejZtcnRsZWoyNnJlaSIsImNyZWF0ZWRBdCI6IjIwMjYtMDMtMDdUMDA6MDI6MDAuMDAwWiJ9.00Dy7qeK7I0hC3P1yvERLJINBLNiEV9LhG8BXdUMIGGLTsxuMcuhn3Yquq96SQa8mzl-BztzD5LMxBohYZxQAg",
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsImNpZCI6ImJhZnlyZWlleWF2dWU2dnh6dDYzdWxrcXB3ZXRmd3F2Znpka2VxNnQzcTNnd3JqbnFnaG1panJneWJhIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoicmVzdG9yZSIsInByZXZpb3VzT3BlcmF0aW9uQ0lEIjoiYmFmeXJlaWNsM2EydDZ2aHo1dmd2czVvamR3NXdjd2dvejN0YXhxcXdleHBicGx0bTJnaDNxNDJ6eWkiLCJjcmVhdGVkQXQiOiIyMDI2LTAzLTA3VDAwOjAzOjAwLjAwMFoifQ.lVKZj34IGmyf-0Un7TELSPP3i57gWMe8j5d4d06gFnh8r4hpf5_1VHMUrwwkt7CFnWcd4Ui4CdeXPKS8jpIeAg"
+  ],
+  "expected": {
+    "did": "did:dfos:cnnnft9f8a2rn938d6nkz38r847v2kr",
+    "isDeleted": false,
+    "controllerKeys": [
+      {
+        "id": "key_ez9a874tckr3dv933d3ckdn7z6zrct8",
+        "type": "Multikey",
+        "publicKeyMultibase": "z6MkfUd65JrAhfdgFuMCccU9ThQvjB2fJAMUHkuuajF992gK"
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metalabel/dfos-protocol",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "type": "module",
   "description": "DFOS Protocol — Ed25519 signed chain primitives, services, credentials, and verification",
   "license": "MIT",