@tinycloud/node-sdk 3.8.0-beta.2 → 3.8.0-beta.21

package/dist/share-receive.js

@@ -0,0 +1,777 @@
+// src/share-receive.ts
+import {
+  credentialRequirementDigest as credentialRequirementDigest2,
+  createEmailCredentialRequirement as createEmailCredentialRequirement2
+} from "@tinycloud/sdk-core";
+import { inspectShare, ShareReceiveError as ShareReceiveError2 } from "@tinycloud/share-sdk";
+
+// src/credentials/email-proof.ts
+import {
+  canonicalDigest as canonicalDigest2,
+  createEmailCredentialRequirement,
+  credentialError,
+  credentialRequirementDigest,
+  CredentialError as CredentialError3,
+  descriptorSatisfiesRequirement,
+  encodeBase64Url as encodeBase64Url3,
+  sha256Base64Url as sha256Base64Url2,
+  validateCredentialFlowDescriptor,
+  verifyIssuedCredential
+} from "@tinycloud/sdk-core";
+
+// src/credentials/interpreter.ts
+import {
+  CredentialError,
+  encodeBase64Url,
+  holderBindingSigningBytes,
+  validateCredentialHolderBinding
+} from "@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 });
+});
+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 CredentialError("REQUEST_SUBSTITUTED", "Credential request identity changed");
+    if (state.state === "expired") throw new CredentialError("REQUEST_EXPIRED", "Credential request expired", { state: state.state, correlationId: state.correlationId });
+    if (state.state === "canceled") throw new CredentialError("CANCELED", "Credential request was canceled", { state: state.state, correlationId: state.correlationId });
+    if (state.state === "issuer_unready") throw new 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 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 = 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 CredentialError("REQUEST_SUBSTITUTED", "Holder binding was substituted");
+      const bytes = holderBindingSigningBytes(binding);
+      let signature = await input.signing.autoSign?.(binding, bytes, input.signal);
+      if (signature === void 0) {
+        if (!input.signing.requestApproval) throw new CredentialError("SIGNATURE_REJECTED", "OpenKey approval is required");
+        try {
+          signature = await input.signing.requestApproval(binding, bytes, input.signal);
+        } catch (cause) {
+          if (cause instanceof CredentialError) throw cause;
+          throw new CredentialError("SIGNATURE_REJECTED", "OpenKey approval was rejected", { cause });
+        }
+      }
+      if (!(signature instanceof Uint8Array) || signature.length === 0) throw new CredentialError("SIGNATURE_REJECTED", "OpenKey signature is invalid");
+      await input.transport.submitHolderSignature(input.requestId, input.verifier, 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 CredentialError) || cause.code !== "PROOF_REJECTED") throw cause;
+            const attemptsRemaining = input.descriptor.lifecycle.maxProofAttempts - attempt;
+            if (next.type !== "mailbox_otp" || attemptsRemaining <= 0) throw new 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
+import {
+  CredentialError as CredentialError2,
+  canonicalDigest,
+  credentialEndpointPath,
+  decodeBase64Url,
+  encodeBase64Url as encodeBase64Url2,
+  holderBindingCanonicalBytes,
+  sha256Base64Url,
+  validateCredentialHolderBinding as validateCredentialHolderBinding2
+} from "@tinycloud/sdk-core";
+function object(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new CredentialError2("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 CredentialError2("REQUEST_SUBSTITUTED", `${label} is invalid`);
+  return value;
+}
+function timestamp(value, label) {
+  if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) throw new CredentialError2("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 CredentialError2("VERIFICATION_FAILED", "Issued SD-JWT is invalid");
+  try {
+    return object(JSON.parse(new TextDecoder().decode(decodeBase64Url(part))), "SD-JWT payload");
+  } catch (cause) {
+    if (cause instanceof CredentialError2) throw cause;
+    throw new CredentialError2("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 CredentialError2("PROOF_REJECTED", "The proof was not accepted", { state: body.state, correlationId: body.correlationId }) : new CredentialError2("VERIFICATION_FAILED", "The proof attempt limit was reached", { state: "proof_attempts_exhausted", correlationId: body.correlationId });
+  if (body.code === "RATE_LIMITED") return new CredentialError2("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 CredentialError2("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 CredentialError2(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(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 CredentialError2("CANCELED", "Credential acquisition was canceled", { cause });
+      throw new CredentialError2("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 CredentialError2("REQUEST_EXPIRED", "Credential request expired");
+      if (response.status === 409) throw new CredentialError2("REQUEST_SUBSTITUTED", "Credential request was replayed or substituted");
+      if (response.status === 503) throw new CredentialError2("ISSUER_UNREADY", "Credential issuer is not ready", { retryAfterMs: Number(response.headers.get("retry-after")) * 1e3 || void 0 });
+      throw new CredentialError2("VERIFICATION_FAILED", "OpenCredentials rejected the request");
+    }
+    if (response.status === 204) return void 0;
+    try {
+      return await response.json();
+    } catch (cause) {
+      throw new CredentialError2("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 CredentialError2("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 CredentialError2("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 CredentialError2("REQUEST_SUBSTITUTED", "Credential state is unsupported");
+  }
+  async beginStep(id, verifier, stepId, signal) {
+    const step = this.proofStep();
+    if (stepId !== step) throw new CredentialError2("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 CredentialError2("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 CredentialError2("REQUEST_SUBSTITUTED", "Credential proof step is substituted");
+    const nonce = this.nonces.get(id);
+    if (!nonce) throw new CredentialError2("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 CredentialError2("REQUEST_SUBSTITUTED", "Holder binding response is invalid");
+    const binding = validateCredentialHolderBinding2(raw.binding);
+    if (encodeBase64Url2(holderBindingCanonicalBytes(binding)) !== raw.canonical) throw new CredentialError2("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 CredentialError2("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 canonicalDigest(this.descriptor) || raw.issuer !== this.descriptor.issuer.did || raw.issuerKid !== this.descriptor.issuer.kid || typeof raw.credential !== "string" || await sha256Base64Url(raw.credential) !== raw.credentialDigest) throw new CredentialError2("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 CredentialError2("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 CredentialError2("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 CredentialError2("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 CredentialError2("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 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 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 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);
+}
+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 credentialRequirementDigest(requirement);
+  const descriptor = await witnessDescriptor(profile, requirement, { fetch: input.fetch, signal }, "request");
+  const descriptorDigest = await canonicalDigest2(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 sha256Base64Url2(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 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 canonicalDigest2(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 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, descriptor };
+  } catch (error) {
+    throw mapError(error, "credential", signal);
+  }
+}
+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 createEmailCredentialRequirement({ email: address, profile: { id: profile, version: 1 }, credentialType: EMAIL_PROOF_CREDENTIAL_TYPE });
+}
+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 canonicalDigest2(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 CredentialError3("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 CredentialError3("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 CredentialError3("OFFLINE", "Credential discovery is unavailable", { cause });
+  }
+  if (!response.ok) throw new CredentialError3(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 CredentialError3("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 = validateCredentialFlowDescriptor(entry.descriptor);
+      if (descriptorSatisfiesRequirement(candidate, requirement) && entry.descriptorDigest === await canonicalDigest2(candidate)) return candidate;
+    } catch {
+    }
+  }
+  throw new CredentialError3("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 encodeBase64Url3(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 = 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");
+  }
+}
+
+// src/share-receive-access.ts
+import { admitPolicyCredentialV4, credentialMatchesRequirement, verifyOwnerNodeBinding } from "@tinycloud/sdk-core";
+import { ShareReceiveError, ShareRecipientClient } from "@tinycloud/share-sdk";
+async function openVerifiedAgentShare(pending, result, requirement, options) {
+  const { envelope } = pending;
+  if (!credentialMatchesRequirement(requirement, result.verified, options.holder.did, new Date(options.now?.() ?? Date.now()))) {
+    throw new ShareReceiveError("authorization-denied", "email credential does not match this share");
+  }
+  if (envelope.target.nodeAudience !== envelope.attestedEnforcerBinding.nodeAudience) {
+    throw new ShareReceiveError("envelope-invalid", "share Node binding is invalid");
+  }
+  try {
+    await verifyOwnerNodeBinding({
+      registryUrl: options.registryOrigin,
+      ownerDid: envelope.policy.ownerDid,
+      nodeOrigin: envelope.target.origin,
+      nodeDid: envelope.target.nodeAudience,
+      fetch: options.fetch,
+      signal: options.signal
+    });
+  } catch {
+    throw new ShareReceiveError("authorization-denied", "share owner Node binding could not be verified");
+  }
+  let admitted;
+  try {
+    admitted = await admitPolicyCredentialV4({
+      policy: envelope.policy,
+      policyCid: envelope.policyCid,
+      policyRootCid: envelope.policyRoot.cid,
+      enforcementRootCid: envelope.enforcementRoot.cid,
+      expectedNodeAudience: envelope.target.nodeAudience,
+      expectedEnforcerDid: envelope.attestedEnforcerBinding.enforcerDid,
+      requirement,
+      credential: result.verified,
+      requestedCapabilities: envelope.policy.capabilityCeiling,
+      requestedExpiresAt: envelope.expiry,
+      sign: options.holder.sign,
+      nodeOrigin: envelope.target.origin,
+      fetch: options.fetch,
+      signal: options.signal
+    });
+  } catch {
+    throw new ShareReceiveError("authorization-denied", "share node refused the email credential");
+  }
+  const client = new ShareRecipientClient({
+    nodeOrigin: envelope.target.origin,
+    holderDid: options.holder.did,
+    envelope,
+    policyAuthorization: { authorization: admitted.session.authorization, cid: admitted.session.cid },
+    sign: options.holder.sign,
+    fetchFn: options.fetch,
+    signal: options.signal
+  });
+  let opened;
+  try {
+    const response = await client.nativeInvoke({ action: "get", resource: envelope.resource });
+    if (!response.ok) throw new ShareReceiveError("authorization-denied", "share node refused the read");
+    opened = await client.decryptV3Content(new Uint8Array(await response.arrayBuffer()));
+  } catch (error) {
+    if (error instanceof ShareReceiveError) throw error;
+    throw new ShareReceiveError("decrypt-failed", "share content could not be opened");
+  }
+  if (Date.parse(envelope.expiry) <= (options.now?.() ?? Date.now())) throw new ShareReceiveError("expired", "share has expired");
+  let text;
+  if (/^(text\/|application\/(?:json|xml|javascript)(?:;|$))/.test(opened.mediaType)) {
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(opened.bytes);
+    } catch {
+    }
+  }
+  return { metadata: pending.metadata, bytes: opened.bytes, ...text === void 0 ? {} : { text }, mediaType: opened.mediaType, untrusted: true };
+}
+
+// src/share-receive.ts
+function requirementFor(envelope) {
+  if (envelope.recipientMatcher.kind !== "exactEmail" || envelope.policy.schema !== "xyz.tinycloud.policy/policy/v2") {
+    throw new ShareReceiveError2("unsupported-target", "this receive path accepts exact-email shares only");
+  }
+  const policy = envelope.policy;
+  return createEmailCredentialRequirement2({
+    email: envelope.recipientMatcher.value,
+    profile: policy.credentialRequirement.profile,
+    credentialType: policy.credentialRequirement.credentialType
+  });
+}
+function active(envelope, now) {
+  if (Date.parse(envelope.expiry) <= now) throw new ShareReceiveError2("expired", "share has expired");
+}
+async function requestAgentShareEmailProof(link, options) {
+  let envelope;
+  const metadata = (await inspectShare(link, {
+    ...options,
+    onResolvedAddressedEnvelope: (value) => {
+      if (value.version === 3) envelope = value;
+    }
+  })).metadata;
+  if (envelope === void 0) throw new ShareReceiveError2("envelope-invalid", "share envelope is invalid");
+  const requirement = requirementFor(envelope);
+  if (await credentialRequirementDigest2(requirement) !== envelope.policy.credentialRequirement.requirementDigest) {
+    throw new ShareReceiveError2("envelope-invalid", "share credential requirement is invalid");
+  }
+  const proof = await requestEmailProofCode({ address: requirement.claims.email, holder: options.holder, fetch: options.fetch, signal: options.signal });
+  return { metadata, envelope, proof };
+}
+async function completeAgentShareReceive(pending, code, options) {
+  const { envelope } = pending;
+  active(envelope, options.now?.() ?? Date.now());
+  const requirement = requirementFor(envelope);
+  if (await credentialRequirementDigest2(requirement) !== envelope.policy.credentialRequirement.requirementDigest) {
+    throw new ShareReceiveError2("envelope-invalid", "share credential requirement is invalid");
+  }
+  if (pending.proof.address !== requirement.claims.email || pending.proof.holderDid !== options.holder.did) {
+    throw new ShareReceiveError2("authorization-denied", "email proof does not belong to this recipient session");
+  }
+  const result = await completeEmailProof({ pending: pending.proof, code, holder: options.holder, fetch: options.fetch, signal: options.signal });
+  return openVerifiedAgentShare(pending, result, requirement, options);
+}
+export {
+  completeAgentShareReceive,
+  requestAgentShareEmailProof
+};
+//# sourceMappingURL=share-receive.js.map