@tinycloud/node-sdk 3.6.0-beta.3 → 3.6.0-beta.5

package/dist/credentials.cjs

@@ -0,0 +1,746 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/credentials/index.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  DEFAULT_EMAIL_PROOF_PROFILE: () => DEFAULT_EMAIL_PROOF_PROFILE,
+  EMAIL_PROOF_CREDENTIAL_TYPE: () => EMAIL_PROOF_CREDENTIAL_TYPE,
+  EMAIL_PROOF_PENDING_MAX_MS: () => EMAIL_PROOF_PENDING_MAX_MS,
+  EmailProofError: () => EmailProofError,
+  OpenCredentialsHttpTransport: () => OpenCredentialsHttpTransport,
+  acquireEmailProof: () => acquireEmailProof,
+  completeEmailProof: () => completeEmailProof,
+  createEd25519HolderSigner: () => createEd25519HolderSigner,
+  createMemoryEmailProofPendingStore: () => createMemoryEmailProofPendingStore,
+  emailProofRequirement: () => emailProofRequirement,
+  interpretCredentialFlow: () => interpretCredentialFlow,
+  mailboxSubject: () => mailboxSubject,
+  requestEmailProofCode: () => requestEmailProofCode
+});
+module.exports = __toCommonJS(credentials_exports);
+
+// src/credentials/interpreter.ts
+var import_sdk_core = require("@tinycloud/sdk-core");
+var delay = (ms, signal) => new Promise((resolve, reject) => {
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener("abort", () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  }, { once: true });
+});
+function mailboxSubject(requirement) {
+  const email = requirement.claims.email;
+  return typeof email === "string" && email.length > 0 ? Object.freeze({ kind: "email", value: email }) : void 0;
+}
+async function interpretCredentialFlow(input) {
+  const steps = new Map(input.descriptor.steps.map((step) => [step.type, step]));
+  const completed = /* @__PURE__ */ new Set();
+  let lastTransition = "";
+  for (; ; ) {
+    input.signal?.throwIfAborted();
+    const state = await input.transport.state(input.requestId, input.verifier, input.signal);
+    if (state.requestId !== input.requestId) throw new import_sdk_core.CredentialError("REQUEST_SUBSTITUTED", "Credential request identity changed");
+    if (state.state === "expired") throw new import_sdk_core.CredentialError("REQUEST_EXPIRED", "Credential request expired", { state: state.state, correlationId: state.correlationId });
+    if (state.state === "canceled") throw new import_sdk_core.CredentialError("CANCELED", "Credential request was canceled", { state: state.state, correlationId: state.correlationId });
+    if (state.state === "issuer_unready") throw new import_sdk_core.CredentialError("ISSUER_UNREADY", "Credential issuer is not ready", { retryAfterMs: state.retryAfterMs, state: state.state, correlationId: state.correlationId });
+    if (state.state === "complete") return;
+    if (state.state === "ready_to_issue" || state.state === "issued") {
+      if (state.state === "ready_to_issue" && !completed.has("issue")) {
+        await input.transport.issue(input.requestId, input.verifier, input.signal);
+        completed.add("issue");
+      } else await (input.onWait?.() ?? delay(state.retryAfterMs ?? 50, input.signal));
+      continue;
+    }
+    const next = state.nextStep;
+    if (!next) {
+      await (input.onWait?.() ?? delay(state.retryAfterMs ?? 50, input.signal));
+      continue;
+    }
+    const declared = steps.get(next.type);
+    if (next.id !== next.type || !declared || declared.type !== next.type || declared.version !== next.version) throw new import_sdk_core.CredentialError("REQUEST_SUBSTITUTED", "Server selected an undeclared credential step");
+    if (completed.has(next.id) || state.transitionId === lastTransition) {
+      await (input.onWait?.() ?? delay(state.retryAfterMs ?? 50, input.signal));
+      continue;
+    }
+    lastTransition = state.transitionId;
+    if (next.type === "holder_signature") {
+      input.onProgress?.({ state: "signing", stepId: next.id, correlationId: state.correlationId });
+      const binding = (0, import_sdk_core.validateCredentialHolderBinding)(await input.transport.holderBinding(input.requestId, input.verifier, input.signal));
+      if (binding.requestId !== input.requestId || binding.descriptorDigest !== input.descriptorDigest || binding.requirementDigest !== input.requirementDigest || binding.holderDid !== input.holderDid || binding.issuer !== input.descriptor.issuer.did || binding.issuerKid !== input.descriptor.issuer.kid || binding.profile !== input.descriptor.profile || binding.openerOrigin !== input.openerOrigin || binding.completionOrigin !== input.openerOrigin || binding.audience !== "tinycloud://credentials") throw new import_sdk_core.CredentialError("REQUEST_SUBSTITUTED", "Holder binding was substituted");
+      const bytes = (0, import_sdk_core.holderBindingSigningBytes)(binding);
+      let signature = await input.signing.autoSign?.(binding, bytes, input.signal);
+      if (signature === void 0) {
+        if (!input.signing.requestApproval) throw new import_sdk_core.CredentialError("SIGNATURE_REJECTED", "OpenKey approval is required");
+        try {
+          signature = await input.signing.requestApproval(binding, bytes, input.signal);
+        } catch (cause) {
+          if (cause instanceof import_sdk_core.CredentialError) throw cause;
+          throw new import_sdk_core.CredentialError("SIGNATURE_REJECTED", "OpenKey approval was rejected", { cause });
+        }
+      }
+      if (!(signature instanceof Uint8Array) || signature.length === 0) throw new import_sdk_core.CredentialError("SIGNATURE_REJECTED", "OpenKey signature is invalid");
+      await input.transport.submitHolderSignature(input.requestId, input.verifier, (0, import_sdk_core.encodeBase64Url)(signature), input.signal, input.signing.holderKey);
+    } else {
+      input.onProgress?.({ state: next.type === "collect_input" ? "collecting" : "proving", stepId: next.id, correlationId: state.correlationId });
+      const handler = input.handlers?.[next.type];
+      const inlineHandler = input.proofHandler;
+      if (!handler && !inlineHandler) {
+        await (input.onWait?.() ?? delay(state.retryAfterMs ?? 50, input.signal));
+        continue;
+      }
+      if (next.constraints.challengeRequired === true) await input.transport.beginStep(input.requestId, input.verifier, next.type, input.signal);
+      if (handler) {
+        const proof = await handler({ descriptor: input.descriptor, requirement: input.requirement, stepId: next.id, constraints: next.constraints, signal: input.signal });
+        await input.transport.submitStep(input.requestId, input.verifier, next.id, proof, input.signal);
+      } else {
+        let feedback;
+        for (let attempt = 1; ; attempt += 1) {
+          const proof = await inlineHandler({
+            stepId: next.id,
+            constraints: next.constraints,
+            display: {
+              title: input.descriptor.display.title,
+              description: input.descriptor.display.description,
+              consent: input.descriptor.display.consent,
+              progressLabel: input.descriptor.accessibility.progressLabel,
+              errorLiveRegion: input.descriptor.accessibility.errorLiveRegion
+            },
+            inputs: input.descriptor.inputs.map(({ id, label, schema }) => ({ id, label, schema })),
+            ...feedback === void 0 ? {} : { feedback },
+            signal: input.signal
+          });
+          try {
+            await input.transport.submitStep(input.requestId, input.verifier, next.id, proof, input.signal);
+            break;
+          } catch (cause) {
+            if (!(cause instanceof import_sdk_core.CredentialError) || cause.code !== "PROOF_REJECTED") throw cause;
+            const attemptsRemaining = input.descriptor.lifecycle.maxProofAttempts - attempt;
+            if (next.type !== "mailbox_otp" || attemptsRemaining <= 0) throw new import_sdk_core.CredentialError("VERIFICATION_FAILED", "The proof was not accepted", { state: attemptsRemaining <= 0 ? "proof_attempts_exhausted" : "proof_rejected", cause });
+            feedback = { kind: "rejected", attemptsRemaining };
+          }
+        }
+      }
+    }
+    completed.add(next.id);
+  }
+}
+
+// src/credentials/transport.ts
+var import_sdk_core2 = require("@tinycloud/sdk-core");
+function object(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", `${label} is invalid`);
+  return value;
+}
+function opaque(value, label) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]{16,128}$/.test(value)) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", `${label} is invalid`);
+  return value;
+}
+function timestamp(value, label) {
+  if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", `${label} is invalid`);
+  return new Date(value).toISOString();
+}
+function jwtPayload(credential) {
+  const part = credential.split("~", 1)[0]?.split(".")[1];
+  if (!part) throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "Issued SD-JWT is invalid");
+  try {
+    return object(JSON.parse(new TextDecoder().decode((0, import_sdk_core2.decodeBase64Url)(part))), "SD-JWT payload");
+  } catch (cause) {
+    if (cause instanceof import_sdk_core2.CredentialError) throw cause;
+    throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "Issued SD-JWT is invalid", { cause });
+  }
+}
+var SERVER_CODES = /* @__PURE__ */ new Set(["REQUEST_EXPIRED", "ISSUER_UNREADY", "UNSUPPORTED_PROFILE", "UNSUPPORTED_VERSION", "SIGNATURE_REJECTED"]);
+function serverError(value, response, honorServerRecoverable) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const body = value;
+  const keys = Object.keys(body).sort();
+  if (keys.join(",") !== "code,correlationId,recoverable,state,type" || body.type !== "tinycloud.credentials/error/v1" || typeof body.code !== "string" || typeof body.recoverable !== "boolean" || typeof body.state !== "string" || typeof body.correlationId !== "string") return void 0;
+  if (body.code === "PROOF_REJECTED") return body.recoverable ? new import_sdk_core2.CredentialError("PROOF_REJECTED", "The proof was not accepted", { state: body.state, correlationId: body.correlationId }) : new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "The proof attempt limit was reached", { state: "proof_attempts_exhausted", correlationId: body.correlationId });
+  if (body.code === "RATE_LIMITED") return new import_sdk_core2.CredentialError("ISSUER_UNREADY", "Too many verification codes were requested", { state: "rate_limited", correlationId: body.correlationId, retryAfterMs: Number(response.headers.get("retry-after")) * 1e3 || void 0, recoverable: honorServerRecoverable ? body.recoverable : void 0 });
+  if (body.code === "CHALLENGE_EXPIRED") return new import_sdk_core2.CredentialError("REQUEST_EXPIRED", "The credential challenge expired", { state: body.state, correlationId: body.correlationId, recoverable: honorServerRecoverable ? body.recoverable : void 0 });
+  if (!SERVER_CODES.has(body.code)) return void 0;
+  const code = body.code;
+  return new import_sdk_core2.CredentialError(code, `OpenCredentials rejected the request: ${code}`, {
+    state: body.state,
+    correlationId: body.correlationId,
+    retryAfterMs: Number(response.headers.get("retry-after")) * 1e3 || void 0,
+    recoverable: honorServerRecoverable ? body.recoverable : void 0
+  });
+}
+var OpenCredentialsHttpTransport = class {
+  constructor(descriptor, fetchFn = globalThis.fetch.bind(globalThis), options = {}) {
+    this.descriptor = descriptor;
+    this.fetchFn = fetchFn;
+    this.options = options;
+    this.nonces = /* @__PURE__ */ new Map();
+    this.bindings = /* @__PURE__ */ new Map();
+  }
+  url(endpoint, id) {
+    return new URL((0, import_sdk_core2.credentialEndpointPath)(endpoint, id), this.descriptor.issuer.origin).href;
+  }
+  async request(endpoint, input) {
+    let response;
+    try {
+      const init = { method: input.method ?? "GET", credentials: "omit", cache: "no-store", redirect: "error", referrerPolicy: "no-referrer", signal: input.signal, headers: { accept: "application/json", ...input.body === void 0 ? {} : { "content-type": "application/json" }, ...input.verifier === void 0 ? {} : { authorization: `Bearer ${input.verifier}` } }, ...input.body === void 0 ? {} : { body: JSON.stringify(input.body) } };
+      response = await this.fetchFn(this.url(endpoint, input.id), init);
+    } catch (cause) {
+      if (cause instanceof DOMException && cause.name === "AbortError") throw new import_sdk_core2.CredentialError("CANCELED", "Credential acquisition was canceled", { cause });
+      throw new import_sdk_core2.CredentialError("OFFLINE", "OpenCredentials is unavailable", { cause });
+    }
+    if (!response.ok) {
+      let parsed;
+      try {
+        parsed = await response.json();
+      } catch {
+        parsed = void 0;
+      }
+      const typed = serverError(parsed, response, this.options.honorServerRecoverable === true);
+      if (typed) throw typed;
+      if (response.status === 410) throw new import_sdk_core2.CredentialError("REQUEST_EXPIRED", "Credential request expired");
+      if (response.status === 409) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential request was replayed or substituted");
+      if (response.status === 503) throw new import_sdk_core2.CredentialError("ISSUER_UNREADY", "Credential issuer is not ready", { retryAfterMs: Number(response.headers.get("retry-after")) * 1e3 || void 0 });
+      throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "OpenCredentials rejected the request");
+    }
+    if (response.status === 204) return void 0;
+    try {
+      return await response.json();
+    } catch (cause) {
+      throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "OpenCredentials response is invalid", { cause });
+    }
+  }
+  async create(input) {
+    const body = object(await this.request("request", { method: "POST", body: { protocol: input.descriptor.protocol, profile: input.descriptor.profile, profileVersion: input.descriptor.profileVersion, descriptorDigest: input.descriptorDigest, requirementDigest: input.requirementDigest, holderDid: input.holderDid, inputs: input.inputs ?? input.requirement.claims, audience: "tinycloud://credentials", openerOrigin: input.openerOrigin, completionOrigin: input.openerOrigin, completionContext: "sdk-acquisition", completionVerifierChallenge: input.completionVerifierChallenge }, signal: input.signal }), "create response");
+    if (body.type !== "tinycloud.credentials/acquisition-request/v1" || body.protocol !== input.descriptor.protocol || body.next !== "challenge" || body.endpoint !== "challenge") throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "create response is invalid");
+    const requestId = opaque(body.requestId, "requestId");
+    return { requestId, locator: requestId, expiresAt: timestamp(body.expiresAt, "expiresAt"), correlationId: requestId };
+  }
+  proofStep() {
+    return this.descriptor.steps.some((step) => step.type === "mailbox_otp") ? "mailbox_otp" : "collect_input";
+  }
+  async state(id, verifier, signal) {
+    const raw = object(await this.request("state", { id, verifier, signal }), "state response");
+    if (raw.type !== "tinycloud.credentials/acquisition-state/v1" || raw.requestId !== id || raw.profile !== this.descriptor.profile || raw.profileVersion !== 1) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential state response is substituted");
+    const base = { type: "OpenCredentialsAcquisitionState", version: 1, requestId: id, transitionId: `${String(raw.state)}:${String(raw.resultPreviouslyRead ?? false)}`, correlationId: id };
+    if (raw.state === "challenge_required") {
+      const type = this.proofStep();
+      return { ...base, state: "pending", nextStep: { id: type, type, version: 1, constraints: { challengeRequired: true } } };
+    }
+    if (raw.state === "proof_required") {
+      const type = this.proofStep();
+      this.nonces.set(id, opaque(raw.challengeNonce, "challengeNonce"));
+      return { ...base, state: "pending", nextStep: { id: type, type, version: 1, constraints: {} } };
+    }
+    if (raw.state === "holder_binding_required" || raw.state === "holder_signature_required") return { ...base, state: "pending", nextStep: { id: "holder_signature", type: "holder_signature", version: 1, constraints: {} } };
+    if (raw.state === "ready_to_issue") return { ...base, state: "ready_to_issue" };
+    if (raw.state === "issued") return { ...base, state: "complete" };
+    throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential state is unsupported");
+  }
+  async beginStep(id, verifier, stepId, signal) {
+    const step = this.proofStep();
+    if (stepId !== step) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential challenge step is substituted");
+    const challenge = object(await this.request("challenge", { id, verifier, method: "POST", body: { step, stepVersion: 1 }, signal }), "challenge response");
+    if (challenge.type !== "tinycloud.credentials/challenge/v1" || challenge.step !== step || challenge.stepVersion !== 1) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential challenge is substituted");
+    this.nonces.set(id, opaque(challenge.challengeNonce, "challengeNonce"));
+  }
+  async submitStep(id, verifier, stepId, proof, signal) {
+    const step = this.proofStep();
+    if (stepId !== step) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential proof step is substituted");
+    const nonce = this.nonces.get(id);
+    if (!nonce) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Credential challenge is missing");
+    await this.request("proof", { id, verifier, method: "POST", body: { step, stepVersion: 1, challengeNonce: nonce, proof }, signal });
+  }
+  async holderBinding(id, verifier, signal) {
+    const raw = object(await this.request("holder_binding", { id, verifier, signal }), "holder binding response");
+    if (raw.type !== "tinycloud.credentials/holder-binding-request/v1" || raw.signingDomain !== "tinycloud.credentials/holder-binding/v1" || raw.alg !== "EdDSA" || typeof raw.canonical !== "string") throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Holder binding response is invalid");
+    const binding = (0, import_sdk_core2.validateCredentialHolderBinding)(raw.binding);
+    if ((0, import_sdk_core2.encodeBase64Url)((0, import_sdk_core2.holderBindingCanonicalBytes)(binding)) !== raw.canonical) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Holder binding canonical bytes were substituted");
+    this.bindings.set(id, binding);
+    return binding;
+  }
+  async submitHolderSignature(id, verifier, signature, signal, key) {
+    const binding = this.bindings.get(id);
+    if (!binding) throw new import_sdk_core2.CredentialError("REQUEST_SUBSTITUTED", "Holder binding was not retrieved");
+    const kid = key?.kid ?? `${binding.holderDid}#${binding.holderDid.replace("did:key:", "")}`;
+    await this.request("holder_signature", { id, verifier, method: "POST", body: { alg: key?.alg ?? "EdDSA", kid, signature }, signal });
+  }
+  async issue(id, verifier, signal) {
+    await this.request("issue", { id, verifier, method: "POST", signal });
+  }
+  async result(id, verifier, signal) {
+    const raw = object(await this.request("result", { id, verifier, signal }), "result response");
+    if (raw.type !== "tinycloud.credentials/result/v1" || raw.protocol !== this.descriptor.protocol || raw.profile !== this.descriptor.profile || raw.profileVersion !== 1 || raw.format !== "vc+sd-jwt" || raw.descriptorDigest !== await (0, import_sdk_core2.canonicalDigest)(this.descriptor) || raw.issuer !== this.descriptor.issuer.did || raw.issuerKid !== this.descriptor.issuer.kid || typeof raw.credential !== "string" || await (0, import_sdk_core2.sha256Base64Url)(raw.credential) !== raw.credentialDigest) throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "Issued result metadata is invalid");
+    const holder = object(raw.holderBinding, "result holder binding");
+    if (raw.subject !== holder.did || holder.signingDomain !== "tinycloud.credentials/holder-binding/v1") throw new import_sdk_core2.CredentialError("HOLDER_MISMATCH", "Issued holder binding is invalid");
+    const claimsRaw = object(raw.claims, "result claims");
+    const claims = {};
+    for (const [name, value] of Object.entries(claimsRaw)) {
+      if (typeof value !== "string") throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "Issued claims are invalid");
+      claims[name] = value;
+    }
+    const validity = object(raw.validity, "result validity");
+    const payload = jwtPayload(raw.credential);
+    if (typeof payload.jti !== "string") throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "Credential id is invalid");
+    const issuedAt = timestamp(validity.issuedAt, "issuedAt");
+    const expiresAt = timestamp(validity.expiresAt, "expiresAt");
+    const status = object(raw.status, "result status");
+    if (status.type !== "none" || status.freshnessSeconds !== this.descriptor.status.freshnessSeconds) throw new import_sdk_core2.CredentialError("VERIFICATION_FAILED", "Credential status is invalid");
+    return { type: "OpenCredentialsIssuedCredential", version: 1, protocol: this.descriptor.protocol, profile: { id: this.descriptor.profile, version: 1 }, credentialType: { id: this.descriptor.format.vct, version: 1 }, schema: this.descriptor.format.vct, format: "vc+sd-jwt", issuerDid: raw.issuer, issuerKid: raw.issuerKid, subjectDid: raw.subject, holderDid: raw.subject, claims, claimsDigest: await (0, import_sdk_core2.canonicalDigest)(claims), descriptorDigest: raw.descriptorDigest, credentialId: payload.jti, issuedAt, notBefore: issuedAt, expiresAt, status: { method: "none", freshnessSeconds: status.freshnessSeconds }, credential: raw.credential };
+  }
+  async issuerMetadata(signal) {
+    return await this.request("issuer_metadata", { signal });
+  }
+  async checkStatus(status, _signal) {
+    return status.method === "none" && status.freshnessSeconds === this.descriptor.status.freshnessSeconds;
+  }
+};
+
+// src/credentials/email-proof.ts
+var import_sdk_core3 = require("@tinycloud/sdk-core");
+var EMAIL_PROOF_PINS = Object.freeze({
+  witnessOrigin: "https://witness.credentials.org",
+  issuerDid: "did:web:issuer.credentials.org",
+  issuerKid: "did:web:issuer.credentials.org#controller",
+  issuerX: "eEJI4xEobto4HtQ7Pg9R1vBOwcpfGRTlXDG5QfqLnGQ",
+  descriptorDigest: "1tg-qphmKBVtNwzVg9xyz-xxqt_xtMXAsQyXw46m8S0"
+});
+var EMAIL_PROOF_CREDENTIAL_TYPE = { id: "opencredentials.email/v1", version: 1 };
+var EMAIL_PROOF_PENDING_MAX_MS = 15 * 6e4;
+var DISCOVERY_URL = `${EMAIL_PROOF_PINS.witnessOrigin}/.well-known/opencredentials`;
+var EMAIL_PROOF_ISSUER_KEYS = [
+  {
+    kid: EMAIL_PROOF_PINS.issuerKid,
+    alg: "EdDSA",
+    jwk: { kty: "OKP", crv: "Ed25519", x: EMAIL_PROOF_PINS.issuerX },
+    validFrom: "2020-01-01T00:00:00Z",
+    validUntil: "2100-01-01T00:00:00Z"
+  }
+];
+var DEFAULT_EMAIL_PROOF_PROFILE = "tinycloud.email-proof/v1";
+var PROFILE_PINS = {
+  "tinycloud.email-proof/v1": { descriptorDigest: EMAIL_PROOF_PINS.descriptorDigest, requiredStep: "mailbox_otp", enabled: true }
+};
+var OPENER_ORIGIN = "https://localhost";
+var STEP_TIMEOUT_MS = 6e4;
+var HOLDER_DID_PREFIX = "did:key:";
+var HOLDER_DID_PATTERN = /^did:key:z6Mk[^#]+$/;
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var INSPECT = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var RECOVERABILITY = {
+  ADDRESS_INVALID: false,
+  HOLDER_INVALID: false,
+  CODE_INVALID: true,
+  RATE_LIMITED: true,
+  ISSUER_UNAVAILABLE: true,
+  NETWORK: true,
+  PROFILE_UNAVAILABLE: false,
+  CODE_REJECTED: true,
+  CODE_ATTEMPTS_EXHAUSTED: false,
+  SIGNATURE_REJECTED: true,
+  CREDENTIAL_INVALID: false,
+  SESSION_EXPIRED: false,
+  SESSION_INVALID: false,
+  CANCELED: false,
+  FAILED: false
+};
+var MESSAGES = {
+  ADDRESS_INVALID: "Email address is invalid.",
+  HOLDER_INVALID: "Holder must be a did:key Ed25519 identifier.",
+  CODE_INVALID: "Verification code must be 8 digits.",
+  ISSUER_UNAVAILABLE: "Email verification is unavailable right now.",
+  NETWORK: "Could not reach the email verification service.",
+  PROFILE_UNAVAILABLE: "The witness does not offer the email verification profile.",
+  CODE_REJECTED: "Verification code was not accepted.",
+  CODE_ATTEMPTS_EXHAUSTED: "Too many wrong codes. Request a new code.",
+  SIGNATURE_REJECTED: "Holder signature was rejected.",
+  CREDENTIAL_INVALID: "Issued credential failed verification.",
+  SESSION_EXPIRED: "Email verification request expired. Request a new code.",
+  SESSION_INVALID: "Email verification request is no longer valid. Request a new code.",
+  CANCELED: "Email verification was canceled.",
+  FAILED: "Email verification failed."
+};
+function rateLimitMessage(retryAfterMs) {
+  const head = "Too many codes were requested for this address.";
+  if (retryAfterMs === void 0 || !Number.isFinite(retryAfterMs) || retryAfterMs <= 0) return `${head} Try again in about an hour.`;
+  const minutes = Math.max(1, Math.ceil(retryAfterMs / 6e4));
+  return `${head} Try again in ${minutes} ${minutes === 1 ? "minute" : "minutes"}.`;
+}
+var EmailProofError = class extends Error {
+  constructor(step, code, retryAfterMs, recoverable = RECOVERABILITY[code]) {
+    super(code === "RATE_LIMITED" ? rateLimitMessage(retryAfterMs) : MESSAGES[code]);
+    this.name = "EmailProofError";
+    this.step = step;
+    this.code = code;
+    this.retryAfterMs = retryAfterMs;
+    this.recoverable = recoverable;
+  }
+};
+function createEd25519HolderSigner(did, sign) {
+  const fragment = did.indexOf("#");
+  const bare = fragment === -1 ? did : did.slice(0, fragment);
+  if (fragment !== -1 && did.slice(fragment + 1) !== bare.slice(HOLDER_DID_PREFIX.length)) throw new EmailProofError("request", "HOLDER_INVALID");
+  if (!HOLDER_DID_PATTERN.test(bare)) throw new EmailProofError("request", "HOLDER_INVALID");
+  return { did: bare, alg: "EdDSA", kid: holderKid(bare), sign };
+}
+function restoreEmailProofPending(fields) {
+  const shown = {
+    type: fields.type,
+    version: fields.version,
+    profile: fields.profile,
+    address: fields.address,
+    requestId: fields.requestId,
+    holderDid: fields.holderDid,
+    descriptorDigest: fields.descriptorDigest,
+    requirementDigest: fields.requirementDigest,
+    openerOrigin: fields.openerOrigin,
+    createdAt: fields.createdAt,
+    expiresAt: fields.expiresAt
+  };
+  const pending = { ...shown };
+  hide(pending, "verifier", fields.verifier);
+  hide(pending, "toJSON", () => ({ ...shown }));
+  hide(pending, INSPECT, () => ({ ...shown, verifier: "[redacted]" }));
+  return Object.freeze(pending);
+}
+function hide(target, key, value) {
+  Object.defineProperty(target, key, { value, enumerable: false, writable: false, configurable: false });
+}
+function pendingDeadlineMs(pending) {
+  return Math.min(Date.parse(pending.expiresAt), Date.parse(pending.createdAt) + EMAIL_PROOF_PENDING_MAX_MS);
+}
+function createMemoryEmailProofPendingStore() {
+  const byRequest = /* @__PURE__ */ new Map();
+  const prune = (now) => {
+    for (const [requestId, pending] of byRequest) if (pendingDeadlineMs(pending) <= now.getTime()) byRequest.delete(requestId);
+  };
+  return {
+    async findLive(address, now) {
+      prune(now);
+      let newest;
+      for (const pending of byRequest.values()) {
+        if (pending.address === address && (!newest || Date.parse(pending.createdAt) > Date.parse(newest.createdAt))) newest = pending;
+      }
+      return newest;
+    },
+    async put(pending) {
+      byRequest.set(pending.requestId, pending);
+    },
+    async delete(requestId) {
+      byRequest.delete(requestId);
+    },
+    async get(requestId, now) {
+      prune(now);
+      return byRequest.get(requestId);
+    }
+  };
+}
+var CodeRequested = class extends Error {
+};
+var pauseForCode = async () => {
+  throw new CodeRequested("code requested");
+};
+async function requestEmailProofCode(input) {
+  const profile = input.profile ?? DEFAULT_EMAIL_PROOF_PROFILE;
+  profilePin(profile, "request");
+  const address = normalizeAddress(input.address);
+  assertHolder(input.holder, "request");
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const signal = input.signal ?? AbortSignal.timeout(STEP_TIMEOUT_MS);
+  const requirement = emailRequirement(address, profile);
+  const requirementDigest = await (0, import_sdk_core3.credentialRequirementDigest)(requirement);
+  const descriptor = await witnessDescriptor(profile, requirement, { fetch: input.fetch, signal }, "request");
+  const descriptorDigest = await (0, import_sdk_core3.canonicalDigest)(descriptor);
+  const verifier = randomVerifier();
+  const transport = new OpenCredentialsHttpTransport(descriptor, input.fetch, { honorServerRecoverable: true });
+  const createdAtMs = now().getTime();
+  let created;
+  try {
+    created = await transport.create({
+      descriptor,
+      descriptorDigest,
+      requirement,
+      requirementDigest,
+      holderDid: input.holder.did,
+      openerOrigin: OPENER_ORIGIN,
+      completionVerifierChallenge: await (0, import_sdk_core3.sha256Base64Url)(verifier),
+      signal
+    });
+  } catch (error) {
+    throw mapError(error, "request", signal);
+  }
+  const serverExpiry = Date.parse(created.expiresAt);
+  if (!Number.isFinite(serverExpiry)) throw new EmailProofError("request", "FAILED");
+  const pending = restoreEmailProofPending({
+    type: "TinyCloudEmailProofPending",
+    version: 1,
+    profile,
+    address,
+    requestId: created.requestId,
+    verifier,
+    holderDid: input.holder.did,
+    descriptorDigest,
+    requirementDigest,
+    openerOrigin: OPENER_ORIGIN,
+    createdAt: new Date(createdAtMs).toISOString(),
+    expiresAt: new Date(Math.min(serverExpiry, createdAtMs + EMAIL_PROOF_PENDING_MAX_MS)).toISOString()
+  });
+  try {
+    await interpretCredentialFlow({
+      descriptor,
+      requirement,
+      requestId: created.requestId,
+      verifier,
+      holderDid: input.holder.did,
+      descriptorDigest,
+      requirementDigest,
+      openerOrigin: OPENER_ORIGIN,
+      transport,
+      signing: holderSigning(input.holder),
+      handlers: { mailbox_otp: pauseForCode },
+      signal
+    });
+  } catch (error) {
+    if (error instanceof CodeRequested) return pending;
+    throw mapError(error, "request", signal);
+  }
+  throw new EmailProofError("request", "FAILED");
+}
+async function completeEmailProof(input) {
+  return completeWithIssuerKeys(input, EMAIL_PROOF_ISSUER_KEYS);
+}
+async function completeWithIssuerKeys(input, issuerKeys) {
+  const { pending } = input;
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  if (!isPending(pending)) throw new EmailProofError("session", "SESSION_INVALID");
+  if (pendingDeadlineMs(pending) <= now().getTime()) throw new EmailProofError("session", "SESSION_EXPIRED");
+  if (!/^\d{8}$/.test(input.code)) throw new EmailProofError("code", "CODE_INVALID");
+  assertHolder(input.holder, "code");
+  if (input.holder.did !== pending.holderDid) throw new EmailProofError("session", "SESSION_INVALID");
+  const signal = input.signal ?? AbortSignal.timeout(STEP_TIMEOUT_MS);
+  const requirement = emailRequirement(pending.address, pending.profile);
+  if (await (0, import_sdk_core3.credentialRequirementDigest)(requirement) !== pending.requirementDigest) throw new EmailProofError("session", "SESSION_INVALID");
+  const descriptor = await witnessDescriptor(pending.profile, requirement, { fetch: input.fetch, signal }, "session");
+  const descriptorDigest = await (0, import_sdk_core3.canonicalDigest)(descriptor);
+  if (descriptorDigest !== pending.descriptorDigest) throw new EmailProofError("session", "SESSION_INVALID");
+  const transport = new OpenCredentialsHttpTransport(descriptor, input.fetch, { honorServerRecoverable: true });
+  try {
+    const state = await transport.state(pending.requestId, pending.verifier, signal);
+    if (state.nextStep?.constraints.challengeRequired === true) throw new EmailProofError("session", "SESSION_INVALID");
+    await interpretCredentialFlow({
+      descriptor,
+      requirement,
+      requestId: pending.requestId,
+      verifier: pending.verifier,
+      holderDid: pending.holderDid,
+      descriptorDigest,
+      requirementDigest: pending.requirementDigest,
+      openerOrigin: pending.openerOrigin,
+      transport,
+      signing: holderSigning(input.holder),
+      handlers: { mailbox_otp: async () => ({ otp: input.code }) },
+      signal
+    });
+  } catch (error) {
+    throw mapError(error, "code", signal);
+  }
+  try {
+    const envelope = await transport.result(pending.requestId, pending.verifier, signal);
+    const verified = await (0, import_sdk_core3.verifyIssuedCredential)({
+      envelope,
+      descriptor,
+      descriptorDigest,
+      requirement,
+      holderDid: pending.holderDid,
+      issuerMetadata: pinnedIssuerMetadata(issuerKeys),
+      now: now(),
+      checkStatus: (status, statusSignal) => transport.checkStatus(status, statusSignal),
+      signal
+    });
+    return { envelope, verified, credentialId: verified.credentialId, issuedAt: verified.issuedAt, expiresAt: verified.expiresAt };
+  } catch (error) {
+    throw mapError(error, "credential", signal);
+  }
+}
+async function acquireEmailProof(input) {
+  return acquireWithIssuerKeys(input, EMAIL_PROOF_ISSUER_KEYS);
+}
+async function acquireWithIssuerKeys(input, issuerKeys) {
+  const address = normalizeAddress(input.address);
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const store = input.pendingStore;
+  let pending = store ? await store.findLive(address, now()) : void 0;
+  if (!pending) {
+    pending = await requestEmailProofCode({ ...input, address });
+    await store?.put(pending);
+  }
+  const shown = restoreEmailProofPending(pending);
+  if (!input.getCode) return { status: "code-requested", pending: shown };
+  const code = await input.getCode({ pending: shown });
+  try {
+    const result = await completeWithIssuerKeys({ ...input, pending, code }, issuerKeys);
+    const warnings = [];
+    if (store) {
+      try {
+        await store.delete(pending.requestId);
+      } catch {
+        warnings.push("The pending request could not be deleted after success; it expires at its deadline.");
+      }
+    }
+    return { status: "issued", result, warnings };
+  } catch (error) {
+    if (!(error instanceof EmailProofError && error.recoverable)) await store?.delete(pending.requestId).catch(() => void 0);
+    throw error;
+  }
+}
+function normalizeAddress(address) {
+  const value = address.trim();
+  if (value.length > 254 || !EMAIL_PATTERN.test(value)) throw new EmailProofError("request", "ADDRESS_INVALID");
+  return value;
+}
+function holderKid(did) {
+  return `${did}#${did.slice(HOLDER_DID_PREFIX.length)}`;
+}
+function assertHolder(holder, step) {
+  if (!HOLDER_DID_PATTERN.test(holder.did) || holder.alg !== "EdDSA" || holder.kid !== holderKid(holder.did)) throw new EmailProofError(step, "HOLDER_INVALID");
+}
+function profilePin(profile, step) {
+  const entry = Object.prototype.hasOwnProperty.call(PROFILE_PINS, profile) ? PROFILE_PINS[profile] : void 0;
+  if (!entry || !entry.enabled) throw new EmailProofError(step, "PROFILE_UNAVAILABLE");
+  return entry;
+}
+function emailRequirement(address, profile) {
+  return (0, import_sdk_core3.createEmailCredentialRequirement)({ email: address, profile: { id: profile, version: 1 }, credentialType: EMAIL_PROOF_CREDENTIAL_TYPE });
+}
+function emailProofRequirement(address) {
+  return emailRequirement(normalizeAddress(address), DEFAULT_EMAIL_PROOF_PROFILE);
+}
+async function witnessDescriptor(profile, requirement, options, step) {
+  const pin = profilePin(profile, step);
+  let descriptor;
+  try {
+    descriptor = await discoverCatalogDescriptor(requirement, DISCOVERY_URL, { fetch: options.fetch, signal: options.signal });
+  } catch (error) {
+    throw discoveryFailure(error, options.signal, step);
+  }
+  if (descriptor.issuer.origin !== EMAIL_PROOF_PINS.witnessOrigin || descriptor.issuer.did !== EMAIL_PROOF_PINS.issuerDid || !descriptor.steps.some((candidate) => candidate.type === pin.requiredStep)) {
+    throw new EmailProofError(step, "PROFILE_UNAVAILABLE");
+  }
+  if (await (0, import_sdk_core3.canonicalDigest)(descriptor) !== pin.descriptorDigest) throw new EmailProofError(step, "PROFILE_UNAVAILABLE");
+  return descriptor;
+}
+async function discoverCatalogDescriptor(requirement, discoveryUrl, options = {}) {
+  let url;
+  try {
+    url = new URL(discoveryUrl);
+  } catch {
+    throw new import_sdk_core3.CredentialError("UNSUPPORTED_PROFILE", "Discovery URL is invalid");
+  }
+  if (url.protocol !== "https:" || !["/.well-known/opencredentials", "/v1/credential-types"].includes(url.pathname) || url.search || url.hash) throw new import_sdk_core3.CredentialError("UNSUPPORTED_PROFILE", "Discovery URL is not an allowed catalog endpoint");
+  const init = { credentials: "omit", cache: "no-store", redirect: "error", referrerPolicy: "no-referrer", signal: options.signal };
+  let response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch.bind(globalThis))(url, init);
+  } catch (cause) {
+    throw new import_sdk_core3.CredentialError("OFFLINE", "Credential discovery is unavailable", { cause });
+  }
+  if (!response.ok) throw new import_sdk_core3.CredentialError(response.status === 503 ? "ISSUER_UNREADY" : "OFFLINE", "Credential discovery is unavailable");
+  const catalog = await response.json();
+  if (catalog.type !== "tinycloud.credentials/catalog/v1" || catalog.protocol !== "tinycloud.credentials/acquisition/v1" || catalog.catalogVersion !== 1 || !Array.isArray(catalog.profiles)) throw new import_sdk_core3.CredentialError("DESCRIPTOR_INVALID", "Credential catalog is invalid");
+  for (const entryValue of catalog.profiles) {
+    if (typeof entryValue !== "object" || entryValue === null || Array.isArray(entryValue)) continue;
+    const entry = entryValue;
+    if (entry.supported !== true || entry.enabled !== true || entry.readiness !== "ready" && entry.readiness !== "degraded") continue;
+    try {
+      const candidate = (0, import_sdk_core3.validateCredentialFlowDescriptor)(entry.descriptor);
+      if ((0, import_sdk_core3.descriptorSatisfiesRequirement)(candidate, requirement) && entry.descriptorDigest === await (0, import_sdk_core3.canonicalDigest)(candidate)) return candidate;
+    } catch {
+    }
+  }
+  throw new import_sdk_core3.CredentialError("UNSUPPORTED_PROFILE", "No available credential profile satisfies the requirement");
+}
+function discoveryFailure(error, signal, step) {
+  if (signal.aborted && signal.reason?.name !== "TimeoutError") return new EmailProofError(step, "CANCELED");
+  return mapError(error, step, signal);
+}
+function pinnedIssuerMetadata(keys) {
+  return { type: "OpenCredentialsIssuerMetadata", version: 1, origin: EMAIL_PROOF_PINS.witnessOrigin, issuerDid: EMAIL_PROOF_PINS.issuerDid, keys, cache: { maxAgeSeconds: 3600, etag: "pinned" } };
+}
+function holderSigning(holder) {
+  return { autoSign: async (_binding, bytes) => holder.sign(bytes), holderKey: { alg: "EdDSA", kid: holder.kid } };
+}
+function randomVerifier() {
+  return (0, import_sdk_core3.encodeBase64Url)(crypto.getRandomValues(new Uint8Array(32)));
+}
+function isPending(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const pending = value;
+  return pending.type === "TinyCloudEmailProofPending" && pending.version === 1 && pending.openerOrigin === OPENER_ORIGIN && [pending.profile, pending.address, pending.requestId, pending.verifier, pending.holderDid, pending.descriptorDigest, pending.requirementDigest, pending.openerOrigin, pending.createdAt, pending.expiresAt].every((field) => typeof field === "string") && Number.isFinite(Date.parse(pending.createdAt)) && Number.isFinite(Date.parse(pending.expiresAt));
+}
+function mapError(value, step, signal) {
+  if (value instanceof EmailProofError) return value;
+  if (value instanceof DOMException && value.name === "TimeoutError") return new EmailProofError(step, "NETWORK");
+  const error = (0, import_sdk_core3.credentialError)(value);
+  const details = error.details;
+  switch (error.code) {
+    case "ISSUER_UNREADY":
+      return details.state === "rate_limited" ? new EmailProofError(step, "RATE_LIMITED", details.retryAfterMs, error.recoverable) : new EmailProofError(step, "ISSUER_UNAVAILABLE", void 0, error.recoverable);
+    case "OFFLINE":
+      if (signal?.aborted && signal.reason?.name !== "TimeoutError") return new EmailProofError(step, "CANCELED");
+      return new EmailProofError(step, "NETWORK");
+    case "UNSUPPORTED_PROFILE":
+    case "DESCRIPTOR_INVALID":
+      return new EmailProofError(step, "PROFILE_UNAVAILABLE");
+    case "PROOF_REJECTED":
+      return new EmailProofError("code", "CODE_REJECTED", void 0, true);
+    case "VERIFICATION_FAILED":
+      if (details.state === "proof_attempts_exhausted") return new EmailProofError("code", "CODE_ATTEMPTS_EXHAUSTED");
+      if (step === "credential") return new EmailProofError("credential", "CREDENTIAL_INVALID");
+      if (step === "code") return new EmailProofError("code", "CODE_REJECTED", void 0, false);
+      return new EmailProofError(step, "FAILED");
+    case "HOLDER_MISMATCH":
+      return new EmailProofError("credential", "CREDENTIAL_INVALID");
+    case "REQUEST_EXPIRED":
+      return new EmailProofError("session", "SESSION_EXPIRED");
+    case "REQUEST_SUBSTITUTED":
+      return new EmailProofError("session", "SESSION_INVALID");
+    case "SIGNATURE_REJECTED":
+      return new EmailProofError("credential", "SIGNATURE_REJECTED", void 0, error.recoverable);
+    case "CANCELED":
+      return new EmailProofError(step, "CANCELED");
+    default:
+      return new EmailProofError(step, "FAILED");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_EMAIL_PROOF_PROFILE,
+  EMAIL_PROOF_CREDENTIAL_TYPE,
+  EMAIL_PROOF_PENDING_MAX_MS,
+  EmailProofError,
+  OpenCredentialsHttpTransport,
+  acquireEmailProof,
+  completeEmailProof,
+  createEd25519HolderSigner,
+  createMemoryEmailProofPendingStore,
+  emailProofRequirement,
+  interpretCredentialFlow,
+  mailboxSubject,
+  requestEmailProofCode
+});
+//# sourceMappingURL=credentials.cjs.map