@tinycloud/share-sdk 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/index.js

@@ -152,10 +152,10 @@ var util;
       return obj[e];
     });
   };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object4) => {
     const keys = [];
-    for (const key in object3) {
-      if (Object.prototype.hasOwnProperty.call(object3, key)) {
+    for (const key in object4) {
+      if (Object.prototype.hasOwnProperty.call(object4, key)) {
         keys.push(key);
       }
     }
@@ -5555,7 +5555,74 @@ function checkBearerDelegation(envelope, options = {}) {
   return { ok: true, delegateeDid: audience };
 }
 var ENVELOPE_AAD_LABEL = "tinycloud-share-envelope-v1";
+var SEALED_BLOB_VERSION = 1;
 var AAD = utf8Bytes(ENVELOPE_AAD_LABEL);
+var KEY_LENGTH = 32;
+var NONCE_LENGTH = 12;
+var TAG_LENGTH = 16;
+var HEADER_LENGTH = 1;
+function assertKey(key32) {
+  if (key32.length !== KEY_LENGTH) {
+    throw new TypeError(`key must be ${KEY_LENGTH} bytes, got ${key32.length}`);
+  }
+}
+async function importAesKey(key32, usage) {
+  assertKey(key32);
+  return globalThis.crypto.subtle.importKey(
+    "raw",
+    key32,
+    "AES-GCM",
+    false,
+    [usage]
+  );
+}
+function generateKey() {
+  return globalThis.crypto.getRandomValues(new Uint8Array(KEY_LENGTH));
+}
+async function seal(plaintextBytes, key32) {
+  const { nonce, ciphertext } = await encryptEnvelope(plaintextBytes, key32);
+  const blob = new Uint8Array(HEADER_LENGTH + nonce.length + ciphertext.length);
+  blob[0] = SEALED_BLOB_VERSION;
+  blob.set(nonce, HEADER_LENGTH);
+  blob.set(ciphertext, HEADER_LENGTH + nonce.length);
+  return { blob, cid: await computeCid(blob) };
+}
+async function open(blob, key32) {
+  if (blob.length < HEADER_LENGTH + NONCE_LENGTH + TAG_LENGTH) {
+    throw new TypeError(`sealed blob too short: ${blob.length} bytes`);
+  }
+  if (blob[0] !== SEALED_BLOB_VERSION) {
+    throw new TypeError(`unknown sealed blob version: ${blob[0]}`);
+  }
+  const nonce = blob.subarray(HEADER_LENGTH, HEADER_LENGTH + NONCE_LENGTH);
+  const ciphertext = blob.subarray(HEADER_LENGTH + NONCE_LENGTH);
+  return decryptEnvelope(nonce, ciphertext, key32);
+}
+async function encryptEnvelope(plaintextBytes, key32) {
+  const key = await importAesKey(key32, "encrypt");
+  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
+  const ciphertext = new Uint8Array(
+    await globalThis.crypto.subtle.encrypt(
+      { name: "AES-GCM", iv: nonce, additionalData: AAD },
+      key,
+      plaintextBytes
+    )
+  );
+  return { nonce, ciphertext };
+}
+async function decryptEnvelope(nonce, ciphertext, key32) {
+  if (nonce.length !== NONCE_LENGTH) {
+    throw new TypeError(`nonce must be ${NONCE_LENGTH} bytes, got ${nonce.length}`);
+  }
+  const key = await importAesKey(key32, "decrypt");
+  return new Uint8Array(
+    await globalThis.crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: nonce, additionalData: AAD },
+      key,
+      ciphertext
+    )
+  );
+}
 function isPlainRecord(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
@@ -5788,8 +5855,6 @@ function base32Lower(bytes3) {
   return output;
 }
 var KEY_LENGTH2 = 32;
-var INLINE_PREFIX = "#tc2=";
-var PUBLIC_INLINE_PARAMETER = "tc2";
 var MAX_INLINE_BYTES = 256 * 1024;
 function assertCanonicalCid(cidString) {
   const cid2 = CID.parse(cidString);
@@ -5798,62 +5863,61 @@ function assertCanonicalCid(cidString) {
     throw new TypeError(`not a canonical CIDv1 raw sha2-256 base32 CID: ${cidString}`);
   }
 }
-async function encodePublicInlineShareUrl(parts) {
+async function encodeSealedInlineShareUrl(parts) {
   if (!isCanonicalHttpsOrigin(parts.origin)) throw new TypeError("origin must be a canonical https origin");
-  if (parts.plaintext.byteLength === 0 || parts.plaintext.byteLength > MAX_INLINE_BYTES) throw new RangeError("public inline envelope is outside the allowed size");
-  const ciphertextCid = await computeCid(parts.plaintext);
-  const payloadBytes = new TextEncoder().encode(canonicalize({
+  if (parts.ciphertext.byteLength === 0 || parts.ciphertext.byteLength > MAX_INLINE_BYTES) throw new RangeError("inline ciphertext is outside the allowed size");
+  if (parts.key32.byteLength !== KEY_LENGTH2) throw new TypeError("inline key must be 32 bytes");
+  const ciphertextCid = await computeCid(parts.ciphertext);
+  const payload = canonicalize({
     v: 2,
-    c: toBase64Url(parts.plaintext),
-    cid: ciphertextCid
-  }));
+    c: toBase64Url(parts.ciphertext),
+    cid: ciphertextCid,
+    k: toBase64Url(parts.key32)
+  });
+  const payloadBytes = new TextEncoder().encode(payload);
   if (payloadBytes.byteLength > MAX_INLINE_BYTES * 2) throw new RangeError("inline URL is too large");
-  return `${parts.origin}/viewer?${PUBLIC_INLINE_PARAMETER}=${toBase64Url(payloadBytes)}`;
+  return `${parts.origin}/s/inline#v=2&p=${toBase64Url(payloadBytes)}`;
 }
-function parseInlineShareUrl(url, options = {}) {
+async function parseSealedInlineShareUrl(url, options = {}) {
   const parsed = new URL(url);
-  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "") throw new TypeError("inline share URL must be canonical HTTPS without userinfo");
-  if (!isCanonicalHttpsOrigin(parsed.origin) || options.expectedOrigin !== void 0 && parsed.origin !== options.expectedOrigin) throw new TypeError("inline share URL origin is not trusted");
-  if (parsed.pathname !== "/viewer") throw new TypeError("not a TinyCloud policy share URL");
-  const secretPayload = parsed.search === "" && parsed.hash.startsWith(INLINE_PREFIX) ? parsed.hash.slice(INLINE_PREFIX.length) : void 0;
-  const publicPayload = parsed.hash === "" && parsed.searchParams.size === 1 ? parsed.searchParams.get(PUBLIC_INLINE_PARAMETER) ?? void 0 : void 0;
-  if (secretPayload === void 0 && publicPayload === void 0) throw new TypeError("not a canonical TinyCloud policy share URL");
-  if (publicPayload !== void 0 && parsed.search !== `?${PUBLIC_INLINE_PARAMETER}=${publicPayload}`) throw new TypeError("public inline URL is not canonical");
+  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "") throw new TypeError("sealed inline share URL must be canonical HTTPS without userinfo");
+  if (!isCanonicalHttpsOrigin(parsed.origin) || options.expectedOrigin !== void 0 && parsed.origin !== options.expectedOrigin) throw new TypeError("sealed inline share URL origin is not trusted");
+  if (parsed.pathname !== "/s/inline" || parsed.search !== "") throw new TypeError("not a Node sealed-inline share URL");
+  if (url !== `${parsed.origin}/s/inline${parsed.hash}`) throw new TypeError("sealed inline share URL is not lexically canonical");
+  const prefix = "#v=2&p=";
+  if (!parsed.hash.startsWith(prefix)) throw new TypeError("sealed inline URL is missing its canonical fragment");
+  const encoded = parsed.hash.slice(prefix.length);
+  if (encoded.length === 0 || parsed.hash !== `${prefix}${encoded}`) throw new TypeError("sealed inline URL fragment is not canonical");
   let payloadBytes;
   try {
-    payloadBytes = fromBase64Url(secretPayload ?? publicPayload);
+    payloadBytes = fromBase64Url(encoded);
   } catch {
-    throw new TypeError("inline payload is not canonical base64url");
+    throw new TypeError("sealed inline payload is not canonical base64url");
   }
-  if (payloadBytes.byteLength === 0 || payloadBytes.byteLength > MAX_INLINE_BYTES * 2) throw new TypeError("inline payload is too large");
+  if (payloadBytes.byteLength === 0 || payloadBytes.byteLength > MAX_INLINE_BYTES * 2) throw new TypeError("sealed inline payload is too large");
+  const payloadText = new TextDecoder("utf-8", { fatal: true }).decode(payloadBytes);
   let value;
   try {
-    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(payloadBytes));
+    value = JSON.parse(payloadText);
   } catch {
-    throw new TypeError("inline payload is not valid JSON");
+    throw new TypeError("sealed inline payload is not valid JSON");
   }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("inline payload must be an object");
-  if (canonicalize(value) !== new TextDecoder("utf-8").decode(payloadBytes)) throw new TypeError("inline payload is not canonical JSON");
+  if (typeof value !== "object" || value === null || Array.isArray(value) || canonicalize(value) !== payloadText) throw new TypeError("sealed inline payload is not canonical JSON");
   const record = value;
-  const keys = Object.keys(record);
-  if (!keys.every((key) => key === "v" || key === "c" || key === "cid" || key === "k") || record.v !== 2 || typeof record.c !== "string" || typeof record.cid !== "string" || publicPayload !== void 0 && (keys.length !== 3 || record.k !== void 0)) throw new TypeError("inline payload has invalid fields");
+  if (Object.keys(record).length !== 4 || record.v !== 2 || typeof record.c !== "string" || typeof record.cid !== "string" || typeof record.k !== "string") throw new TypeError("sealed inline payload has invalid fields");
   let ciphertext;
+  let key32;
   try {
     ciphertext = fromBase64Url(record.c);
+    key32 = fromBase64Url(record.k);
   } catch {
-    throw new TypeError("inline ciphertext is not canonical base64url");
+    throw new TypeError("sealed inline payload has invalid base64url material");
   }
-  if (ciphertext.byteLength === 0 || ciphertext.byteLength > MAX_INLINE_BYTES) throw new TypeError("inline ciphertext is outside the allowed size");
+  if (ciphertext.byteLength === 0 || ciphertext.byteLength > MAX_INLINE_BYTES) throw new TypeError("sealed inline ciphertext is outside the allowed size");
+  if (key32.byteLength !== KEY_LENGTH2) throw new TypeError("sealed inline key must be 32 bytes");
   assertCanonicalCid(record.cid);
-  if (record.k !== void 0 && typeof record.k !== "string") throw new TypeError("inline key must be base64url");
-  let key32;
-  try {
-    key32 = record.k === void 0 ? void 0 : fromBase64Url(record.k);
-  } catch {
-    throw new TypeError("inline key is not canonical base64url");
-  }
-  if (key32 !== void 0 && key32.length !== KEY_LENGTH2) throw new TypeError("inline key must be 32 bytes");
-  return { kind: "inline", ciphertextCid: record.cid, ciphertext, ...key32 === void 0 ? {} : { key32 } };
+  if (await computeCid(ciphertext) !== record.cid) throw new TypeError("sealed inline ciphertext does not match its CID");
+  return { kind: "inline", ciphertextCid: record.cid, ciphertext, key32 };
 }
 
 // src/receive.ts
@@ -5901,19 +5965,17 @@ async function resolvePolicyShare(link, options) {
   let parsed;
   try {
     url = new URL(link);
-    if (url.pathname !== "/viewer" || url.hash !== "" || url.searchParams.size !== 1 || !url.searchParams.has("tc2")) throw new Error("not public Policy/v3");
-    parsed = parseInlineShareUrl(link, { ...options.expectedOrigin === void 0 ? {} : { expectedOrigin: options.expectedOrigin } });
-    if (parsed.key32 !== void 0) throw new Error("secret inline transport is retired");
+    parsed = await parseSealedInlineShareUrl(link, { ...options.expectedOrigin === void 0 ? {} : { expectedOrigin: options.expectedOrigin } });
   } catch {
     throw new ShareReceiveError("invalid-link", "share link format is invalid");
   }
   const limit = options.maxSealedBlobBytes ?? DEFAULT_MAX_SEALED_BLOB_BYTES;
-  if (!Number.isSafeInteger(limit) || limit <= 0 || parsed.ciphertext.byteLength > limit) throw new ShareReceiveError("max-bytes-exceeded", "public policy envelope exceeds the configured byte limit");
-  if (await computeCid(parsed.ciphertext) !== parsed.ciphertextCid) throw new ShareReceiveError("cid-mismatch", "public envelope bytes do not match the link CID");
+  if (!Number.isSafeInteger(limit) || limit <= 0 || parsed.ciphertext.byteLength > limit) throw new ShareReceiveError("max-bytes-exceeded", "sealed policy envelope exceeds the configured byte limit");
+  if (await computeCid(parsed.ciphertext) !== parsed.ciphertextCid) throw new ShareReceiveError("cid-mismatch", "sealed envelope bytes do not match the link CID");
   options.signal?.throwIfAborted();
   let envelope;
   try {
-    const encoded = new TextDecoder("utf-8", { fatal: true }).decode(parsed.ciphertext);
+    const encoded = new TextDecoder("utf-8", { fatal: true }).decode(await open(parsed.ciphertext, parsed.key32));
     const value = JSON.parse(encoded);
     if (canonicalize(value) !== encoded) throw new Error("non-canonical envelope");
     envelope = shareEnvelopeV3Schema.parse(value);
@@ -6588,10 +6650,23 @@ function publicationResult(input) {
   Object.defineProperty(result, "deliveryMaterial", { enumerable: false, value: input.deliveryMaterial });
   return result;
 }
+var EMAIL_DOMAIN_PROFILE = { id: "tinycloud.email-domain-proof/v1", version: 1 };
+var EMAIL_CREDENTIAL_TYPE = { id: "opencredentials.email/v1", version: 1 };
+var EMAIL_DOMAIN_DESCRIPTOR_DIGEST = "33X5mAkZZgApdD3xh_T-3KS5moop0J2Nloi2nqWsdWY";
+function assertEmailDomainPolicy(options, domain) {
+  if (!options.actions.every((action) => action === "read" || action === "list") || !options.policyActions.every((action) => action === "tinycloud.kv/get" || action === "tinycloud.kv/list" || action === "tinycloud.kv/metadata")) throw new TypeError("email-domain shares are view-only");
+  if (options.deliveryEmail !== void 0) throw new TypeError("email-domain shares are not emailed");
+  const commitment = options.credentialRequirement;
+  if (commitment === void 0) throw new TypeError("email-domain shares require a credential requirement");
+  if (canonicalize(commitment.profile) !== canonicalize(EMAIL_DOMAIN_PROFILE) || canonicalize(commitment.credentialType) !== canonicalize(EMAIL_CREDENTIAL_TYPE) || commitment.descriptorDigest !== EMAIL_DOMAIN_DESCRIPTOR_DIGEST) throw new TypeError("email-domain shares require the email-domain credential profile");
+  const expected = { type: "TinyCloudCredentialRequirement", version: 1, profile: EMAIL_DOMAIN_PROFILE, credentialType: EMAIL_CREDENTIAL_TYPE, claims: { emailDomain: domain }, maxAgeSeconds: 300 };
+  if (toBase64Url(sha2563(textEncoder.encode(canonicalize(expected)))) !== commitment.requirementDigest) throw new TypeError("credential requirement is not bound to the email domain");
+}
 async function publishAddressedShare(options) {
   assertSafeInput(options);
   const target = normalizeShareTarget(options.target);
   if (target.kind === "bearer") throw new TypeError("addressed target is required");
+  if (target.kind === "emailDomain") assertEmailDomainPolicy(options, target.domain);
   const expiry = rfc3339Seconds(options.expiresAt);
   const matcher = targetMatcher(target);
   const capabilities = sortCanonical([
@@ -6664,14 +6739,25 @@ async function publishAddressedShare(options) {
   const envelope = { ...unsigned, signature: { signerDid: options.authority.ownerDid, algorithm: "Ed25519", value: toBase64Url(envelopeSignature) } };
   shareEnvelopeV3Schema.parse(envelope);
   const envelopeBytes = textEncoder.encode(canonicalize(envelope));
-  const envelopeCid = await computeCid(envelopeBytes);
-  const url = await encodePublicInlineShareUrl({ origin: options.shareOrigin, plaintext: envelopeBytes });
-  const deliveryMaterial = { envelope, shareCid: envelopeCid };
+  const envelopeKeyBytes = generateKey();
+  const sealed = await seal(envelopeBytes, envelopeKeyBytes);
+  const envelopeKey = toBase64Url(envelopeKeyBytes);
+  const url = await encodeSealedInlineShareUrl({
+    origin: options.shareOrigin,
+    ciphertext: sealed.blob,
+    key32: envelopeKeyBytes
+  });
+  const deliveryMaterial = {
+    envelope,
+    shareCid: sealed.cid,
+    sealedEnvelope: toBase64Url(sealed.blob),
+    envelopeKey
+  };
   options.onDeliveryMaterial?.(deliveryMaterial);
   return publicationResult({
     options,
     url,
-    envelopeCid,
+    envelopeCid: sealed.cid,
     matcher,
     policyCid: created.policyCid,
     policyRootCid: policyRoot.cid,
@@ -7728,6 +7814,119 @@ async function defaultIdempotencyKey(shareId, recipient) {
   return `tinycloud-share:${shareId}:${toBase64Url(digest3)}`;
 }
 
+// src/credential-invitation.ts
+var CredentialInvitationError = class extends Error {
+  constructor(code3, message) {
+    super(message);
+    this.code = code3;
+    this.name = "CredentialInvitationError";
+  }
+};
+function canonicalOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CredentialInvitationError(
+      "invalid-origin",
+      "credential invitation origin is invalid"
+    );
+  }
+  if (url.origin !== value || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || url.protocol !== "https:")
+    throw new CredentialInvitationError(
+      "invalid-origin",
+      "credential invitation origin is invalid"
+    );
+  return url.origin;
+}
+function object2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function validateReceipt(receipt, shareUrl) {
+  if (!object2(receipt) || !object2(receipt.request) || !object2(receipt.admission) || !object2(receipt.proof)) {
+    throw new CredentialInvitationError(
+      "invalid-receipt",
+      "credential invitation receipt is invalid"
+    );
+  }
+  if (receipt.request.returnLink !== shareUrl) {
+    throw new CredentialInvitationError(
+      "invalid-receipt",
+      "credential invitation is not bound to the share link"
+    );
+  }
+  let link;
+  try {
+    link = new URL(shareUrl);
+  } catch {
+    throw new CredentialInvitationError(
+      "invalid-receipt",
+      "credential invitation share link is invalid"
+    );
+  }
+  if (link.search !== "" || link.pathname !== "/s/inline") {
+    throw new CredentialInvitationError(
+      "invalid-receipt",
+      "credential invitation share link must be sealed inline"
+    );
+  }
+  try {
+    await parseSealedInlineShareUrl(shareUrl);
+  } catch {
+    throw new CredentialInvitationError(
+      "invalid-receipt",
+      "credential invitation share link is invalid"
+    );
+  }
+}
+async function deliverCredentialInvitation(input) {
+  const credentialsOrigin = canonicalOrigin(input.credentialsOrigin);
+  await validateReceipt(input.receipt, input.shareUrl);
+  const fetchFn = input.fetchFn ?? globalThis.fetch;
+  let response;
+  try {
+    response = await fetchFn(`${credentialsOrigin}/v1/credential-invitations`, {
+      method: "POST",
+      credentials: "omit",
+      redirect: "error",
+      referrerPolicy: "no-referrer",
+      headers: {
+        accept: "application/json",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(input.receipt),
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    });
+  } catch {
+    throw new CredentialInvitationError(
+      "transport",
+      "credential invitation delivery is unavailable"
+    );
+  }
+  if (response.status !== 202) {
+    throw new CredentialInvitationError(
+      "rejected",
+      "credential invitation delivery was not accepted"
+    );
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new CredentialInvitationError(
+      "invalid-response",
+      "credential invitation response is invalid"
+    );
+  }
+  if (!object2(body) || Object.keys(body).length !== 1 || body.status !== "accepted") {
+    throw new CredentialInvitationError(
+      "invalid-response",
+      "credential invitation response is invalid"
+    );
+  }
+  return { status: "accepted" };
+}
+
 // src/lifecycle.ts
 function targetKind2(record) {
   if (record.targetKind !== void 0) return record.targetKind;
@@ -7834,7 +8033,7 @@ var DOMAIN = SHARE_V2_PROTOCOL.challengeDomain;
 var PRESENTATION_DOMAIN = SHARE_V2_PROTOCOL.sessionDomain;
 var SESSION_DOMAIN = SHARE_V2_PROTOCOL.sessionDomain;
 var INVOCATION_DOMAIN = SHARE_V2_PROTOCOL.invocationDomain;
-function object2(value, label) {
+function object3(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} is invalid`);
   return value;
 }
@@ -7893,11 +8092,11 @@ function nativeAction(action) {
   return action === "list" ? "tinycloud.kv/list" : action === "edit" ? "tinycloud.kv/put" : "tinycloud.kv/get";
 }
 function policyAttenuationForV3(envelope) {
-  const policy = object2(envelope.policy, "v3 policy");
+  const policy = object3(envelope.policy, "v3 policy");
   if (!Array.isArray(policy.capabilityCeiling)) throw new Error("v3 policy capability ceiling is invalid");
   const attenuation = {};
   for (const raw of policy.capabilityCeiling) {
-    const capability = object2(raw, "v3 policy capability");
+    const capability = object3(raw, "v3 policy capability");
     if (typeof capability.resource !== "string" || attenuation[capability.resource] !== void 0) throw new Error("v3 policy capability is invalid");
     if (capability.kind === "encryption") {
       if (capability.action !== "tinycloud.encryption/decrypt") throw new Error("v3 policy capability is invalid");
@@ -7955,8 +8154,8 @@ function verifyV3PolicyAuthorization(input) {
   const factKeys = Object.keys(fact);
   const legacyShape = factKeys.length === POLICY_SESSION_FACT_KEYS.length && factKeys.every((key) => POLICY_SESSION_FACT_KEYS.includes(key)) && POLICY_SESSION_FACT_KEYS.every((key) => key in fact);
   const v4Shape = factKeys.length === POLICY_SESSION_FACT_KEYS.length + POLICY_SESSION_V4_AUDIT_FACT_KEYS.length && factKeys.every((key) => POLICY_SESSION_FACT_KEYS.includes(key) || POLICY_SESSION_V4_AUDIT_FACT_KEYS.includes(key)) && POLICY_SESSION_FACT_KEYS.every((key) => key in fact) && POLICY_SESSION_V4_AUDIT_FACT_KEYS.every((key) => key in fact);
-  const binding = object2(input.envelope.attestedEnforcerBinding, "v3 attested enforcer binding");
-  const policy = object2(input.envelope.policy, "v3 policy");
+  const binding = object3(input.envelope.attestedEnforcerBinding, "v3 attested enforcer binding");
+  const policy = object3(input.envelope.policy, "v3 policy");
   const now = Math.floor(Date.now() / 1e3);
   if (!legacyShape && !v4Shape || POLICY_SESSION_DIGEST_FACT_KEYS.some((key) => !LOWER_SHA256_HEX.test(fact[key])) || v4Shape && (!LOWER_SHA256_HEX.test(fact.credentialIdAuditDigestHex) || !LOWER_SHA256_HEX.test(fact.presentationJtiAuditDigestHex)) || compact.payload.aud !== input.holderDid || compact.payload.iss.split("#", 1)[0] !== fact.nodeAudience || fact.profile !== "policy-session-ucan/v1" || fact.ownerDid !== policy.ownerDid || fact.policyId !== policy.policyId || fact.policyCid !== input.envelope.policyCid || fact.contentSourceDigestHex !== input.envelope.contentSourceDigestHex || fact.enforcerDid !== binding.enforcerDid || fact.nodeAudience !== binding.nodeAudience || fact.recipientDid !== input.holderDid || fact.policyDelegationCid !== input.envelope.policyRoot.cid || fact.enforcementDelegationCid !== input.envelope.enforcementRoot.cid || typeof fact.remainingRedelegationDepth !== "number" || !Number.isInteger(fact.remainingRedelegationDepth) || fact.remainingRedelegationDepth < 0 || fact.remainingRedelegationDepth > 8 || compact.payload.prf.length !== 2 || compact.payload.prf[0] !== input.envelope.policyRoot.cid || compact.payload.prf[1] !== input.envelope.enforcementRoot.cid || compact.payload.nbf > now || compact.payload.exp <= now || compact.payload.exp - compact.payload.nbf > 60 || canonicalize(compact.payload.att) !== canonicalize(policyAttenuationForV3(input.envelope))) throw new Error("v3 policy delegation signed binding mismatch");
   return compact;
@@ -8047,7 +8246,7 @@ var ShareRecipientClient = class {
     if (this.session === void 0) await this.establish(envelope);
     const response = await this.nativeInvoke({ action: "get", resource: envelope.resource });
     if (!response.ok) throw new Error("share recipient read was rejected");
-    const value = object2(await response.json(), "share read response");
+    const value = object3(await response.json(), "share read response");
     const expectedAction = nativeAction("read");
     if (value.type !== "TinyCloudShareInvokeResponse" || value.version !== 2 || value.action !== expectedAction || value.resource !== envelope.resource.path || typeof value.content !== "string" || typeof value.bodyDigest !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(value.bodyDigest) || !Object.hasOwn(value, "proof")) throw new Error("share read response is invalid");
     const content = fromBase64Url(value.content);
@@ -8062,7 +8261,7 @@ var ShareRecipientClient = class {
   }
   async establishV3(envelope) {
     if (this.options.buildPresentation === void 0) throw new Error("share presentation builder is required");
-    const attestedEnforcer = object2(envelope.attestedEnforcerBinding, "v3 attested enforcer binding");
+    const attestedEnforcer = object3(envelope.attestedEnforcerBinding, "v3 attested enforcer binding");
     if (attestedEnforcer.enforcerDid !== envelope.target.nodeAudience || typeof attestedEnforcer.nodeAudience !== "string") throw new Error("v3 attested enforcer binding mismatch");
     try {
       ed25519PublicKeyFromDidKey(attestedEnforcer.nodeAudience);
@@ -8077,7 +8276,7 @@ var ShareRecipientClient = class {
       ...this.options.signal === void 0 ? {} : { signal: this.options.signal }
     });
     if (!challengeResponse.ok) throw new Error(`v3 policy challenge rejected (${challengeResponse.status})`);
-    const challenge = object2(await challengeResponse.json(), "v3 policy challenge");
+    const challenge = object3(await challengeResponse.json(), "v3 policy challenge");
     if (typeof challenge.challengeId !== "string" || typeof challenge.nonce !== "string" || challenge.policyCid !== envelope.policyCid || challenge.recipientDid !== this.options.holderDid || challenge.nodeAudience !== attestedEnforcer.nodeAudience || challenge.enforcerDid !== void 0 && challenge.enforcerDid !== attestedEnforcer.enforcerDid || typeof challenge.expiresAt !== "string" || !Number.isFinite(Date.parse(challenge.expiresAt)) || Date.parse(challenge.expiresAt) <= Date.now()) throw new Error("v3 policy challenge binding mismatch");
     const material = await this.options.buildPresentation({
       challenge,
@@ -8098,7 +8297,7 @@ var ShareRecipientClient = class {
       ...this.options.signal === void 0 ? {} : { signal: this.options.signal }
     });
     if (!delegationResponse.ok) throw new Error(`v3 policy delegation rejected (${delegationResponse.status})`);
-    const delegation = object2(await delegationResponse.json(), "v3 policy delegation");
+    const delegation = object3(await delegationResponse.json(), "v3 policy delegation");
     if (delegation.admitted !== true || typeof delegation.sessionCid !== "string" || typeof delegation.authorization !== "string") throw new Error("v3 policy delegation response is not admitted");
     const compact = verifyV3PolicyAuthorization({ authorization: delegation.authorization, cid: delegation.sessionCid, envelope, holderDid: this.options.holderDid });
     const fact = compact.payload.fct[0];
@@ -8140,7 +8339,7 @@ var ShareRecipientClient = class {
       this.options.onStage?.("decryption");
       const response = await this.fetchFn(new URL("/invoke", this.options.nodeOrigin), { method: "POST", redirect: "error", headers: { accept: "application/json", "content-type": "application/json", Authorization: invocation.authorization }, body: JSON.stringify(body), ...this.options.signal === void 0 ? {} : { signal: this.options.signal } });
       if (!response.ok) throw new Error(`v3 decrypt invocation rejected (${response.status})`);
-      const value = object2(await response.json(), "v3 decrypt response");
+      const value = object3(await response.json(), "v3 decrypt response");
       const allowed = ["type", "targetNode", "networkId", "invocationCid", "encryptedSymmetricKeyHash", "receiverPublicKeyHash", "wrappedKey", "alg", "keyVersion", "requestHash", "nodeId", "nodeSignature"];
       if (Object.keys(value).length !== allowed.length || Object.keys(value).some((key) => !allowed.includes(key)) || value.type !== "tinycloud.encryption.decrypt-result/v1" || value.targetNode !== body.targetNode || value.nodeId !== body.targetNode || value.networkId !== body.networkId || value.invocationCid !== invocation.cid || value.encryptedSymmetricKeyHash !== body.encryptedSymmetricKeyHash || value.receiverPublicKeyHash !== receiverPublicKeyHash || value.alg !== body.alg || value.keyVersion !== body.keyVersion || value.requestHash !== hex3(sha2566(new TextEncoder().encode(`${invocation.cid}${bodyHash}`))) || typeof value.wrappedKey !== "string" || typeof value.nodeSignature !== "string") throw new Error("v3 decrypt response binding is invalid");
       const unsigned = { ...value };
@@ -8228,11 +8427,11 @@ function createAddressedAuthorization(input) {
     },
     async verifyResult({ envelope, value, proof }) {
       try {
-        const wrapper = object2(proof, "share read proof");
-        const response = object2(wrapper.response, "share read response proof");
+        const wrapper = object3(proof, "share read proof");
+        const response = object3(wrapper.response, "share read response proof");
         const envelopeAction = nativeAction("read");
         if (response.type !== "TinyCloudShareInvokeResponse" || response.version !== 2 || response.action !== envelopeAction || response.resource !== envelope.resource.path || typeof response.bodyDigest !== "string" || response.bodyDigest !== value.bodyDigest || response.bodyDigest !== await digestBytes2(value.bytes)) return false;
-        const detached = object2(wrapper.detached, "share read detached proof");
+        const detached = object3(wrapper.detached, "share read detached proof");
         if (input.trustedNode === void 0 || detached.alg !== "EdDSA" || detached.kid !== input.trustedNode.invitationKid) return false;
         const unsigned = { ...response };
         delete unsigned.proof;
@@ -8300,6 +8499,7 @@ async function openNativeShare(sharing, link) {
   return sharing.receive(parseNativeShareUrl(link), { autoSubdelegate: false, useSessionKey: false });
 }
 export {
+  CredentialInvitationError,
   DEFAULT_MAX_CONTENT_BLOB_BYTES,
   DEFAULT_MAX_SEALED_BLOB_BYTES,
   DEFAULT_SHARE_LIFETIME_MS,
@@ -8332,6 +8532,7 @@ export {
   createNativeShare,
   createPolicyEnforcementDelegation,
   createShareV2HolderBindingArtifact,
+  deliverCredentialInvitation,
   fromBase64Url,
   historyRecordForPublishedShare,
   inspectShare,