@learncard/sss-key-manager 0.1.24 → 0.2.0

package/dist/sss-key-manager.esm.js

@@ -56,6 +56,8 @@ var require_types_cjs_development = __commonJS({
       AchievementSubjectValidator: /* @__PURE__ */ __name(() => AchievementSubjectValidator, "AchievementSubjectValidator"),
       AchievementTypeValidator: /* @__PURE__ */ __name(() => AchievementTypeValidator, "AchievementTypeValidator"),
       AchievementValidator: /* @__PURE__ */ __name(() => AchievementValidator, "AchievementValidator"),
+      AcknowledgeViewInputValidator: /* @__PURE__ */ __name(() => AcknowledgeViewInputValidator, "AcknowledgeViewInputValidator"),
+      AcknowledgeViewOutputValidator: /* @__PURE__ */ __name(() => AcknowledgeViewOutputValidator, "AcknowledgeViewOutputValidator"),
       AddTagInputValidator: /* @__PURE__ */ __name(() => AddTagInputValidator, "AddTagInputValidator"),
       AddressValidator: /* @__PURE__ */ __name(() => AddressValidator, "AddressValidator"),
       AgeRatingValidator: /* @__PURE__ */ __name(() => AgeRatingValidator, "AgeRatingValidator"),
@@ -133,6 +135,7 @@ var require_types_cjs_development = __commonJS({
       CreateContactMethodSessionValidator: /* @__PURE__ */ __name(() => CreateContactMethodSessionValidator, "CreateContactMethodSessionValidator"),
       CreateManagedFrameworkBatchInputValidator: /* @__PURE__ */ __name(() => CreateManagedFrameworkBatchInputValidator, "CreateManagedFrameworkBatchInputValidator"),
       CreateManagedFrameworkInputValidator: /* @__PURE__ */ __name(() => CreateManagedFrameworkInputValidator, "CreateManagedFrameworkInputValidator"),
+      CreateShareLinkInputValidator: /* @__PURE__ */ __name(() => CreateShareLinkInputValidator, "CreateShareLinkInputValidator"),
       CreateSkillInputValidator: /* @__PURE__ */ __name(() => CreateSkillInputValidator, "CreateSkillInputValidator"),
       CreateSkillsBatchInputValidator: /* @__PURE__ */ __name(() => CreateSkillsBatchInputValidator, "CreateSkillsBatchInputValidator"),
       CredentialActivityEventTypeValidator: /* @__PURE__ */ __name(() => CredentialActivityEventTypeValidator, "CredentialActivityEventTypeValidator"),
@@ -164,10 +167,14 @@ var require_types_cjs_development = __commonJS({
       DeleteSkillInputValidator: /* @__PURE__ */ __name(() => DeleteSkillInputValidator, "DeleteSkillInputValidator"),
       DidDocumentValidator: /* @__PURE__ */ __name(() => DidDocumentValidator, "DidDocumentValidator"),
       EMPTY_IN_APP_MESSAGES_FLAG: /* @__PURE__ */ __name(() => EMPTY_IN_APP_MESSAGES_FLAG, "EMPTY_IN_APP_MESSAGES_FLAG"),
+      ESCROW_PIN_LOCKED_MESSAGE: /* @__PURE__ */ __name(() => ESCROW_PIN_LOCKED_MESSAGE2, "ESCROW_PIN_LOCKED_MESSAGE"),
+      ESCROW_PIN_MISMATCH_PATTERN: /* @__PURE__ */ __name(() => ESCROW_PIN_MISMATCH_PATTERN2, "ESCROW_PIN_MISMATCH_PATTERN"),
+      ESCROW_PIN_UNAVAILABLE_MESSAGE: /* @__PURE__ */ __name(() => ESCROW_PIN_UNAVAILABLE_MESSAGE2, "ESCROW_PIN_UNAVAILABLE_MESSAGE"),
       EncryptedCredentialRecordValidator: /* @__PURE__ */ __name(() => EncryptedCredentialRecordValidator, "EncryptedCredentialRecordValidator"),
       EncryptedRecordValidator: /* @__PURE__ */ __name(() => EncryptedRecordValidator, "EncryptedRecordValidator"),
       EndorsementCredentialValidator: /* @__PURE__ */ __name(() => EndorsementCredentialValidator, "EndorsementCredentialValidator"),
       EndorsementSubjectValidator: /* @__PURE__ */ __name(() => EndorsementSubjectValidator, "EndorsementSubjectValidator"),
+      EscrowPinStatusValidator: /* @__PURE__ */ __name(() => EscrowPinStatusValidator, "EscrowPinStatusValidator"),
       EvidenceValidator: /* @__PURE__ */ __name(() => EvidenceValidator, "EvidenceValidator"),
       FlatAuthGrantValidator: /* @__PURE__ */ __name(() => FlatAuthGrantValidator, "FlatAuthGrantValidator"),
       FrameworkWithSkillsValidator: /* @__PURE__ */ __name(() => FrameworkWithSkillsValidator, "FrameworkWithSkillsValidator"),
@@ -249,6 +256,14 @@ var require_types_cjs_development = __commonJS({
       LaunchTypeValidator: /* @__PURE__ */ __name(() => LaunchTypeValidator, "LaunchTypeValidator"),
       LearnCardRefreshAuthorizationValidator: /* @__PURE__ */ __name(() => LearnCardRefreshAuthorizationValidator, "LearnCardRefreshAuthorizationValidator"),
       LinkProviderFrameworkInputValidator: /* @__PURE__ */ __name(() => LinkProviderFrameworkInputValidator, "LinkProviderFrameworkInputValidator"),
+      ListShareLinksInputValidator: /* @__PURE__ */ __name(() => ListShareLinksInputValidator, "ListShareLinksInputValidator"),
+      MAX_ENDORSEMENTS: /* @__PURE__ */ __name(() => MAX_ENDORSEMENTS, "MAX_ENDORSEMENTS"),
+      MAX_SELECTED_CREDENTIALS: /* @__PURE__ */ __name(() => MAX_SELECTED_CREDENTIALS, "MAX_SELECTED_CREDENTIALS"),
+      MAX_SHARE_CIPHERTEXT_BYTES: /* @__PURE__ */ __name(() => MAX_SHARE_CIPHERTEXT_BYTES, "MAX_SHARE_CIPHERTEXT_BYTES"),
+      MAX_SHARE_LINK_REQUEST_BYTES: /* @__PURE__ */ __name(() => MAX_SHARE_LINK_REQUEST_BYTES, "MAX_SHARE_LINK_REQUEST_BYTES"),
+      MAX_SHARE_RECOVERY_JWE_BYTES: /* @__PURE__ */ __name(() => MAX_SHARE_RECOVERY_JWE_BYTES, "MAX_SHARE_RECOVERY_JWE_BYTES"),
+      MAX_SHARE_SOURCE_URI_CHARS: /* @__PURE__ */ __name(() => MAX_SHARE_SOURCE_URI_CHARS, "MAX_SHARE_SOURCE_URI_CHARS"),
+      MAX_VP_MEMBERS: /* @__PURE__ */ __name(() => MAX_VP_MEMBERS, "MAX_VP_MEMBERS"),
       ManagedCredentialRefreshReceiptValidator: /* @__PURE__ */ __name(() => ManagedCredentialRefreshReceiptValidator, "ManagedCredentialRefreshReceiptValidator"),
       ManagedCredentialRefreshServiceValidator: /* @__PURE__ */ __name(() => ManagedCredentialRefreshServiceValidator, "ManagedCredentialRefreshServiceValidator"),
       PaginatedAppStoreListingsValidator: /* @__PURE__ */ __name(() => PaginatedAppStoreListingsValidator, "PaginatedAppStoreListingsValidator"),
@@ -271,6 +286,7 @@ var require_types_cjs_development = __commonJS({
       PaginatedLCNProfileManagersValidator: /* @__PURE__ */ __name(() => PaginatedLCNProfileManagersValidator, "PaginatedLCNProfileManagersValidator"),
       PaginatedLCNProfilesAndManagersValidator: /* @__PURE__ */ __name(() => PaginatedLCNProfilesAndManagersValidator, "PaginatedLCNProfilesAndManagersValidator"),
       PaginatedLCNProfilesValidator: /* @__PURE__ */ __name(() => PaginatedLCNProfilesValidator, "PaginatedLCNProfilesValidator"),
+      PaginatedShareLinksValidator: /* @__PURE__ */ __name(() => PaginatedShareLinksValidator, "PaginatedShareLinksValidator"),
       PaginatedSkillFrameworksValidator: /* @__PURE__ */ __name(() => PaginatedSkillFrameworksValidator, "PaginatedSkillFrameworksValidator"),
       PaginatedSkillTreeValidator: /* @__PURE__ */ __name(() => PaginatedSkillTreeValidator, "PaginatedSkillTreeValidator"),
       PaginatedVisibleLCNProfilesValidator: /* @__PURE__ */ __name(() => PaginatedVisibleLCNProfilesValidator, "PaginatedVisibleLCNProfilesValidator"),
@@ -295,11 +311,20 @@ var require_types_cjs_development = __commonJS({
       ReplaceSkillFrameworkSkillsInputValidator: /* @__PURE__ */ __name(() => ReplaceSkillFrameworkSkillsInputValidator, "ReplaceSkillFrameworkSkillsInputValidator"),
       ReplaceSkillFrameworkSkillsResultValidator: /* @__PURE__ */ __name(() => ReplaceSkillFrameworkSkillsResultValidator, "ReplaceSkillFrameworkSkillsResultValidator"),
       RequestLearnerContextEventValidator: /* @__PURE__ */ __name(() => RequestLearnerContextEventValidator, "RequestLearnerContextEventValidator"),
+      ResolveShareLinkInputValidator: /* @__PURE__ */ __name(() => ResolveShareLinkInputValidator, "ResolveShareLinkInputValidator"),
       ResultDescriptionValidator: /* @__PURE__ */ __name(() => ResultDescriptionValidator, "ResultDescriptionValidator"),
       ResultStatusTypeValidator: /* @__PURE__ */ __name(() => ResultStatusTypeValidator, "ResultStatusTypeValidator"),
       ResultTypeValidator: /* @__PURE__ */ __name(() => ResultTypeValidator, "ResultTypeValidator"),
       ResultValidator: /* @__PURE__ */ __name(() => ResultValidator, "ResultValidator"),
       RubricCriterionValidator: /* @__PURE__ */ __name(() => RubricCriterionValidator, "RubricCriterionValidator"),
+      SHARE_AAD_PREFIX: /* @__PURE__ */ __name(() => SHARE_AAD_PREFIX, "SHARE_AAD_PREFIX"),
+      SHARE_CONTENT_KEY_BYTES: /* @__PURE__ */ __name(() => SHARE_CONTENT_KEY_BYTES, "SHARE_CONTENT_KEY_BYTES"),
+      SHARE_IV_BYTES: /* @__PURE__ */ __name(() => SHARE_IV_BYTES, "SHARE_IV_BYTES"),
+      SHARE_LINK_ID_BYTES: /* @__PURE__ */ __name(() => SHARE_LINK_ID_BYTES, "SHARE_LINK_ID_BYTES"),
+      SHARE_LINK_PROTOCOL: /* @__PURE__ */ __name(() => SHARE_LINK_PROTOCOL, "SHARE_LINK_PROTOCOL"),
+      SHARE_RECOVERY_PROTOCOL: /* @__PURE__ */ __name(() => SHARE_RECOVERY_PROTOCOL, "SHARE_RECOVERY_PROTOCOL"),
+      SHARE_TAG_BYTES: /* @__PURE__ */ __name(() => SHARE_TAG_BYTES, "SHARE_TAG_BYTES"),
+      SHARE_VIEW_RECEIPT_TTL_SECONDS: /* @__PURE__ */ __name(() => SHARE_VIEW_RECEIPT_TTL_SECONDS, "SHARE_VIEW_RECEIPT_TTL_SECONDS"),
       SendAiSessionCredentialEventValidator: /* @__PURE__ */ __name(() => SendAiSessionCredentialEventValidator, "SendAiSessionCredentialEventValidator"),
       SendBoostInputValidator: /* @__PURE__ */ __name(() => SendBoostInputValidator, "SendBoostInputValidator"),
       SendBoostResponseValidator: /* @__PURE__ */ __name(() => SendBoostResponseValidator, "SendBoostResponseValidator"),
@@ -314,6 +339,32 @@ var require_types_cjs_development = __commonJS({
       SentCredentialInfoValidator: /* @__PURE__ */ __name(() => SentCredentialInfoValidator, "SentCredentialInfoValidator"),
       ServiceValidator: /* @__PURE__ */ __name(() => ServiceValidator, "ServiceValidator"),
       SetPrimaryContactMethodValidator: /* @__PURE__ */ __name(() => SetPrimaryContactMethodValidator, "SetPrimaryContactMethodValidator"),
+      ShareCiphertextValidator: /* @__PURE__ */ __name(() => ShareCiphertextValidator, "ShareCiphertextValidator"),
+      ShareContentKeyValidator: /* @__PURE__ */ __name(() => ShareContentKeyValidator, "ShareContentKeyValidator"),
+      ShareContentStateValidator: /* @__PURE__ */ __name(() => ShareContentStateValidator, "ShareContentStateValidator"),
+      ShareEndorsementEntryValidator: /* @__PURE__ */ __name(() => ShareEndorsementEntryValidator, "ShareEndorsementEntryValidator"),
+      ShareEnvelopeValidator: /* @__PURE__ */ __name(() => ShareEnvelopeValidator, "ShareEnvelopeValidator"),
+      ShareIvValidator: /* @__PURE__ */ __name(() => ShareIvValidator, "ShareIvValidator"),
+      ShareLinkIdInputValidator: /* @__PURE__ */ __name(() => ShareLinkIdInputValidator, "ShareLinkIdInputValidator"),
+      ShareLinkIdValidator: /* @__PURE__ */ __name(() => ShareLinkIdValidator, "ShareLinkIdValidator"),
+      ShareLinkOperationKeyInputValidator: /* @__PURE__ */ __name(() => ShareLinkOperationKeyInputValidator, "ShareLinkOperationKeyInputValidator"),
+      ShareLinkOwnerCommitOutputValidator: /* @__PURE__ */ __name(() => ShareLinkOwnerCommitOutputValidator, "ShareLinkOwnerCommitOutputValidator"),
+      ShareLinkOwnerContentOutputValidator: /* @__PURE__ */ __name(() => ShareLinkOwnerContentOutputValidator, "ShareLinkOwnerContentOutputValidator"),
+      ShareLinkOwnerRecoveryOutputValidator: /* @__PURE__ */ __name(() => ShareLinkOwnerRecoveryOutputValidator, "ShareLinkOwnerRecoveryOutputValidator"),
+      ShareLinkOwnerStatusOutputValidator: /* @__PURE__ */ __name(() => ShareLinkOwnerStatusOutputValidator, "ShareLinkOwnerStatusOutputValidator"),
+      ShareLinkPublicContentViewValidator: /* @__PURE__ */ __name(() => ShareLinkPublicContentViewValidator, "ShareLinkPublicContentViewValidator"),
+      ShareLinkPublicStateValidator: /* @__PURE__ */ __name(() => ShareLinkPublicStateValidator, "ShareLinkPublicStateValidator"),
+      ShareLinkStatusValidator: /* @__PURE__ */ __name(() => ShareLinkStatusValidator, "ShareLinkStatusValidator"),
+      ShareLinkValidator: /* @__PURE__ */ __name(() => ShareLinkValidator, "ShareLinkValidator"),
+      ShareManifestPresentationValidator: /* @__PURE__ */ __name(() => ShareManifestPresentationValidator, "ShareManifestPresentationValidator"),
+      ShareOwnerRecoveryValidator: /* @__PURE__ */ __name(() => ShareOwnerRecoveryValidator, "ShareOwnerRecoveryValidator"),
+      SharePayloadValidator: /* @__PURE__ */ __name(() => SharePayloadValidator, "SharePayloadValidator"),
+      SharePayloadValidatorShape: /* @__PURE__ */ __name(() => SharePayloadValidatorShape, "SharePayloadValidatorShape"),
+      ShareRecoveryEndorsementValidator: /* @__PURE__ */ __name(() => ShareRecoveryEndorsementValidator, "ShareRecoveryEndorsementValidator"),
+      ShareRecoveryPlaintextValidator: /* @__PURE__ */ __name(() => ShareRecoveryPlaintextValidator, "ShareRecoveryPlaintextValidator"),
+      ShareRecoverySelectionValidator: /* @__PURE__ */ __name(() => ShareRecoverySelectionValidator, "ShareRecoverySelectionValidator"),
+      ShareSelectionEntryValidator: /* @__PURE__ */ __name(() => ShareSelectionEntryValidator, "ShareSelectionEntryValidator"),
+      ShareSharerValidator: /* @__PURE__ */ __name(() => ShareSharerValidator, "ShareSharerValidator"),
       SkillDeletionStrategyValidator: /* @__PURE__ */ __name(() => SkillDeletionStrategyValidator, "SkillDeletionStrategyValidator"),
       SkillFrameworkAdminInputValidator: /* @__PURE__ */ __name(() => SkillFrameworkAdminInputValidator, "SkillFrameworkAdminInputValidator"),
       SkillFrameworkAdminsValidator: /* @__PURE__ */ __name(() => SkillFrameworkAdminsValidator, "SkillFrameworkAdminsValidator"),
@@ -345,6 +396,7 @@ var require_types_cjs_development = __commonJS({
       UnsignedVCValidator: /* @__PURE__ */ __name(() => UnsignedVCValidator, "UnsignedVCValidator"),
       UnsignedVPValidator: /* @__PURE__ */ __name(() => UnsignedVPValidator, "UnsignedVPValidator"),
       UpdateFrameworkInputValidator: /* @__PURE__ */ __name(() => UpdateFrameworkInputValidator, "UpdateFrameworkInputValidator"),
+      UpdateShareLinkInputValidator: /* @__PURE__ */ __name(() => UpdateShareLinkInputValidator, "UpdateShareLinkInputValidator"),
       UpdateSkillInputValidator: /* @__PURE__ */ __name(() => UpdateSkillInputValidator, "UpdateSkillInputValidator"),
       VC2EvidenceValidator: /* @__PURE__ */ __name(() => VC2EvidenceValidator, "VC2EvidenceValidator"),
       VCValidator: /* @__PURE__ */ __name(() => VCValidator, "VCValidator"),
@@ -356,7 +408,12 @@ var require_types_cjs_development = __commonJS({
       VerificationStatusValidator: /* @__PURE__ */ __name(() => VerificationStatusValidator, "VerificationStatusValidator"),
       appStoreActionValidator: /* @__PURE__ */ __name(() => appStoreActionValidator, "appStoreActionValidator"),
       capgoUpdateActionValidator: /* @__PURE__ */ __name(() => capgoUpdateActionValidator, "capgoUpdateActionValidator"),
+      classifyShareManifest: /* @__PURE__ */ __name(() => classifyShareManifest, "classifyShareManifest"),
+      decodeBase64Url: /* @__PURE__ */ __name(() => decodeBase64Url, "decodeBase64Url"),
+      decodedBase64UrlByteLength: /* @__PURE__ */ __name(() => decodedBase64UrlByteLength, "decodedBase64UrlByteLength"),
       dismissActionValidator: /* @__PURE__ */ __name(() => dismissActionValidator, "dismissActionValidator"),
+      encodeBase64Url: /* @__PURE__ */ __name(() => encodeBase64Url, "encodeBase64Url"),
+      escrowPinMismatchMessage: /* @__PURE__ */ __name(() => escrowPinMismatchMessage, "escrowPinMismatchMessage"),
       externalLinkActionValidator: /* @__PURE__ */ __name(() => externalLinkActionValidator, "externalLinkActionValidator"),
       inAppMessageActionStyleValidator: /* @__PURE__ */ __name(() => inAppMessageActionStyleValidator, "inAppMessageActionStyleValidator"),
       inAppMessageActionTargetValidator: /* @__PURE__ */ __name(() => inAppMessageActionTargetValidator, "inAppMessageActionTargetValidator"),
@@ -371,10 +428,12 @@ var require_types_cjs_development = __commonJS({
       inAppMessageVersionSourceValidator: /* @__PURE__ */ __name(() => inAppMessageVersionSourceValidator, "inAppMessageVersionSourceValidator"),
       inAppMessagesFlagValidator: /* @__PURE__ */ __name(() => inAppMessagesFlagValidator, "inAppMessagesFlagValidator"),
       internalLinkActionValidator: /* @__PURE__ */ __name(() => internalLinkActionValidator, "internalLinkActionValidator"),
+      isCanonicalBase64Url: /* @__PURE__ */ __name(() => isCanonicalBase64Url, "isCanonicalBase64Url"),
       isStoredCredentialEnvelope: /* @__PURE__ */ __name(() => isStoredCredentialEnvelope, "isStoredCredentialEnvelope"),
       parseInAppMessagesFlag: /* @__PURE__ */ __name(() => parseInAppMessagesFlag, "parseInAppMessagesFlag"),
       platformPredicateValidator: /* @__PURE__ */ __name(() => platformPredicateValidator, "platformPredicateValidator"),
       rolePredicateValidator: /* @__PURE__ */ __name(() => rolePredicateValidator, "rolePredicateValidator"),
+      utf8ByteLength: /* @__PURE__ */ __name(() => utf8ByteLength, "utf8ByteLength"),
       versionPredicateValidator: /* @__PURE__ */ __name(() => versionPredicateValidator, "versionPredicateValidator")
     });
     module.exports = __toCommonJS(index_exports);
@@ -18011,6 +18070,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         __name2(this, "AuthSessionError");
       }
     };
+    var ESCROW_PIN_LOCKED_MESSAGE2 = "Too many incorrect PIN attempts. You can still recover by waiting.";
+    var ESCROW_PIN_UNAVAILABLE_MESSAGE2 = "PIN recovery is not available for this account.";
+    var ESCROW_PIN_MISMATCH_PATTERN2 = /^Incorrect PIN\. (\d+) attempts left\.$/;
+    var escrowPinMismatchMessage = /* @__PURE__ */ __name2((attemptsRemaining) => `Incorrect PIN. ${attemptsRemaining} attempts left.`, "escrowPinMismatchMessage");
+    var EscrowPinStatusValidator = external_exports.object({
+      state: external_exports.enum(["none", "enabled", "locked", "stale"]),
+      enabled: external_exports.boolean(),
+      attemptsRemaining: external_exports.number().int().nonnegative(),
+      salt: external_exports.string().optional()
+    });
     var BITSTRING_STATUS_PURPOSES = ["revocation", "suspension"];
     var DEFAULT_BITSTRING_STATUS_LIST_SIZE = 131072;
     var BitstringStatusPurposeValidator = external_exports.enum(BITSTRING_STATUS_PURPOSES);
@@ -18125,6 +18194,458 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const result = inAppMessagesFlagValidator.safeParse(raw);
       return result.success ? result.data : EMPTY_IN_APP_MESSAGES_FLAG;
     }, "parseInAppMessagesFlag");
+    var SHARE_LINK_ID_BYTES = 16;
+    var SHARE_CONTENT_KEY_BYTES = 32;
+    var SHARE_IV_BYTES = 12;
+    var SHARE_TAG_BYTES = 16;
+    var MAX_SHARE_CIPHERTEXT_BYTES = 512 * 1024;
+    var MAX_SHARE_RECOVERY_JWE_BYTES = 64 * 1024;
+    var MAX_SELECTED_CREDENTIALS = 50;
+    var MAX_ENDORSEMENTS = 200;
+    var MAX_VP_MEMBERS = MAX_SELECTED_CREDENTIALS + MAX_ENDORSEMENTS;
+    var MAX_SHARE_SOURCE_URI_CHARS = 2048;
+    var MAX_SHARE_LINK_REQUEST_BYTES = 1024 * 1024;
+    var SHARE_LINK_PROTOCOL = "lc-share/v1";
+    var SHARE_RECOVERY_PROTOCOL = "lc-share-recovery/v1";
+    var SHARE_AAD_PREFIX = "lc-share:v1";
+    var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    var BASE64URL_LOOKUP = (() => {
+      const table = new Int16Array(128).fill(-1);
+      for (let index = 0; index < BASE64URL_ALPHABET.length; index += 1) {
+        table[BASE64URL_ALPHABET.charCodeAt(index)] = index;
+      }
+      return table;
+    })();
+    var encodeBase64Url = /* @__PURE__ */ __name2((bytes) => {
+      let output = "";
+      for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index];
+        const second = bytes[index + 1];
+        const third = bytes[index + 2];
+        output += BASE64URL_ALPHABET[first >> 2];
+        output += BASE64URL_ALPHABET[(first & 3) << 4 | (second ?? 0) >> 4];
+        if (second === void 0) break;
+        output += BASE64URL_ALPHABET[(second & 15) << 2 | (third ?? 0) >> 6];
+        if (third === void 0) break;
+        output += BASE64URL_ALPHABET[third & 63];
+      }
+      return output;
+    }, "encodeBase64Url");
+    var decodeBase64Url = /* @__PURE__ */ __name2((value) => {
+      if (typeof value !== "string") return null;
+      const output = new Uint8Array(Math.floor(value.length * 6 / 8));
+      let bits = 0;
+      let bitCount = 0;
+      let outputIndex = 0;
+      for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        const digit = code < 128 ? BASE64URL_LOOKUP[code] : -1;
+        if (digit < 0) return null;
+        bits = bits << 6 | digit;
+        bitCount += 6;
+        if (bitCount >= 8) {
+          bitCount -= 8;
+          output[outputIndex] = bits >> bitCount & 255;
+          outputIndex += 1;
+        }
+      }
+      return output;
+    }, "decodeBase64Url");
+    var isCanonicalBase64Url = /* @__PURE__ */ __name2((value, expectedBytes) => {
+      if (typeof value !== "string") return false;
+      if (expectedBytes !== void 0 && value.length !== Math.ceil(expectedBytes * 4 / 3))
+        return false;
+      const decoded = decodeBase64Url(value);
+      if (decoded === null) return false;
+      if (expectedBytes !== void 0 && decoded.length !== expectedBytes) return false;
+      return encodeBase64Url(decoded) === value;
+    }, "isCanonicalBase64Url");
+    var decodedBase64UrlByteLength = /* @__PURE__ */ __name2((value) => decodeBase64Url(value)?.length ?? null, "decodedBase64UrlByteLength");
+    var utf8ByteLength = /* @__PURE__ */ __name2((value) => new TextEncoder().encode(value).length, "utf8ByteLength");
+    var canonicalBase64Url = /* @__PURE__ */ __name2((bytes) => external_exports.string().refine((value) => isCanonicalBase64Url(value, bytes), {
+      message: `must be canonical base64url for exactly ${bytes} bytes`
+    }), "canonicalBase64Url");
+    var ShareLinkIdValidator = canonicalBase64Url(SHARE_LINK_ID_BYTES);
+    var ShareContentKeyValidator = canonicalBase64Url(SHARE_CONTENT_KEY_BYTES);
+    var ShareIvValidator = canonicalBase64Url(SHARE_IV_BYTES);
+    var ShareCiphertextValidator = external_exports.string().refine(
+      (value) => {
+        if (value.length > Math.ceil(MAX_SHARE_CIPHERTEXT_BYTES * 4 / 3)) return false;
+        const decoded = decodeBase64Url(value);
+        if (decoded === null) return false;
+        if (encodeBase64Url(decoded) !== value) return false;
+        return decoded.length >= SHARE_TAG_BYTES && decoded.length <= MAX_SHARE_CIPHERTEXT_BYTES;
+      },
+      {
+        message: `must be canonical base64url decoding to ${SHARE_TAG_BYTES}..${MAX_SHARE_CIPHERTEXT_BYTES} bytes`
+      }
+    );
+    var ShareEnvelopeValidator = external_exports.object({
+      v: external_exports.literal(1),
+      alg: external_exports.literal("A256GCM"),
+      iv: ShareIvValidator,
+      ct: ShareCiphertextValidator
+    }).strict();
+    var safeVersion = external_exports.number().int().min(1).max(2 ** 31 - 1);
+    var safeCredentialIndex = external_exports.number().int().min(0).max(MAX_VP_MEMBERS - 1);
+    var ShareSelectionEntryValidator = external_exports.object({ credentialIndex: safeCredentialIndex }).strict();
+    var ShareEndorsementEntryValidator = external_exports.object({ credentialIndex: safeCredentialIndex, targetCredentialIndex: safeCredentialIndex }).strict();
+    var ShareSharerValidator = external_exports.object({
+      profileId: external_exports.string().min(1).max(128),
+      displayName: external_exports.string().min(1).max(120),
+      avatar: external_exports.string().max(2048).optional()
+    }).strict();
+    var presentationShape = VPValidator.extend({
+      verifiableCredential: VCValidator.array().min(1).max(MAX_VP_MEMBERS)
+    });
+    var hasBoundedPresentation = /* @__PURE__ */ __name2((value) => {
+      let credentialCount = 0;
+      const ancestors = /* @__PURE__ */ new Set();
+      const visit = /* @__PURE__ */ __name2((node, depth) => {
+        if (node === null || typeof node !== "object") return true;
+        if (depth > 32 || ancestors.has(node)) return false;
+        ancestors.add(node);
+        try {
+          for (const [key, child] of Object.entries(node)) {
+            if (key === "verifiableCredential") {
+              credentialCount += Array.isArray(child) ? child.length : 1;
+              if (credentialCount > MAX_VP_MEMBERS) return false;
+            }
+            if (!visit(child, depth + 1)) return false;
+          }
+          return true;
+        } finally {
+          ancestors.delete(node);
+        }
+      }, "visit");
+      return visit(value, 0);
+    }, "hasBoundedPresentation");
+    var ShareManifestPresentationValidator = external_exports.custom(
+      (value) => hasBoundedPresentation(value) && presentationShape.safeParse(value).success,
+      { message: "invalid share presentation" }
+    );
+    var SharePayloadValidatorShape = external_exports.object({
+      protocol: external_exports.literal(SHARE_LINK_PROTOCOL),
+      shareId: ShareLinkIdValidator,
+      contentVersion: safeVersion,
+      createdAt: external_exports.iso.datetime(),
+      sharer: ShareSharerValidator,
+      presentation: ShareManifestPresentationValidator,
+      selection: ShareSelectionEntryValidator.array().min(1).max(MAX_SELECTED_CREDENTIALS),
+      endorsements: ShareEndorsementEntryValidator.array().max(MAX_ENDORSEMENTS).default([])
+    }).strict();
+    var classificationFailure = /* @__PURE__ */ __name2((code, message, path = []) => ({ ok: false, code, message, path }), "classificationFailure");
+    var readSignedClaimId = /* @__PURE__ */ __name2((member) => {
+      if (member === null || typeof member !== "object") return void 0;
+      const record2 = member;
+      const claim = record2.credentialSubject ?? record2.endorsement;
+      if (claim === null || typeof claim !== "object") return void 0;
+      const claimRecord = claim;
+      const nested = claimRecord.endorsement;
+      const nestedId = nested !== null && typeof nested === "object" ? nested.id : void 0;
+      return claimRecord.id ?? nestedId;
+    }, "readSignedClaimId");
+    var classifyShareManifest = /* @__PURE__ */ __name2((payload) => {
+      const members = payload.presentation?.verifiableCredential;
+      if (!Array.isArray(members) || members.length === 0) {
+        return classificationFailure("NO_PRESENTATION_MEMBERS", "presentation has no credentials");
+      }
+      if (members.length > MAX_VP_MEMBERS) {
+        return classificationFailure(
+          "TOO_MANY_VP_MEMBERS",
+          `presentation has ${members.length} members, over the ${MAX_VP_MEMBERS} bound`
+        );
+      }
+      const selection = payload.selection;
+      const endorsements = payload.endorsements ?? [];
+      if (!Array.isArray(selection) || selection.length < 1 || selection.length > MAX_SELECTED_CREDENTIALS) {
+        return classificationFailure("BAD_SELECTION", "selection must contain 1..50 entries");
+      }
+      if (!Array.isArray(endorsements) || endorsements.length > MAX_ENDORSEMENTS) {
+        return classificationFailure(
+          "BAD_ENDORSEMENTS",
+          "endorsements must contain at most 200 entries"
+        );
+      }
+      const selectedIndices = [];
+      const selected = /* @__PURE__ */ new Set();
+      for (let index = 0; index < selection.length; index += 1) {
+        const entry = selection[index];
+        const credentialIndex = entry?.credentialIndex;
+        if (!Number.isSafeInteger(credentialIndex) || credentialIndex < 0 || credentialIndex >= members.length) {
+          return classificationFailure(
+            "SELECTION_INDEX_OUT_OF_BOUNDS",
+            `selection[${index}].credentialIndex is out of bounds`,
+            ["selection", index, "credentialIndex"]
+          );
+        }
+        if (selected.has(credentialIndex)) {
+          return classificationFailure(
+            "SELECTION_INDEX_DUPLICATE",
+            `selection[${index}].credentialIndex is duplicated`,
+            ["selection", index, "credentialIndex"]
+          );
+        }
+        selected.add(credentialIndex);
+        selectedIndices.push(credentialIndex);
+      }
+      const classified = new Set(selected);
+      const endorsementIndices = [];
+      for (let index = 0; index < endorsements.length; index += 1) {
+        const entry = endorsements[index];
+        const credentialIndex = entry?.credentialIndex;
+        const targetIndex = entry?.targetCredentialIndex;
+        if (!Number.isSafeInteger(credentialIndex) || credentialIndex < 0 || credentialIndex >= members.length) {
+          return classificationFailure(
+            "ENDORSEMENT_INDEX_OUT_OF_BOUNDS",
+            `endorsements[${index}].credentialIndex is out of bounds`,
+            ["endorsements", index, "credentialIndex"]
+          );
+        }
+        if (classified.has(credentialIndex)) {
+          return classificationFailure(
+            "VP_MEMBER_CLASSIFIED_TWICE",
+            `endorsements[${index}].credentialIndex was already classified`,
+            ["endorsements", index, "credentialIndex"]
+          );
+        }
+        if (!selected.has(targetIndex)) {
+          return classificationFailure(
+            "ENDORSEMENT_TARGET_NOT_SELECTED",
+            `endorsements[${index}].targetCredentialIndex must reference a selected credential`,
+            ["endorsements", index, "targetCredentialIndex"]
+          );
+        }
+        const referenced = readSignedClaimId(members[credentialIndex]);
+        const target = members[targetIndex];
+        const targetId = target !== null && typeof target === "object" ? target.id : void 0;
+        if (typeof referenced !== "string" || typeof targetId !== "string" || referenced !== targetId) {
+          return classificationFailure(
+            "ENDORSEMENT_TARGET_UNBOUND",
+            `endorsements[${index}] claim does not reference the target credential id`,
+            ["endorsements", index]
+          );
+        }
+        classified.add(credentialIndex);
+        endorsementIndices.push(credentialIndex);
+      }
+      if (classified.size !== members.length) {
+        return classificationFailure(
+          "UNCLASSIFIED_VP_MEMBER",
+          "every presentation member must be classified exactly once",
+          ["presentation", "verifiableCredential"]
+        );
+      }
+      return {
+        ok: true,
+        classification: { selectedIndices, endorsementIndices, memberCount: members.length }
+      };
+    }, "classifyShareManifest");
+    var SharePayloadValidator = SharePayloadValidatorShape.superRefine((payload, ctx) => {
+      const result = classifyShareManifest(payload);
+      if (!result.ok) {
+        ctx.addIssue({
+          code: "custom",
+          message: result.message,
+          path: result.path,
+          params: { shareLinkCode: result.code }
+        });
+      }
+    });
+    var ShareRecoverySelectionValidator = external_exports.object({
+      ref: external_exports.string().min(1).max(MAX_SHARE_SOURCE_URI_CHARS),
+      order: external_exports.number().int().min(0).max(MAX_SELECTED_CREDENTIALS - 1)
+    }).strict();
+    var ShareRecoveryEndorsementValidator = external_exports.object({ targetRef: external_exports.string().min(1).max(MAX_SHARE_SOURCE_URI_CHARS) }).strict();
+    var ShareRecoveryPlaintextValidator = external_exports.object({
+      protocol: external_exports.literal(SHARE_RECOVERY_PROTOCOL),
+      shareId: ShareLinkIdValidator,
+      ownerProfileId: external_exports.string().min(1).max(128),
+      createdAt: external_exports.iso.datetime(),
+      latest: external_exports.object({ contentVersion: safeVersion, key: ShareContentKeyValidator }).strict(),
+      selection: ShareRecoverySelectionValidator.array().min(1).max(MAX_SELECTED_CREDENTIALS),
+      endorsements: ShareRecoveryEndorsementValidator.array().max(MAX_ENDORSEMENTS).default([])
+    }).strict().superRefine((recovery, ctx) => {
+      const orders = /* @__PURE__ */ new Set();
+      recovery.selection.forEach((entry, index) => {
+        if (entry.order >= recovery.selection.length) {
+          ctx.addIssue({
+            code: "custom",
+            message: "order must be within the selection bounds",
+            path: ["selection", index, "order"]
+          });
+        }
+        if (orders.has(entry.order)) {
+          ctx.addIssue({
+            code: "custom",
+            message: "order must be unique within the selection",
+            path: ["selection", index, "order"]
+          });
+        }
+        orders.add(entry.order);
+      });
+    });
+    var ShareOwnerRecoveryValidator = JWEValidator.refine(
+      (value) => utf8ByteLength(JSON.stringify(value)) <= MAX_SHARE_RECOVERY_JWE_BYTES,
+      { message: `serialized recovery JWE must be at most ${MAX_SHARE_RECOVERY_JWE_BYTES} bytes` }
+    );
+    var ShareLinkStatusValidator = external_exports.enum(["pending", "active", "stopped"]);
+    var ShareContentStateValidator = external_exports.enum(["staging", "finalized", "content_missing"]);
+    var ShareLinkValidator = external_exports.object({
+      id: ShareLinkIdValidator,
+      title: external_exports.string().min(1).max(120),
+      note: external_exports.string().max(500).optional(),
+      selectedCount: external_exports.number().int().min(1).max(MAX_SELECTED_CREDENTIALS),
+      version: safeVersion,
+      contentVersion: safeVersion,
+      status: ShareLinkStatusValidator,
+      contentState: ShareContentStateValidator,
+      createdAt: external_exports.iso.datetime(),
+      updatedAt: external_exports.iso.datetime(),
+      expiresAt: external_exports.iso.datetime().nullable(),
+      stoppedAt: external_exports.iso.datetime().nullable(),
+      lastViewedAt: external_exports.iso.datetime().nullable(),
+      viewCount: external_exports.number().int().min(0).optional(),
+      passcodeProtected: external_exports.boolean(),
+      notifyOnView: external_exports.boolean(),
+      minorPolicy: external_exports.object({
+        isMinor: external_exports.boolean().nullable(),
+        policyResolved: external_exports.boolean(),
+        defaultExpiryDays: external_exports.union([external_exports.literal(30), external_exports.literal(365)]),
+        viewCountingEnabled: external_exports.boolean()
+      }),
+      /**
+       * Guarded application/API URL for the content. Optional because owner APIs in
+       * D1 have no public resolve/content endpoint yet; it must never be a
+       * LearnCloud object URL or carry a fabricated decryption key.
+       */
+      contentUrl: external_exports.string().optional()
+    });
+    var clientRequestId = external_exports.string().uuid();
+    var CreateShareLinkInputValidator = external_exports.object({
+      id: ShareLinkIdValidator,
+      clientRequestId,
+      title: external_exports.string().min(1).max(120),
+      note: external_exports.string().max(500).optional(),
+      expiresAt: external_exports.iso.datetime().nullable().optional(),
+      passcode: external_exports.string().min(8).max(64).optional(),
+      notifyOnView: external_exports.boolean().default(false),
+      selectedCount: external_exports.number().int().min(1).max(MAX_SELECTED_CREDENTIALS),
+      contentVersion: external_exports.literal(1),
+      envelope: ShareEnvelopeValidator,
+      ownerEncryptedRecovery: ShareOwnerRecoveryValidator
+    }).strict();
+    var UpdateShareLinkInputValidator = external_exports.object({
+      id: ShareLinkIdValidator,
+      expectedVersion: safeVersion,
+      clientRequestId,
+      title: external_exports.string().min(1).max(120).optional(),
+      note: external_exports.string().max(500).nullable().optional(),
+      expiresAt: external_exports.iso.datetime().nullable().optional(),
+      /** Omitted preserves the current passcode, null removes it, and a string replaces it. */
+      passcode: external_exports.string().min(8).max(64).nullable().optional(),
+      notifyOnView: external_exports.boolean().optional(),
+      contentVersion: safeVersion.optional(),
+      selectedCount: external_exports.number().int().min(1).max(MAX_SELECTED_CREDENTIALS).optional(),
+      envelope: ShareEnvelopeValidator.optional(),
+      ownerEncryptedRecovery: ShareOwnerRecoveryValidator.optional()
+    }).strict().superRefine((value, ctx) => {
+      const provided = [
+        value.contentVersion,
+        value.selectedCount,
+        value.envelope,
+        value.ownerEncryptedRecovery
+      ].filter((field) => field !== void 0).length;
+      if (provided !== 0 && provided !== 4) {
+        ctx.addIssue({
+          code: "custom",
+          message: "content replacement requires contentVersion, selectedCount, envelope and ownerEncryptedRecovery together"
+        });
+      }
+    });
+    var ShareLinkIdInputValidator = external_exports.object({ id: ShareLinkIdValidator }).strict();
+    var ShareLinkOperationKeyInputValidator = external_exports.object({ id: ShareLinkIdValidator, operationId: external_exports.string().uuid() }).strict();
+    var ShareLinkOwnerCommitOutputValidator = external_exports.discriminatedUnion("status", [
+      external_exports.object({ status: external_exports.literal("completed"), share: ShareLinkValidator }).strict(),
+      external_exports.object({
+        status: external_exports.literal("pending"),
+        id: ShareLinkIdValidator,
+        operationId: external_exports.string().uuid()
+      }).strict()
+    ]);
+    var ShareLinkOwnerStatusOutputValidator = external_exports.discriminatedUnion("status", [
+      external_exports.object({ status: external_exports.literal("found"), share: ShareLinkValidator }).strict(),
+      external_exports.object({
+        status: external_exports.literal("pending"),
+        id: ShareLinkIdValidator,
+        operationId: external_exports.string().uuid()
+      }).strict(),
+      external_exports.object({ status: external_exports.literal("not_found"), id: ShareLinkIdValidator }).strict()
+    ]);
+    var ShareLinkOwnerRecoveryOutputValidator = external_exports.object({ recovery: ShareOwnerRecoveryValidator }).strict();
+    var ShareLinkOwnerContentOutputValidator = external_exports.object({
+      id: ShareLinkIdValidator,
+      contentVersion: safeVersion,
+      envelope: ShareEnvelopeValidator
+    }).strict();
+    var ResolveShareLinkInputValidator = external_exports.object({
+      id: ShareLinkIdValidator,
+      /** Sent only in a POST body; it must never be placed in a share URL. */
+      passcode: external_exports.string().min(4).max(64).optional()
+    }).strict();
+    var ShareLinkPublicStateValidator = external_exports.discriminatedUnion("state", [
+      external_exports.object({
+        state: external_exports.literal("passcode_required"),
+        id: ShareLinkIdValidator
+      }).strict(),
+      external_exports.object({ state: external_exports.literal("try_later"), id: ShareLinkIdValidator }).strict(),
+      external_exports.object({
+        state: external_exports.literal("active"),
+        id: ShareLinkIdValidator,
+        title: external_exports.string().max(120),
+        note: external_exports.string().max(500).optional(),
+        selectedCount: external_exports.number().int().min(1).max(MAX_SELECTED_CREDENTIALS),
+        contentVersion: safeVersion,
+        contentUrl: external_exports.string(),
+        sharer: external_exports.object({
+          displayName: external_exports.string().max(120),
+          avatar: external_exports.string().max(2048).optional()
+        }),
+        createdAt: external_exports.iso.datetime(),
+        updatedAt: external_exports.iso.datetime(),
+        expiresAt: external_exports.iso.datetime().nullable()
+      }).strict(),
+      external_exports.object({
+        state: external_exports.literal("expired"),
+        id: ShareLinkIdValidator,
+        expiresAt: external_exports.iso.datetime()
+      }).strict(),
+      external_exports.object({
+        state: external_exports.literal("stopped"),
+        id: ShareLinkIdValidator,
+        stoppedAt: external_exports.iso.datetime()
+      }).strict(),
+      external_exports.object({ state: external_exports.literal("not_found"), id: ShareLinkIdValidator }).strict()
+    ]);
+    var ListShareLinksInputValidator = external_exports.object({
+      limit: external_exports.number().int().min(1).max(50).default(25),
+      cursor: external_exports.string().max(512).optional()
+    }).strict();
+    var PaginatedShareLinksValidator = PaginationResponseValidator.extend({
+      records: ShareLinkValidator.array()
+    });
+    var AcknowledgeViewInputValidator = external_exports.object({
+      receipt: external_exports.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/)
+    }).strict();
+    var AcknowledgeViewOutputValidator = external_exports.object({ ok: external_exports.literal(true) }).strict();
+    var SHARE_VIEW_RECEIPT_TTL_SECONDS = 10 * 60;
+    var ShareLinkPublicContentViewValidator = external_exports.object({
+      id: ShareLinkIdValidator,
+      contentVersion: safeVersion,
+      envelope: ShareEnvelopeValidator,
+      contentUrl: external_exports.string(),
+      receipt: external_exports.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/)
+    }).strict();
   }
 });
 
@@ -18141,6 +18662,10 @@ var require_dist = __commonJS({
 });
 
 // src/api-client.ts
+var DID_CHALLENGE_REQUIRED_ERROR = "This operation requires the DID-challenge flow; use createSSSStrategy";
+var throwDidChallengeRequired = /* @__PURE__ */ __name(() => {
+  throw new Error(DID_CHALLENGE_REQUIRED_ERROR);
+}, "throwDidChallengeRequired");
 var SSSApiClient = class {
   static {
     __name(this, "SSSApiClient");
@@ -18153,20 +18678,9 @@ var SSSApiClient = class {
     const token = await this.authProvider.getIdToken();
     return {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
+      "X-Auth-Token": token
     };
   }
-  async getContactMethodFromUser() {
-    const user = await this.authProvider.getCurrentUser();
-    if (!user) return null;
-    if (user.email) {
-      return { type: "email", value: user.email.toLowerCase() };
-    }
-    if (user.phone) {
-      return { type: "phone", value: user.phone };
-    }
-    return null;
-  }
   async getAuthShare() {
     const headers = await this.getAuthHeaders();
     const providerType = this.authProvider.getProviderType();
@@ -18183,52 +18697,24 @@ var SSSApiClient = class {
     }
     return response.json();
   }
-  async storeAuthShare(input) {
-    const headers = await this.getAuthHeaders();
-    const providerType = this.authProvider.getProviderType();
-    const response = await fetch(`${this.serverUrl}/keys/auth-share`, {
-      method: "PUT",
-      headers,
-      body: JSON.stringify({
-        ...input,
-        providerType
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to store auth share: ${response.statusText}`);
-    }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async storeAuthShare(_input) {
+    throwDidChallengeRequired();
   }
-  async addRecoveryMethod(input) {
-    const headers = await this.getAuthHeaders();
-    const providerType = this.authProvider.getProviderType();
-    const response = await fetch(`${this.serverUrl}/keys/recovery`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        ...input,
-        providerType
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to add recovery method: ${response.statusText}`);
-    }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async addRecoveryMethod(_input) {
+    throwDidChallengeRequired();
   }
   async getRecoveryShare(type, credentialId) {
     const token = await this.authProvider.getIdToken();
     const providerType = this.authProvider.getProviderType();
-    const params = new URLSearchParams({
-      type,
-      providerType,
-      authToken: token
-    });
+    const params = new URLSearchParams({ type, providerType });
     if (credentialId) {
       params.append("credentialId", credentialId);
     }
     const response = await fetch(`${this.serverUrl}/keys/recovery?${params}`, {
       method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
+      headers: { "Content-Type": "application/json", "X-Auth-Token": token }
     });
     if (!response.ok) {
       if (response.status === 404) {
@@ -18238,81 +18724,81 @@ var SSSApiClient = class {
     }
     return response.json();
   }
-  async markMigrated() {
-    const headers = await this.getAuthHeaders();
-    const providerType = this.authProvider.getProviderType();
-    const response = await fetch(`${this.serverUrl}/keys/migrate`, {
+  async startIdentityRecovery(email) {
+    const response = await fetch(`${this.serverUrl}/keys/recovery-session/start`, {
       method: "POST",
-      headers,
-      body: JSON.stringify({ providerType })
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email })
     });
     if (!response.ok) {
-      throw new Error(`Failed to mark as migrated: ${response.statusText}`);
+      throw new Error(`Failed to send recovery code: ${response.statusText}`);
     }
   }
-  async sendEmailBackupShare(emailShare, overrideEmail) {
-    const headers = await this.getAuthHeaders();
-    const providerType = this.authProvider.getProviderType();
-    let email = overrideEmail;
-    if (!email) {
-      const user = await this.authProvider.getCurrentUser();
-      email = user?.email;
-    }
-    if (!email) {
-      console.warn("Cannot send email backup share: no email address available");
-      return;
-    }
-    const response = await fetch(`${this.serverUrl}/keys/email-backup`, {
+  async verifyIdentityRecovery(email, code) {
+    const response = await fetch(`${this.serverUrl}/keys/recovery-session/verify`, {
       method: "POST",
-      headers,
-      body: JSON.stringify({
-        providerType,
-        emailShare,
-        email
-      })
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, code })
     });
     if (!response.ok) {
-      console.warn(`Failed to send email backup share: ${response.statusText}`);
+      throw new Error(`Failed to verify recovery code: ${response.statusText}`);
     }
+    return response.json();
   }
-  async addRecoveryEmail(email) {
-    const token = await this.authProvider.getIdToken();
-    const providerType = this.authProvider.getProviderType();
-    const response = await fetch(`${this.serverUrl}/keys/recovery-email/add`, {
+  async useIdentityRecoverySession(recoverySessionToken, type, credentialId) {
+    const response = await fetch(`${this.serverUrl}/keys/recovery-session/recover`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ authToken: token, providerType, email })
+      body: JSON.stringify({ recoverySessionToken, type, credentialId })
     });
     if (!response.ok) {
-      const data = await response.json().catch(() => ({}));
-      throw new Error(data?.message || `Failed to add recovery email: ${response.statusText}`);
+      throw new Error(`Failed to retrieve recovery data: ${response.statusText}`);
     }
+    return response.json();
   }
-  async verifyRecoveryEmail(code) {
-    const token = await this.authProvider.getIdToken();
-    const providerType = this.authProvider.getProviderType();
-    const response = await fetch(`${this.serverUrl}/keys/recovery-email/verify`, {
+  async completeIdentityRecoveryRebind(input) {
+    const response = await fetch(`${this.serverUrl}/keys/recovery-session/rebind`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ authToken: token, providerType, code })
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${input.didAuthVp}`,
+        "X-Auth-Token": input.newAuthToken
+      },
+      body: JSON.stringify({
+        recoverySessionToken: input.recoverySessionToken,
+        providerType: input.providerType,
+        primaryDid: input.primaryDid,
+        authShare: input.authShare
+      })
     });
     if (!response.ok) {
-      const data = await response.json().catch(() => ({}));
-      throw new Error(data?.message || `Failed to verify recovery email: ${response.statusText}`);
+      throw new Error(`Failed to bind the new sign-in: ${response.statusText}`);
     }
     return response.json();
   }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async markMigrated() {
+    throwDidChallengeRequired();
+  }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async activate() {
+    throwDidChallengeRequired();
+  }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async sendEmailBackupShare(_emailShare, _overrideEmail) {
+    throwDidChallengeRequired();
+  }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async addRecoveryEmail(_email) {
+    throwDidChallengeRequired();
+  }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
+  async verifyRecoveryEmail(_code) {
+    return throwDidChallengeRequired();
+  }
+  /** @deprecated Requires DID-challenge authorization. Use `createSSSStrategy`. */
   async deleteUserKey() {
-    const headers = await this.getAuthHeaders();
-    const providerType = this.authProvider.getProviderType();
-    const response = await fetch(`${this.serverUrl}/keys`, {
-      method: "DELETE",
-      headers,
-      body: JSON.stringify({ providerType })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to delete user key: ${response.statusText}`);
-    }
+    throwDidChallengeRequired();
   }
 };
 
@@ -18507,11 +18993,10 @@ async function getOrCreateMasterKey() {
         (s) => s.get("master-key")
       );
       if (existing) return existing;
-      const key = await crypto.subtle.generateKey(
-        { name: "AES-GCM", length: 256 },
-        false,
-        ["encrypt", "decrypt"]
-      );
+      const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
+        "encrypt",
+        "decrypt"
+      ]);
       await tx(db, KEYS_STORE, "readwrite", (s) => s.put(key, "master-key"));
       return key;
     } finally {
@@ -18612,12 +19097,7 @@ __name(getShareVersion, "getShareVersion");
 async function getDeviceShare(id = DEFAULT_DEVICE_SHARE_ID) {
   const db = await openDB();
   try {
-    const raw = await tx(
-      db,
-      SHARES_STORE,
-      "readonly",
-      (s) => s.get(id)
-    );
+    const raw = await tx(db, SHARES_STORE, "readonly", (s) => s.get(id));
     if (raw == null) {
       return null;
     }
@@ -18676,7 +19156,9 @@ async function listAllDeviceShares() {
       try {
         const share = await getDeviceShare(id);
         if (!share) {
-          console.warn(`SSS Storage: removing orphaned entry that failed to decrypt: ${id}`);
+          console.warn(
+            `SSS Storage: removing orphaned entry that failed to decrypt: ${id}`
+          );
           await deleteDeviceShare(id);
           continue;
         }
@@ -18760,6 +19242,7 @@ function createAdaptiveStorage() {
     getDeviceShare: /* @__PURE__ */ __name((id) => isPublicComputerMode() ? sessionGetDeviceShare(id) : getDeviceShare(id), "getDeviceShare"),
     hasDeviceShare: /* @__PURE__ */ __name((id) => isPublicComputerMode() ? sessionHasDeviceShare(id) : hasDeviceShare(id), "hasDeviceShare"),
     clearAllShares: /* @__PURE__ */ __name((id) => isPublicComputerMode() ? sessionClearAllShares(id) : clearAllShares(id), "clearAllShares"),
+    deleteDeviceShare: /* @__PURE__ */ __name((id) => isPublicComputerMode() ? sessionDeleteDeviceShare(id) : deleteDeviceShare(id), "deleteDeviceShare"),
     storeShareVersion: /* @__PURE__ */ __name((version, id) => isPublicComputerMode() ? sessionStoreShareVersion(version, id) : storeShareVersion(version, id), "storeShareVersion"),
     getShareVersion: /* @__PURE__ */ __name((id) => isPublicComputerMode() ? sessionGetShareVersion(id) : getShareVersion(id), "getShareVersion")
   };
@@ -19040,6 +19523,33 @@ function countWords(phrase) {
   return phrase.trim().split(/\s+/).filter((w) => w.length > 0).length;
 }
 __name(countWords, "countWords");
+function randomIndex(max) {
+  const limit = 4294967296 - 4294967296 % max;
+  for (; ; ) {
+    const value = crypto.getRandomValues(new Uint32Array(1))[0];
+    if (value === void 0) throw new Error("Failed to choose recovery phrase words");
+    if (value < limit) return value % max;
+  }
+}
+__name(randomIndex, "randomIndex");
+async function buildRecoveryPhraseChallengeOptions(phrase, challengeWordIndices, optionCount = 6) {
+  const words = phrase.trim().split(/\s+/);
+  const phraseWords = new Set(words);
+  const decoyPool = (await getWordlist()).filter((word) => !phraseWords.has(word));
+  return challengeWordIndices.map((wordIndex) => {
+    const answer = words[wordIndex];
+    if (!answer) throw new Error("Recovery phrase challenge index is out of range");
+    const options = /* @__PURE__ */ new Set([answer]);
+    while (options.size < optionCount) options.add(decoyPool[randomIndex(decoyPool.length)]);
+    const shuffled = [...options];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+      const j = randomIndex(i + 1);
+      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+  });
+}
+__name(buildRecoveryPhraseChallengeOptions, "buildRecoveryPhraseChallengeOptions");
 
 // src/key-manager.ts
 var SSSKeyManager = class {
@@ -19265,117 +19775,671 @@ function createSSSKeyManager(config) {
 }
 __name(createSSSKeyManager, "createSSSKeyManager");
 
-// src/atomic-operations.ts
-var ShareVerificationError = class extends Error {
-  constructor(message, combination, expected, got) {
-    super(message);
-    this.combination = combination;
-    this.expected = expected;
-    this.got = got;
-    this.name = "ShareVerificationError";
-  }
-  static {
-    __name(this, "ShareVerificationError");
-  }
-};
-var AtomicUpdateError = class extends Error {
-  constructor(message, phase, rolledBack, cause) {
-    super(message);
-    this.phase = phase;
-    this.rolledBack = rolledBack;
-    this.cause = cause;
-    this.name = "AtomicUpdateError";
+// src/email-relay-crypto.ts
+var EMAIL_RELAY_ENVELOPE_VERSION = 1;
+var EMAIL_RELAY_ALGORITHM = "P-256-HKDF-SHA256-AES-256-GCM";
+var encodeUtf8 = /* @__PURE__ */ __name((value) => {
+  const bytes = new TextEncoder().encode(value);
+  const copy = new Uint8Array(new ArrayBuffer(bytes.byteLength));
+  copy.set(bytes);
+  return copy;
+}, "encodeUtf8");
+var EMAIL_RELAY_INFO = encodeUtf8("learncard-email-relay-v1");
+var SIX_DIGIT_CODE_RANGE = 9e5;
+var UINT32_RANGE = 4294967296;
+var MAX_UNBIASED_UINT32 = Math.floor(UINT32_RANGE / SIX_DIGIT_CODE_RANGE) * SIX_DIGIT_CODE_RANGE;
+var isRecord = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");
+var requireString = /* @__PURE__ */ __name((record, key, options) => {
+  const value = record[key];
+  if (typeof value !== "string" || value.length < (options.min ?? 1) || value.length > options.max || options.pattern && !options.pattern.test(value)) {
+    throw new Error(`Invalid email relay ${key}`);
   }
-  static {
-    __name(this, "AtomicUpdateError");
-  }
-};
-async function splitAndVerify(privateKey) {
-  const shares = await splitPrivateKey(privateKey);
-  const combinations = [
-    ["device+auth", shares.deviceShare, shares.authShare],
-    ["device+recovery", shares.deviceShare, shares.recoveryShare],
-    ["device+email", shares.deviceShare, shares.emailShare],
-    ["auth+recovery", shares.authShare, shares.recoveryShare],
-    ["auth+email", shares.authShare, shares.emailShare],
-    ["recovery+email", shares.recoveryShare, shares.emailShare]
+  return value;
+}, "requireString");
+var parseBranding = /* @__PURE__ */ __name((value) => {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) throw new Error("Invalid email relay branding");
+  const branding = {};
+  const keys = [
+    "brandName",
+    "logoUrl",
+    "logoAlt",
+    "primaryColor",
+    "primaryTextColor",
+    "supportEmail",
+    "websiteUrl",
+    "appUrl",
+    "fromDomain",
+    "copyrightHolder"
   ];
-  for (const [name, share1, share2] of combinations) {
-    const reconstructed = await reconstructFromShares([share1, share2]);
-    if (reconstructed !== privateKey) {
-      throw new ShareVerificationError(
-        `Share verification failed for ${name}: reconstruction mismatch`,
-        name,
-        privateKey,
-        reconstructed
-      );
+  for (const key of keys) {
+    const field = value[key];
+    if (field === void 0) continue;
+    if (typeof field !== "string" || field.length > 2048) {
+      throw new Error(`Invalid email relay branding.${key}`);
     }
+    branding[key] = field;
   }
-  return {
-    privateKey,
-    shares,
-    verified: true
-  };
-}
-__name(splitAndVerify, "splitAndVerify");
-async function atomicShareUpdate(privateKey, storage, options = {}) {
-  let newShares = null;
-  let deviceStored = false;
-  try {
-    const result = await splitAndVerify(privateKey);
-    newShares = result.shares;
-  } catch (e) {
-    throw new AtomicUpdateError(
-      "Failed to split and verify shares",
-      "split",
-      false,
-      e instanceof Error ? e : void 0
-    );
+  return branding;
+}, "parseBranding");
+var parseEmailRelayEnvelope = /* @__PURE__ */ __name((value) => {
+  if (!isRecord(value)) throw new Error("Invalid email relay envelope");
+  if (value.version !== EMAIL_RELAY_ENVELOPE_VERSION) {
+    throw new Error("Unsupported email relay envelope version");
   }
-  try {
-    await storage.storeDevice(newShares.deviceShare);
-    deviceStored = true;
-  } catch (e) {
-    throw new AtomicUpdateError(
-      "Failed to store device share locally",
-      "store_device",
-      false,
-      e instanceof Error ? e : void 0
-    );
+  if (value.algorithm !== EMAIL_RELAY_ALGORITHM) {
+    throw new Error("Unsupported email relay algorithm");
   }
-  try {
-    await storage.storeAuth(newShares.authShare);
-  } catch (e) {
-    if (options.previousDeviceShare && deviceStored) {
-      try {
-        await storage.storeDevice(options.previousDeviceShare);
-        options.onRollback?.("Server storage failed, restored previous device share");
-      } catch (rollbackError) {
-        console.error("CRITICAL: Rollback failed after auth share storage failure", rollbackError);
-      }
-    }
-    throw new AtomicUpdateError(
-      "Failed to store auth share on server, rolled back device share",
-      "store_auth",
-      !!options.previousDeviceShare,
-      e instanceof Error ? e : void 0
-    );
+  return {
+    version: EMAIL_RELAY_ENVELOPE_VERSION,
+    algorithm: EMAIL_RELAY_ALGORITHM,
+    keyId: requireString(value, "keyId", {
+      max: 128,
+      pattern: /^[A-Za-z0-9._-]+$/
+    }),
+    ephemeralPublicKey: requireString(value, "ephemeralPublicKey", { max: 256 }),
+    salt: requireString(value, "salt", { max: 128 }),
+    iv: requireString(value, "iv", { max: 64 }),
+    ciphertext: requireString(value, "ciphertext", { max: 16384 })
+  };
+}, "parseEmailRelayEnvelope");
+var parseEmailRelayPlaintext = /* @__PURE__ */ __name((value) => {
+  if (!isRecord(value) || value.version !== EMAIL_RELAY_ENVELOPE_VERSION) {
+    throw new Error("Invalid email relay plaintext");
   }
-  return newShares;
-}
-__name(atomicShareUpdate, "atomicShareUpdate");
-async function verifyStoredShares(storage, expectedDid, didFromPrivateKey) {
-  const result = {
-    healthy: false,
-    hasDeviceShare: false,
-    hasAuthShare: false,
-    didMatches: false,
-    error: void 0
+  return {
+    version: EMAIL_RELAY_ENVELOPE_VERSION,
+    targetEmail: requireString(value, "targetEmail", {
+      max: 320,
+      pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    }).trim().toLowerCase(),
+    recoveryKey: requireString(value, "recoveryKey", {
+      min: 5,
+      max: 4096,
+      pattern: /^[0-9a-f]+$/i
+    }),
+    confirmationCode: requireString(value, "confirmationCode", {
+      max: 6,
+      pattern: /^\d{6}$/
+    }),
+    branding: parseBranding(value.branding)
   };
-  try {
-    const deviceShare = await storage.getDevice?.();
-    result.hasDeviceShare = !!deviceShare;
-    if (!deviceShare) {
+}, "parseEmailRelayPlaintext");
+var getAad = /* @__PURE__ */ __name((envelope) => encodeUtf8(`${envelope.version}|${envelope.algorithm}|${envelope.keyId}`), "getAad");
+var deriveAesKey = /* @__PURE__ */ __name(async (sharedSecret, salt, usage) => {
+  const keyMaterial = await crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, [
+    "deriveKey"
+  ]);
+  return crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info: EMAIL_RELAY_INFO },
+    keyMaterial,
+    { name: "AES-GCM", length: 256 },
+    false,
+    [usage]
+  );
+}, "deriveAesKey");
+var generateEmailRelayConfirmationCode = /* @__PURE__ */ __name(() => {
+  const random = new Uint32Array(1);
+  let value;
+  do {
+    crypto.getRandomValues(random);
+    value = random[0] ?? UINT32_RANGE;
+  } while (value >= MAX_UNBIASED_UINT32);
+  return String(1e5 + value % SIX_DIGIT_CODE_RANGE);
+}, "generateEmailRelayConfirmationCode");
+var encryptEmailRelayPayload = /* @__PURE__ */ __name(async (input, publicKeyBase64, keyId) => {
+  const plaintext = parseEmailRelayPlaintext({
+    ...input,
+    version: EMAIL_RELAY_ENVELOPE_VERSION
+  });
+  const normalizedKeyId = keyId.trim();
+  if (!publicKeyBase64.trim()) throw new Error("Email relay public key is not configured");
+  if (!/^[A-Za-z0-9._-]{1,128}$/.test(normalizedKeyId)) {
+    throw new Error("Email relay key ID is not configured");
+  }
+  const recipientPublicKey = await crypto.subtle.importKey(
+    "spki",
+    base64ToBuffer(publicKeyBase64.trim()).buffer,
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  const ephemeralKeyPair = await crypto.subtle.generateKey(
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    ["deriveBits"]
+  );
+  const sharedSecret = await crypto.subtle.deriveBits(
+    { name: "ECDH", public: recipientPublicKey },
+    ephemeralKeyPair.privateKey,
+    256
+  );
+  const salt = crypto.getRandomValues(new Uint8Array(32));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const aesKey = await deriveAesKey(sharedSecret, salt, "encrypt");
+  const envelopeMetadata = {
+    version: EMAIL_RELAY_ENVELOPE_VERSION,
+    algorithm: EMAIL_RELAY_ALGORITHM,
+    keyId: normalizedKeyId
+  };
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv, additionalData: getAad(envelopeMetadata) },
+    aesKey,
+    encodeUtf8(JSON.stringify(plaintext))
+  );
+  const ephemeralPublicKey = await crypto.subtle.exportKey("raw", ephemeralKeyPair.publicKey);
+  return {
+    ...envelopeMetadata,
+    ephemeralPublicKey: bufferToBase64(ephemeralPublicKey),
+    salt: bufferToBase64(salt.buffer),
+    iv: bufferToBase64(iv.buffer),
+    ciphertext: bufferToBase64(ciphertext)
+  };
+}, "encryptEmailRelayPayload");
+var decryptEmailRelayPayload = /* @__PURE__ */ __name(async (value, privateKeyBase64) => {
+  const envelope = parseEmailRelayEnvelope(value);
+  const privateKey = await crypto.subtle.importKey(
+    "pkcs8",
+    base64ToBuffer(privateKeyBase64.trim()).buffer,
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    ["deriveBits"]
+  );
+  const ephemeralPublicKey = await crypto.subtle.importKey(
+    "raw",
+    base64ToBuffer(envelope.ephemeralPublicKey).buffer,
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  const sharedSecret = await crypto.subtle.deriveBits(
+    { name: "ECDH", public: ephemeralPublicKey },
+    privateKey,
+    256
+  );
+  const salt = base64ToBuffer(envelope.salt);
+  const iv = base64ToBuffer(envelope.iv);
+  const aesKey = await deriveAesKey(sharedSecret, salt, "decrypt");
+  const decrypted = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: getAad(envelope) },
+    aesKey,
+    base64ToBuffer(envelope.ciphertext)
+  );
+  const parsed = JSON.parse(new TextDecoder().decode(decrypted));
+  return parseEmailRelayPlaintext(parsed);
+}, "decryptEmailRelayPayload");
+
+// src/escrow-crypto.ts
+var ESCROW_ENVELOPE_VERSION = 1;
+var ESCROW_ALGORITHM = "P-256-HKDF-SHA256-AES-256-GCM";
+var ESCROW_BLOB_INFO = "learncard-escrow-blob-v1";
+var ESCROW_RELEASE_INFO = "learncard-escrow-release-v1";
+var ESCROW_CLIENT_KEY_ID = "client";
+var encodeUtf82 = /* @__PURE__ */ __name((value) => {
+  const bytes = new TextEncoder().encode(value);
+  const copy = new Uint8Array(new ArrayBuffer(bytes.byteLength));
+  copy.set(bytes);
+  return copy;
+}, "encodeUtf8");
+var isRecord2 = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");
+var requireString2 = /* @__PURE__ */ __name((record, key, options) => {
+  const value = record[key];
+  if (typeof value !== "string" || value.length < (options.min ?? 1) || value.length > options.max || options.pattern && !options.pattern.test(value)) {
+    throw new Error(`Invalid escrow ${key}`);
+  }
+  return value;
+}, "requireString");
+var parseEscrowEnvelope = /* @__PURE__ */ __name((value) => {
+  if (!isRecord2(value)) throw new Error("Invalid escrow envelope");
+  if (value.version !== ESCROW_ENVELOPE_VERSION) {
+    throw new Error("Unsupported escrow envelope version");
+  }
+  if (value.algorithm !== ESCROW_ALGORITHM) {
+    throw new Error("Unsupported escrow algorithm");
+  }
+  return {
+    version: ESCROW_ENVELOPE_VERSION,
+    algorithm: ESCROW_ALGORITHM,
+    keyId: requireString2(value, "keyId", { max: 128, pattern: /^[A-Za-z0-9._-]+$/ }),
+    ephemeralPublicKey: requireString2(value, "ephemeralPublicKey", { max: 256 }),
+    salt: requireString2(value, "salt", { max: 128 }),
+    iv: requireString2(value, "iv", { max: 64 }),
+    ciphertext: requireString2(value, "ciphertext", { max: 16384 })
+  };
+}, "parseEscrowEnvelope");
+var parseEscrowBlobPlaintext = /* @__PURE__ */ __name((value) => {
+  if (!isRecord2(value) || value.version !== ESCROW_ENVELOPE_VERSION) {
+    throw new Error("Invalid escrow plaintext");
+  }
+  if (typeof value.shareVersion !== "number" || !Number.isInteger(value.shareVersion) || value.shareVersion <= 0) {
+    throw new Error("Invalid escrow shareVersion");
+  }
+  return {
+    version: ESCROW_ENVELOPE_VERSION,
+    recoveryShare: requireString2(value, "recoveryShare", {
+      min: 5,
+      max: 4096,
+      pattern: /^[0-9a-f]+$/i
+    }).toLowerCase(),
+    did: requireString2(value, "did", { max: 2048, pattern: /^did:/ }),
+    shareVersion: value.shareVersion,
+    ...value.pinVerifier !== void 0 ? {
+      pinVerifier: requireString2(value, "pinVerifier", {
+        min: 64,
+        max: 64,
+        pattern: /^[0-9a-f]{64}$/i
+      }).toLowerCase()
+    } : {}
+  };
+}, "parseEscrowBlobPlaintext");
+var parseEscrowReleasePlaintext = /* @__PURE__ */ __name((value) => {
+  const plaintext = parseEscrowBlobPlaintext(value);
+  if (!isRecord2(value)) throw new Error("Invalid escrow plaintext");
+  return {
+    ...plaintext,
+    holdId: requireString2(value, "holdId", { max: 128, pattern: /^[A-Za-z0-9._-]+$/ })
+  };
+}, "parseEscrowReleasePlaintext");
+var getAad2 = /* @__PURE__ */ __name((envelope) => encodeUtf82(`${envelope.version}|${envelope.algorithm}|${envelope.keyId}`), "getAad");
+var deriveAesKey2 = /* @__PURE__ */ __name(async (sharedSecret, salt, usage, info) => {
+  const keyMaterial = await crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, [
+    "deriveKey"
+  ]);
+  return crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info: encodeUtf82(info) },
+    keyMaterial,
+    { name: "AES-GCM", length: 256 },
+    false,
+    [usage]
+  );
+}, "deriveAesKey");
+var generateEscrowKeyPair = /* @__PURE__ */ __name(async () => {
+  const keyPair = await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, [
+    "deriveBits"
+  ]);
+  const [publicKey, privateKey] = await Promise.all([
+    crypto.subtle.exportKey("spki", keyPair.publicKey),
+    crypto.subtle.exportKey("pkcs8", keyPair.privateKey)
+  ]);
+  return { publicKey: bufferToBase64(publicKey), privateKey: bufferToBase64(privateKey) };
+}, "generateEscrowKeyPair");
+var encryptToRecipient = /* @__PURE__ */ __name(async (plaintextJson, spki, keyId, info) => {
+  if (typeof spki !== "string" || !spki.trim()) {
+    throw new Error("Escrow public key is not configured");
+  }
+  const recipientKeyId = requireString2({ keyId }, "keyId", {
+    max: 128,
+    pattern: /^[A-Za-z0-9._-]+$/
+  });
+  const recipientPublicKey = await crypto.subtle.importKey(
+    "spki",
+    base64ToBuffer(spki.trim()),
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  const ephemeralKeyPair = await crypto.subtle.generateKey(
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    ["deriveBits"]
+  );
+  const sharedSecret = await crypto.subtle.deriveBits(
+    { name: "ECDH", public: recipientPublicKey },
+    ephemeralKeyPair.privateKey,
+    256
+  );
+  const salt = crypto.getRandomValues(new Uint8Array(32));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const aesKey = await deriveAesKey2(sharedSecret, salt, "encrypt", info);
+  const metadata = {
+    version: ESCROW_ENVELOPE_VERSION,
+    algorithm: ESCROW_ALGORITHM,
+    keyId: recipientKeyId
+  };
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv, additionalData: getAad2(metadata) },
+    aesKey,
+    encodeUtf82(plaintextJson)
+  );
+  const ephemeralPublicKey = await crypto.subtle.exportKey("raw", ephemeralKeyPair.publicKey);
+  return {
+    ...metadata,
+    ephemeralPublicKey: bufferToBase64(ephemeralPublicKey),
+    salt: bufferToBase64(salt.buffer),
+    iv: bufferToBase64(iv.buffer),
+    ciphertext: bufferToBase64(ciphertext)
+  };
+}, "encryptToRecipient");
+var decryptFromEnvelope = /* @__PURE__ */ __name(async (value, pkcs8, info) => {
+  const envelope = parseEscrowEnvelope(value);
+  const privateKey = await crypto.subtle.importKey(
+    "pkcs8",
+    base64ToBuffer(pkcs8.trim()),
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    ["deriveBits"]
+  );
+  const ephemeralPublicKey = await crypto.subtle.importKey(
+    "raw",
+    base64ToBuffer(envelope.ephemeralPublicKey),
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  const sharedSecret = await crypto.subtle.deriveBits(
+    { name: "ECDH", public: ephemeralPublicKey },
+    privateKey,
+    256
+  );
+  const salt = base64ToBuffer(envelope.salt);
+  const iv = base64ToBuffer(envelope.iv);
+  const aesKey = await deriveAesKey2(sharedSecret, salt, "decrypt", info);
+  const decrypted = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: getAad2(envelope) },
+    aesKey,
+    base64ToBuffer(envelope.ciphertext)
+  );
+  const parsed = JSON.parse(new TextDecoder().decode(decrypted));
+  return parsed;
+}, "decryptFromEnvelope");
+var encryptEscrowBlob = /* @__PURE__ */ __name(async (input, enclavePublicKeySpkiB64, keyId) => {
+  const plaintext = parseEscrowBlobPlaintext({ ...input, version: ESCROW_ENVELOPE_VERSION });
+  return encryptToRecipient(
+    JSON.stringify(plaintext),
+    enclavePublicKeySpkiB64,
+    keyId,
+    ESCROW_BLOB_INFO
+  );
+}, "encryptEscrowBlob");
+var decryptEscrowBlob = /* @__PURE__ */ __name(async (envelope, enclavePrivateKeyPkcs8B64) => parseEscrowBlobPlaintext(
+  await decryptFromEnvelope(envelope, enclavePrivateKeyPkcs8B64, ESCROW_BLOB_INFO)
+), "decryptEscrowBlob");
+var sealEscrowRelease = /* @__PURE__ */ __name(async (input, clientEphemeralPublicKeySpkiB64) => {
+  const plaintext = parseEscrowReleasePlaintext({ ...input, version: ESCROW_ENVELOPE_VERSION });
+  return encryptToRecipient(
+    JSON.stringify(plaintext),
+    clientEphemeralPublicKeySpkiB64,
+    ESCROW_CLIENT_KEY_ID,
+    ESCROW_RELEASE_INFO
+  );
+}, "sealEscrowRelease");
+var openEscrowRelease = /* @__PURE__ */ __name(async (envelope, clientEphemeralPrivateKeyPkcs8B64) => parseEscrowReleasePlaintext(
+  await decryptFromEnvelope(envelope, clientEphemeralPrivateKeyPkcs8B64, ESCROW_RELEASE_INFO)
+), "openEscrowRelease");
+
+// src/escrow-attestation.ts
+var isRecord3 = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");
+var normalizePublicKey = /* @__PURE__ */ __name((value) => {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > 512 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(trimmed)) {
+    throw new Error("Invalid escrow attestation public key");
+  }
+  return bufferToBase64(base64ToBuffer(trimmed).buffer);
+}, "normalizePublicKey");
+var verifyEnclaveAttestation = /* @__PURE__ */ __name(async (attestation, policy) => {
+  const fields = ["mode", "keyId", "publicKey", "measurements", "document", "issuedAt"];
+  if (!isRecord3(attestation) || Object.keys(attestation).some((key) => !fields.includes(key)) || attestation.mode !== "software" && attestation.mode !== "nitro" || typeof attestation.keyId !== "string" || !/^[A-Za-z0-9._-]{1,128}$/.test(attestation.keyId) || typeof attestation.publicKey !== "string" || !isRecord3(attestation.measurements) || Object.entries(attestation.measurements).some(
+    ([key, value]) => !["imageSha384", "pcr0", "pcr1", "pcr2"].includes(key) || typeof value !== "string" || !value || value.length > 1024
+  ) || typeof attestation.document !== "string" || !attestation.document || attestation.document.length > 65536 || typeof attestation.issuedAt !== "string" || !Number.isFinite(Date.parse(attestation.issuedAt))) {
+    throw new Error("Invalid escrow attestation");
+  }
+  const publicKey = normalizePublicKey(attestation.publicKey);
+  await crypto.subtle.importKey(
+    "spki",
+    base64ToBuffer(publicKey),
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  if (policy.mode === "nitro") {
+    throw new Error("Nitro attestation verification is not implemented yet");
+  }
+  if (attestation.mode !== policy.mode) throw new Error("Escrow attestation mode mismatch");
+  if (!policy.pinnedPublicKeys.some((pin) => normalizePublicKey(pin) === publicKey)) {
+    throw new Error("Escrow attestation public key is not trusted");
+  }
+  return { publicKey, keyId: attestation.keyId, mode: attestation.mode };
+}, "verifyEnclaveAttestation");
+
+// src/types.ts
+var import_types = __toESM(require_dist());
+var EscrowPinUnavailableError = class extends Error {
+  static {
+    __name(this, "EscrowPinUnavailableError");
+  }
+  constructor() {
+    super("PIN recovery is not available for this account.");
+    this.name = "EscrowPinUnavailableError";
+  }
+};
+var EscrowPinMismatchError = class extends Error {
+  constructor(attemptsRemaining) {
+    super("Incorrect PIN.");
+    this.attemptsRemaining = attemptsRemaining;
+    this.name = "EscrowPinMismatchError";
+  }
+  static {
+    __name(this, "EscrowPinMismatchError");
+  }
+};
+var EscrowPinThrottledError = class extends Error {
+  static {
+    __name(this, "EscrowPinThrottledError");
+  }
+  constructor() {
+    super("Too many tries right now. Wait a minute and try again.");
+    this.name = "EscrowPinThrottledError";
+  }
+};
+var EscrowHoldRestartThrottledError = class extends Error {
+  constructor(retryAfter) {
+    super("A recovery request was started recently. Please wait before restarting.");
+    this.retryAfter = retryAfter;
+    this.name = "EscrowHoldRestartThrottledError";
+  }
+  static {
+    __name(this, "EscrowHoldRestartThrottledError");
+  }
+};
+var EscrowPinLockedError = class extends Error {
+  static {
+    __name(this, "EscrowPinLockedError");
+  }
+  constructor() {
+    super("Too many incorrect PIN attempts. You can still recover by waiting.");
+    this.name = "EscrowPinLockedError";
+  }
+};
+
+// src/escrow-pin.ts
+var PIN_MIN_LENGTH = 6;
+var PIN_MAX_LENGTH = 12;
+var ESCROW_PIN_MAX_ATTEMPTS = 10;
+var TRIVIAL_PINS = /* @__PURE__ */ new Set([
+  "123456",
+  "654321",
+  "000000",
+  "111111",
+  "121212",
+  "112233",
+  "123123",
+  "696969",
+  "123321"
+]);
+var normalizePin = /* @__PURE__ */ __name((raw) => raw.trim().normalize("NFKD").replace(/\D/g, ""), "normalizePin");
+var validatePin = /* @__PURE__ */ __name((pin) => {
+  const normalized = normalizePin(pin);
+  if (normalized.length < PIN_MIN_LENGTH || normalized.length > PIN_MAX_LENGTH) {
+    return { ok: false, reason: "length" };
+  }
+  if (/^(\d)\1+$/.test(normalized) || "0123456789".includes(normalized) || "9876543210".includes(normalized) || TRIVIAL_PINS.has(normalized)) {
+    return { ok: false, reason: "trivial" };
+  }
+  return { ok: true };
+}, "validatePin");
+var generatePinSalt = /* @__PURE__ */ __name(() => bufferToBase64(crypto.getRandomValues(new Uint8Array(16)).buffer), "generatePinSalt");
+var derivePinProof = /* @__PURE__ */ __name(async (pin, pinSaltBase64) => {
+  const salt = base64ToBuffer(pinSaltBase64);
+  if (salt.length !== 16) throw new Error("Invalid escrow PIN salt length");
+  const key = await deriveKeyFromPassword(normalizePin(pin), salt);
+  try {
+    return bytesToHex(key);
+  } finally {
+    key.fill(0);
+  }
+}, "derivePinProof");
+var constantTimeEqualHex = /* @__PURE__ */ __name((a, b) => {
+  if (a.length !== b.length || !/^(?:[0-9a-f]{2})+$/i.test(a) || !/^(?:[0-9a-f]{2})+$/i.test(b)) {
+    return false;
+  }
+  const aBytes = hexToBytes(a);
+  const bBytes = hexToBytes(b);
+  let difference = 0;
+  for (let i = 0; i < aBytes.length; i++) {
+    difference |= aBytes[i] ^ bBytes[i];
+  }
+  return difference === 0;
+}, "constantTimeEqualHex");
+
+// src/atomic-operations.ts
+var ShareVerificationError = class extends Error {
+  constructor(message, combination, expected, got) {
+    super(message);
+    this.combination = combination;
+    this.expected = expected;
+    this.got = got;
+    this.name = "ShareVerificationError";
+  }
+  static {
+    __name(this, "ShareVerificationError");
+  }
+};
+var AtomicUpdateError = class extends Error {
+  constructor(message, phase, rolledBack, cause) {
+    super(message);
+    this.phase = phase;
+    this.rolledBack = rolledBack;
+    this.cause = cause;
+    this.name = "AtomicUpdateError";
+  }
+  static {
+    __name(this, "AtomicUpdateError");
+  }
+};
+var ShareWriteRejectedError = class extends Error {
+  static {
+    __name(this, "ShareWriteRejectedError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "ShareWriteRejectedError";
+  }
+};
+async function splitAndVerify(privateKey) {
+  const shares = await splitPrivateKey(privateKey);
+  const combinations = [
+    ["device+auth", shares.deviceShare, shares.authShare],
+    ["device+recovery", shares.deviceShare, shares.recoveryShare],
+    ["device+email", shares.deviceShare, shares.emailShare],
+    ["auth+recovery", shares.authShare, shares.recoveryShare],
+    ["auth+email", shares.authShare, shares.emailShare],
+    ["recovery+email", shares.recoveryShare, shares.emailShare]
+  ];
+  for (const [name, share1, share2] of combinations) {
+    const reconstructed = await reconstructFromShares([share1, share2]);
+    if (reconstructed !== privateKey) {
+      throw new ShareVerificationError(
+        `Share verification failed for ${name}: reconstruction mismatch`,
+        name,
+        privateKey,
+        reconstructed
+      );
+    }
+  }
+  return {
+    privateKey,
+    shares,
+    verified: true
+  };
+}
+__name(splitAndVerify, "splitAndVerify");
+async function atomicShareUpdate(privateKey, storage, options = {}) {
+  let newShares = null;
+  let deviceStored = false;
+  try {
+    const result = await splitAndVerify(privateKey);
+    newShares = result.shares;
+  } catch (e) {
+    throw new AtomicUpdateError(
+      "Failed to split and verify shares",
+      "split",
+      false,
+      e instanceof Error ? e : void 0
+    );
+  }
+  try {
+    await storage.storeDevice(newShares.deviceShare);
+    deviceStored = true;
+  } catch (e) {
+    throw new AtomicUpdateError(
+      "Failed to store device share locally",
+      "store_device",
+      false,
+      e instanceof Error ? e : void 0
+    );
+  }
+  try {
+    await storage.storeAuth(newShares.authShare);
+  } catch (e) {
+    if (!(e instanceof ShareWriteRejectedError)) {
+      throw new AtomicUpdateError(
+        "Auth share write outcome unknown; device share preserved for reconciliation",
+        "store_auth",
+        false,
+        e instanceof Error ? e : void 0
+      );
+    }
+    let rolledBack = false;
+    if (deviceStored) {
+      try {
+        if (options.previousDeviceShare !== void 0) {
+          await storage.storeDevice(options.previousDeviceShare);
+          options.onRollback?.("Server storage failed, restored previous device share");
+          rolledBack = true;
+        } else if (storage.clearDevice) {
+          await storage.clearDevice();
+          options.onRollback?.("Server storage failed, removed new device share");
+          rolledBack = true;
+        }
+      } catch (rollbackError) {
+        console.error(
+          "CRITICAL: Rollback failed after auth share storage failure",
+          rollbackError
+        );
+      }
+    }
+    throw new AtomicUpdateError(
+      rolledBack ? "Failed to store auth share on server, rolled back device share" : "Failed to store auth share on server; rollback did not complete",
+      "store_auth",
+      rolledBack,
+      e instanceof Error ? e : void 0
+    );
+  }
+  return newShares;
+}
+__name(atomicShareUpdate, "atomicShareUpdate");
+async function verifyStoredShares(storage, expectedDid, didFromPrivateKey) {
+  const result = {
+    healthy: false,
+    hasDeviceShare: false,
+    hasAuthShare: false,
+    didMatches: false,
+    error: void 0
+  };
+  try {
+    const deviceShare = await storage.getDevice?.();
+    result.hasDeviceShare = !!deviceShare;
+    if (!deviceShare) {
       result.error = "No device share found";
       return result;
     }
@@ -19411,12 +20475,16 @@ async function atomicRecovery(recoveryShare, authShareData, storage, options = {
 __name(atomicRecovery, "atomicRecovery");
 
 // src/sss-strategy.ts
+var import_types3 = __toESM(require_dist());
 var SSS_DB_NAME = "lcb-sss-keys";
+var DEFAULT_DEVICE_SHARE_ID2 = "sss-device-share";
+var MAX_RECONCILIATION_HISTORY = 5;
 var defaultStorage = {
   storeDeviceShare,
   getDeviceShare,
   hasDeviceShare,
   clearAllShares,
+  deleteDeviceShare,
   storeShareVersion,
   getShareVersion
 };
@@ -19425,10 +20493,24 @@ var buildHeaders = /* @__PURE__ */ __name((token, didAuthVp, tenantId) => ({
   ...didAuthVp ? { Authorization: `Bearer ${didAuthVp}` } : {},
   ...tenantId ? { "X-Tenant-Id": tenantId } : {}
 }), "buildHeaders");
+var SERVER_REQUEST_TIMEOUT_MS = 3e4;
+var requestTimeoutSignal = /* @__PURE__ */ __name((ms = SERVER_REQUEST_TIMEOUT_MS) => typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(ms) : void 0, "requestTimeoutSignal");
+var describeHttpStatus = /* @__PURE__ */ __name((response) => response.statusText ? `${response.status} ${response.statusText}` : `${response.status}`, "describeHttpStatus");
+var EscrowRequestError = class extends Error {
+  constructor(status) {
+    super("Escrow request failed");
+    this.status = status;
+    this.name = "EscrowRequestError";
+  }
+  static {
+    __name(this, "EscrowRequestError");
+  }
+};
 var fetchAuthShareRaw = /* @__PURE__ */ __name(async (serverUrl, token, providerType, shareVersion, tenantId) => {
   const response = await fetch(`${serverUrl}/keys/auth-share`, {
     method: "POST",
     headers: buildHeaders(token, void 0, tenantId),
+    signal: requestTimeoutSignal(),
     body: JSON.stringify({
       authToken: token,
       providerType,
@@ -19437,42 +20519,103 @@ var fetchAuthShareRaw = /* @__PURE__ */ __name(async (serverUrl, token, provider
   });
   if (!response.ok) {
     if (response.status === 404) return null;
-    throw new Error(`Failed to fetch key status: ${response.statusText}`);
+    throw new Error(`Failed to fetch key status: ${describeHttpStatus(response)}`);
   }
   return response.json();
 }, "fetchAuthShareRaw");
-var putAuthShare = /* @__PURE__ */ __name(async (serverUrl, token, providerType, authShare, primaryDid, didAuthVp, tenantId) => {
+var putAuthShare = /* @__PURE__ */ __name(async (serverUrl, token, providerType, authShare, primaryDid, didAuthVp, tenantId, expectedShareVersion) => {
   const response = await fetch(`${serverUrl}/keys/auth-share`, {
     method: "PUT",
     headers: buildHeaders(token, didAuthVp, tenantId),
+    signal: requestTimeoutSignal(),
     body: JSON.stringify({
       authToken: token,
       providerType,
       authShare: { encryptedData: authShare, encryptedDek: "", iv: "" },
       primaryDid,
-      securityLevel: "basic"
+      securityLevel: "basic",
+      sssActivationState: "provisional",
+      expectedShareVersion
     })
   });
   if (!response.ok) {
-    throw new Error(`Failed to store auth share: ${response.statusText}`);
+    const message = `Failed to store auth share: ${describeHttpStatus(response)}`;
+    if (response.status >= 400 && response.status < 500 && response.status !== 408) {
+      throw new ShareWriteRejectedError(message);
+    }
+    throw new Error(message);
   }
   const data = await response.json();
-  return { shareVersion: data.shareVersion ?? 1 };
+  return {
+    shareVersion: data.shareVersion ?? 1,
+    expectedShareVersionChecked: data.expectedShareVersionChecked === true
+  };
 }, "putAuthShare");
+var authShareToString = /* @__PURE__ */ __name((authShare) => {
+  if (typeof authShare === "string") return authShare;
+  if (typeof authShare === "object" && authShare !== null && "encryptedData" in authShare && typeof authShare.encryptedData === "string") {
+    return authShare.encryptedData;
+  }
+  return null;
+}, "authShareToString");
+var requestFreshDidAuthVp = /* @__PURE__ */ __name(async (serverUrl, privateKey, did, signDidAuthVp, tenantId) => {
+  const bootstrapVp = await signDidAuthVp(privateKey);
+  const response = await fetch(`${serverUrl}/keys/challenge`, {
+    method: "POST",
+    headers: buildHeaders("", bootstrapVp, tenantId),
+    signal: requestTimeoutSignal(),
+    body: JSON.stringify({ did })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to request DID challenge: ${describeHttpStatus(response)}`);
+  }
+  const data = await response.json();
+  if (!data.challenge) throw new Error("DID challenge response was empty");
+  return signDidAuthVp(privateKey, data.challenge);
+}, "requestFreshDidAuthVp");
 var fetchRecoveryShare = /* @__PURE__ */ __name(async (serverUrl, token, providerType, type, credentialId, tenantId) => {
-  const params = new URLSearchParams({ type, providerType, authToken: token });
+  const params = new URLSearchParams({ type, providerType });
   if (credentialId) {
     params.set("credentialId", credentialId);
   }
   const response = await fetch(`${serverUrl}/keys/recovery?${params}`, {
     method: "GET",
-    headers: buildHeaders(token, void 0, tenantId)
+    headers: {
+      "Content-Type": "application/json",
+      "X-Auth-Token": token,
+      ...tenantId ? { "X-Tenant-Id": tenantId } : {}
+    }
   });
   if (!response.ok) {
     throw new Error(`No ${type} recovery share found`);
   }
   return response.json();
 }, "fetchRecoveryShare");
+var IdentityRecoverySessionConsumedError = class extends Error {
+  static {
+    __name(this, "IdentityRecoverySessionConsumedError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "IdentityRecoverySessionConsumedError";
+  }
+};
+var postJson = /* @__PURE__ */ __name(async (url, body, headers) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const data = await response.json().catch(() => null);
+    const message = data?.error?.message || data?.message || response.statusText;
+    if (response.status >= 400 && response.status < 500 && response.status !== 408) {
+      throw new ShareWriteRejectedError(message);
+    }
+    throw new Error(message);
+  }
+  return response.json();
+}, "postJson");
 var postRecoveryMethod = /* @__PURE__ */ __name(async (serverUrl, token, providerType, body, didAuthVp, tenantId) => {
   const response = await fetch(`${serverUrl}/keys/recovery`, {
     method: "POST",
@@ -19480,9 +20623,40 @@ var postRecoveryMethod = /* @__PURE__ */ __name(async (serverUrl, token, provide
     body: JSON.stringify({ authToken: token, providerType, ...body })
   });
   if (!response.ok) {
-    throw new Error(`Failed to add recovery method: ${response.statusText}`);
+    throw new Error(`Failed to add recovery method: ${describeHttpStatus(response)}`);
   }
 }, "postRecoveryMethod");
+var postRecoveryConfirmation = /* @__PURE__ */ __name(async (serverUrl, token, providerType, body, didAuthVp, tenantId) => {
+  const response = await fetch(`${serverUrl}/keys/recovery/confirm`, {
+    method: "POST",
+    headers: buildHeaders(token, didAuthVp, tenantId),
+    body: JSON.stringify({ authToken: token, providerType, ...body })
+  });
+  if (!response.ok) {
+    const data = await response.json().catch(() => null);
+    const message = data?.error?.message || data?.message || `Failed to confirm recovery method`;
+    throw new Error(message);
+  }
+}, "postRecoveryConfirmation");
+var calculateShareChecksum = /* @__PURE__ */ __name(async (share) => {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(share));
+  return bytesToHex(new Uint8Array(digest));
+}, "calculateShareChecksum");
+var RECOVERY_PHRASE_CHALLENGE_COUNT = 2;
+var selectRecoveryPhraseChallengeIndices = /* @__PURE__ */ __name((wordCount, challengeCount = RECOVERY_PHRASE_CHALLENGE_COUNT) => {
+  if (wordCount < challengeCount) {
+    throw new Error("Recovery phrase does not contain enough words for confirmation");
+  }
+  const indices = /* @__PURE__ */ new Set();
+  const limit = 4294967296 - 4294967296 % wordCount;
+  while (indices.size < challengeCount) {
+    const randomValue = crypto.getRandomValues(new Uint32Array(1))[0];
+    if (randomValue === void 0) throw new Error("Failed to choose recovery phrase words");
+    if (randomValue >= limit) continue;
+    indices.add(randomValue % wordCount);
+  }
+  return [...indices].sort((a, b) => a - b);
+}, "selectRecoveryPhraseChallengeIndices");
 var VERSION_PREFIX_LEN = 4;
 var formatVersionedEmailShare = /* @__PURE__ */ __name((emailShare, shareVersion) => shareVersion.toString(16).padStart(VERSION_PREFIX_LEN, "0") + emailShare, "formatVersionedEmailShare");
 var parseVersionedEmailShare = /* @__PURE__ */ __name((input) => {
@@ -19495,44 +20669,512 @@ var parseVersionedEmailShare = /* @__PURE__ */ __name((input) => {
   }
   return { share: input, version: void 0 };
 }, "parseVersionedEmailShare");
-var sendEmailBackupShare = /* @__PURE__ */ __name(async (serverUrl, token, providerType, emailShare, email, shareVersion, tenantId) => {
-  try {
-    const payload = shareVersion != null ? formatVersionedEmailShare(emailShare, shareVersion) : emailShare;
-    const response = await fetch(`${serverUrl}/keys/email-backup`, {
-      method: "POST",
-      headers: buildHeaders(token, void 0, tenantId),
-      body: JSON.stringify({ authToken: token, providerType, emailShare: payload, email })
-    });
-    if (!response.ok) {
-      console.warn(`Email backup share delivery failed: ${response.statusText}`);
-    }
-  } catch (e) {
-    console.warn("Email backup share delivery failed:", e);
-  }
-}, "sendEmailBackupShare");
-var sendEmailShareToRecoveryEmail = /* @__PURE__ */ __name(async (serverUrl, token, providerType, emailShare, shareVersion, tenantId) => {
-  const payload = shareVersion != null ? formatVersionedEmailShare(emailShare, shareVersion) : emailShare;
+var sendEmailBackupShare = /* @__PURE__ */ __name(async (serverUrl, token, providerType, emailShare, email, escrowRelayPublicKey, escrowRelayKeyId, emailBranding, shareVersion, didAuthVp, tenantId) => {
+  const recoveryKey = shareVersion != null ? formatVersionedEmailShare(emailShare, shareVersion) : emailShare;
+  const confirmationCode = generateEmailRelayConfirmationCode();
+  const relayPayload = await encryptEmailRelayPayload(
+    {
+      targetEmail: email,
+      recoveryKey,
+      confirmationCode,
+      branding: emailBranding
+    },
+    escrowRelayPublicKey,
+    escrowRelayKeyId
+  );
   const response = await fetch(`${serverUrl}/keys/email-backup`, {
     method: "POST",
-    headers: buildHeaders(token, void 0, tenantId),
+    headers: buildHeaders(token, didAuthVp, tenantId),
     body: JSON.stringify({
       authToken: token,
       providerType,
-      emailShare: payload,
-      useRecoveryEmail: true
+      relayPayload,
+      confirmationCode,
+      email,
+      shareVersion
     })
   });
   if (!response.ok) {
-    throw new Error(`Failed to send recovery share to recovery email: ${response.statusText}`);
+    throw new Error(`Failed to send recovery share: ${describeHttpStatus(response)}`);
+  }
+}, "sendEmailBackupShare");
+var rotationChain = Promise.resolve();
+var withRotationLock = /* @__PURE__ */ __name((operation) => {
+  const run = rotationChain.then(operation, operation);
+  rotationChain = run.catch(() => void 0);
+  return run;
+}, "withRotationLock");
+var pendingShareId = /* @__PURE__ */ __name((storageId) => `sss-pending-share:${storageId ?? DEFAULT_DEVICE_SHARE_ID2}`, "pendingShareId");
+var PENDING_WRITE_EXPIRY_MS = 10 * 60 * 1e3;
+var MAX_PENDING_SHARE_CANDIDATES = 8;
+var readPendingShareCandidates = /* @__PURE__ */ __name(async (storage, storageId) => {
+  const raw = await storage.getDeviceShare(pendingShareId(storageId));
+  if (!raw) return [];
+  if (!raw.trimStart().startsWith("{")) return [{ share: raw, createdAt: 0 }];
+  const data = JSON.parse(raw);
+  if (!data || typeof data !== "object" || !("v" in data) || data.v !== 1 || !("candidates" in data) || !Array.isArray(data.candidates) || !data.candidates.every(
+    (candidate) => candidate !== null && typeof candidate === "object" && "share" in candidate && typeof candidate.share === "string" && "createdAt" in candidate && typeof candidate.createdAt === "number" && Number.isFinite(candidate.createdAt) && candidate.createdAt >= 0
+  ))
+    throw new Error("Invalid pending share candidates");
+  return data.candidates;
+}, "readPendingShareCandidates");
+var clearPendingShareCandidates = /* @__PURE__ */ __name(async (storage, storageId) => storage.clearAllShares(pendingShareId(storageId)), "clearPendingShareCandidates");
+var writePendingShareCandidates = /* @__PURE__ */ __name(async (storage, candidates, storageId) => {
+  if (!candidates.length) return clearPendingShareCandidates(storage, storageId);
+  await storage.storeDeviceShare(JSON.stringify({ v: 1, candidates }), pendingShareId(storageId));
+}, "writePendingShareCandidates");
+var addPendingShareCandidate = /* @__PURE__ */ __name(async (storage, candidate, storageId) => {
+  const candidates = await readPendingShareCandidates(storage, storageId);
+  if (candidates.length >= MAX_PENDING_SHARE_CANDIDATES) {
+    throw new AtomicUpdateError(
+      "Reconcile the pending share update before writing new shares",
+      "store_device",
+      false
+    );
+  }
+  await writePendingShareCandidates(storage, [...candidates, candidate], storageId);
+}, "addPendingShareCandidate");
+var removePendingShareCandidate = /* @__PURE__ */ __name(async (storage, share, storageId) => {
+  const candidates = await readPendingShareCandidates(storage, storageId);
+  await writePendingShareCandidates(
+    storage,
+    candidates.filter((candidate) => candidate.share !== share),
+    storageId
+  );
+}, "removePendingShareCandidate");
+var resolvePendingShareCandidates = /* @__PURE__ */ __name(async (storage, storageId, fetchCurrent, expectedDid, didFromPrivateKey, assertActiveUser = () => {
+}, onPromoted, fetchHistorical) => {
+  const candidates = await readPendingShareCandidates(storage, storageId);
+  const snapshot = await fetchCurrent();
+  assertActiveUser();
+  const { authShare, currentVersion } = snapshot;
+  if (authShare && (currentVersion === null || !Number.isInteger(currentVersion) || currentVersion < 1)) {
+    throw new Error("Current auth share is missing a valid share version");
+  }
+  if (authShare && currentVersion !== null) {
+    for (const candidate of candidates) {
+      const health = await verifyStoredShares(
+        { getDevice: /* @__PURE__ */ __name(async () => candidate.share, "getDevice"), getAuth: /* @__PURE__ */ __name(async () => authShare, "getAuth") },
+        expectedDid,
+        didFromPrivateKey
+      );
+      assertActiveUser();
+      if (!health.healthy) continue;
+      const privateKey = await reconstructFromShares([candidate.share, authShare]);
+      assertActiveUser();
+      await storage.storeDeviceShare(candidate.share, storageId);
+      await storage.storeShareVersion(currentVersion, storageId);
+      await removePendingShareCandidate(storage, candidate.share, storageId);
+      assertActiveUser();
+      onPromoted?.(snapshot);
+      return { snapshot, privateKey };
+    }
+  }
+  const matched = /* @__PURE__ */ new Set();
+  const history = /* @__PURE__ */ new Map();
+  let historyComplete = true;
+  if (candidates.length && currentVersion !== null) {
+    for (let version = currentVersion - 1; version >= 1 && version >= currentVersion - MAX_RECONCILIATION_HISTORY; version--) {
+      if (!fetchHistorical) {
+        historyComplete = false;
+        break;
+      }
+      try {
+        const share = await fetchHistorical(version);
+        if (share) history.set(version, share);
+      } catch {
+        historyComplete = false;
+      }
+      assertActiveUser();
+    }
+  }
+  const mainShare = await storage.getDeviceShare(storageId);
+  let mainHealthy = false;
+  const retainedShares = [...history.values(), ...authShare ? [authShare] : []];
+  if (mainShare) {
+    for (const share of retainedShares) {
+      const health = await verifyStoredShares(
+        { getDevice: /* @__PURE__ */ __name(async () => mainShare, "getDevice"), getAuth: /* @__PURE__ */ __name(async () => share, "getAuth") },
+        expectedDid,
+        didFromPrivateKey
+      );
+      assertActiveUser();
+      if (health.healthy) {
+        mainHealthy = true;
+        break;
+      }
+    }
+  }
+  let promoted;
+  for (const candidate of candidates) {
+    for (const [version, share] of history) {
+      const health = await verifyStoredShares(
+        { getDevice: /* @__PURE__ */ __name(async () => candidate.share, "getDevice"), getAuth: /* @__PURE__ */ __name(async () => share, "getAuth") },
+        expectedDid,
+        didFromPrivateKey
+      );
+      assertActiveUser();
+      if (!health.healthy) continue;
+      matched.add(candidate.share);
+      if (!mainHealthy && !promoted) {
+        await storage.storeDeviceShare(candidate.share, storageId);
+        await storage.storeShareVersion(version, storageId);
+        assertActiveUser();
+        onPromoted?.({ currentVersion: version, authShare: share });
+        promoted = candidate.share;
+      }
+      break;
+    }
+  }
+  const live = candidates.filter(
+    (candidate) => candidate.share !== promoted && (matched.has(candidate.share) || !historyComplete || candidate.createdAt !== 0 && Date.now() - candidate.createdAt <= PENDING_WRITE_EXPIRY_MS)
+  );
+  if (live.length !== candidates.length) {
+    assertActiveUser();
+    await writePendingShareCandidates(storage, live, storageId);
+  }
+  return { snapshot, privateKey: null };
+}, "resolvePendingShareCandidates");
+var activeShareUpdates = /* @__PURE__ */ new WeakMap();
+var shareUpdateStorageOwners = /* @__PURE__ */ new WeakMap();
+var withShareUpdateLock = /* @__PURE__ */ __name(async (storage, storageId, operation) => {
+  const id = pendingShareId(storageId);
+  const owner = shareUpdateStorageOwners.get(storage) ?? storage;
+  const active = activeShareUpdates.get(owner) ?? /* @__PURE__ */ new Set();
+  activeShareUpdates.set(owner, active);
+  const busy = /* @__PURE__ */ __name(() => new AtomicUpdateError("A share update is already in progress", "store_device", false), "busy");
+  if (active.has(id)) throw busy();
+  active.add(id);
+  try {
+    if (typeof navigator !== "undefined" && navigator.locks) {
+      return await navigator.locks.request(id, { ifAvailable: true }, async (lock) => {
+        if (!lock) throw busy();
+        return operation();
+      });
+    }
+    return await operation();
+  } finally {
+    active.delete(id);
+  }
+}, "withShareUpdateLock");
+var persistSharesWithoutLock = /* @__PURE__ */ __name(async (privateKey, serverUrl, token, providerType, primaryDid, storage, storageId, didFromPrivateKey, signDidAuthVp, tenantId, onPromoted, assertActiveUser = () => {
+}) => {
+  if (primaryDid && didFromPrivateKey) {
+    const derivedDid = await didFromPrivateKey(privateKey);
+    if (derivedDid && derivedDid !== primaryDid) {
+      throw new Error(
+        "rotateShares: key does not match expected DID \u2014 refusing to overwrite server shares"
+      );
+    }
+  }
+  const { snapshot } = await resolvePendingShareCandidates(
+    storage,
+    storageId,
+    async () => {
+      const data = await fetchAuthShareRaw(
+        serverUrl,
+        token,
+        providerType,
+        void 0,
+        tenantId
+      );
+      return {
+        currentVersion: data?.shareVersion ?? null,
+        authShare: authShareToString(data?.authShare)
+      };
+    },
+    primaryDid,
+    didFromPrivateKey ?? (async (key) => key === privateKey ? primaryDid : `${primaryDid}:mismatch`),
+    assertActiveUser,
+    onPromoted,
+    async (version) => authShareToString(
+      (await fetchAuthShareRaw(serverUrl, token, providerType, version, tenantId))?.authShare
+    )
+  );
+  const didAuthVp = signDidAuthVp ? await requestFreshDidAuthVp(serverUrl, privateKey, primaryDid, signDidAuthVp, tenantId) : void 0;
+  assertActiveUser();
+  let shareVersion;
+  let stagedShare = "";
+  const shares = await atomicShareUpdate(privateKey, {
+    storeDevice: /* @__PURE__ */ __name(async (share) => {
+      assertActiveUser();
+      stagedShare = share;
+      await addPendingShareCandidate(storage, { share, createdAt: Date.now() }, storageId);
+    }, "storeDevice"),
+    clearDevice: /* @__PURE__ */ __name(() => removePendingShareCandidate(storage, stagedShare, storageId), "clearDevice"),
+    storeAuth: /* @__PURE__ */ __name(async (share) => {
+      assertActiveUser();
+      const result = await putAuthShare(
+        serverUrl,
+        token,
+        providerType,
+        share,
+        primaryDid,
+        didAuthVp,
+        tenantId,
+        snapshot.currentVersion ?? 0
+      );
+      shareVersion = result.shareVersion;
+    }, "storeAuth")
+  });
+  if (shareVersion === void 0) {
+    throw new Error("Server did not return a share version");
   }
-}, "sendEmailShareToRecoveryEmail");
+  await storage.storeDeviceShare(shares.deviceShare, storageId);
+  await storage.storeShareVersion(shareVersion, storageId);
+  await removePendingShareCandidate(storage, shares.deviceShare, storageId);
+  assertActiveUser();
+  return { shares, shareVersion };
+}, "persistSharesWithoutLock");
+var persistSharesAtomically = /* @__PURE__ */ __name((...args) => withShareUpdateLock(
+  args[5],
+  args[6],
+  () => withRotationLock(() => persistSharesWithoutLock(...args))
+), "persistSharesAtomically");
 function createSSSStrategy(config) {
-  const { serverUrl, enableEmailBackupShare = false, tenantId } = config;
+  const {
+    serverUrl,
+    enableEmailBackupShare = false,
+    escrowRelayPublicKey = "",
+    escrowRelayKeyId = "",
+    emailBranding,
+    tenantId
+  } = config;
   const storage = config.storage || defaultStorage;
+  let storageGeneration = 0;
+  const localWrites = /* @__PURE__ */ new Set();
+  const guardedStorage = /* @__PURE__ */ __name(() => {
+    const generation = storageGeneration;
+    const write = /* @__PURE__ */ __name((operation) => {
+      if (generation !== storageGeneration) {
+        return Promise.reject(new Error("This recovery request was cancelled."));
+      }
+      const pending = operation();
+      localWrites.add(pending);
+      return pending.finally(() => localWrites.delete(pending));
+    }, "write");
+    const guarded = {
+      ...storage,
+      storeDeviceShare: /* @__PURE__ */ __name((share, id) => write(() => storage.storeDeviceShare(share, id)), "storeDeviceShare"),
+      storeShareVersion: /* @__PURE__ */ __name((version, id) => write(() => storage.storeShareVersion(version, id)), "storeShareVersion"),
+      clearAllShares: /* @__PURE__ */ __name((id) => write(() => storage.clearAllShares(id)), "clearAllShares"),
+      deleteDeviceShare: /* @__PURE__ */ __name((id) => write(() => storage.deleteDeviceShare(id)), "deleteDeviceShare")
+    };
+    shareUpdateStorageOwners.set(guarded, storage);
+    return guarded;
+  }, "guardedStorage");
   let activeStorageId;
   let lastEmailShare;
   let lastShareVersion;
-  let hasRecoveryEmail = false;
+  let pendingPhraseConfirmation;
+  let pendingBackupConfirmation;
+  let pendingIdentityRecovery;
+  let lastServerSnapshot = null;
+  let escrowEnrollmentInFlight;
+  let unenrolledRotation;
+  const escrowRequest = /* @__PURE__ */ __name(async (path, init, pinAttempt = false) => {
+    const response = await fetch(`${serverUrl}/keys/escrow${path}`, {
+      signal: requestTimeoutSignal(),
+      ...init
+    });
+    if (!response.ok) {
+      if (!pinAttempt && path === "/recover" && response.status === 429) {
+        const body = await response.json().catch(() => void 0);
+        const message = body && typeof body === "object" && "message" in body && typeof body.message === "string" ? body.message : "";
+        const retryAfter = /Try again after (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\./.exec(
+          message
+        )?.[1];
+        throw new EscrowHoldRestartThrottledError(
+          retryAfter && Number.isFinite(Date.parse(retryAfter)) ? retryAfter : void 0
+        );
+      }
+      if (pinAttempt && response.status === 429) {
+        const body = await response.json().catch(() => void 0);
+        if (body && typeof body === "object" && "message" in body && body.message === import_types3.ESCROW_PIN_LOCKED_MESSAGE) {
+          throw new EscrowPinLockedError();
+        }
+        throw new EscrowPinThrottledError();
+      }
+      if (pinAttempt && response.status === 403) {
+        const body = await response.json().catch(() => void 0);
+        if (body && typeof body === "object" && "message" in body && body.message === import_types3.ESCROW_PIN_UNAVAILABLE_MESSAGE) {
+          throw new EscrowPinUnavailableError();
+        }
+        if (body && typeof body === "object" && "message" in body && typeof body.message === "string" && body.message.startsWith("Incorrect PIN.")) {
+          const match = import_types3.ESCROW_PIN_MISMATCH_PATTERN.exec(body.message);
+          const remaining = match ? Number(match[1]) : 0;
+          throw new EscrowPinMismatchError(
+            Number.isSafeInteger(remaining) && remaining >= 0 && remaining < ESCROW_PIN_MAX_ATTEMPTS ? remaining : 0
+          );
+        }
+      }
+      throw new EscrowRequestError(response.status);
+    }
+    try {
+      return await response.json();
+    } catch {
+      throw new EscrowRequestError(response.status);
+    }
+  }, "escrowRequest");
+  const fetchVerifiedEnclaveKey = /* @__PURE__ */ __name(async () => {
+    if (!config.escrow?.enabled) throw new Error("Escrow enrollment is disabled");
+    const { attestation } = await escrowRequest("/attestation", {
+      method: "GET",
+      headers: buildHeaders("", void 0, tenantId)
+    });
+    return verifyEnclaveAttestation(attestation, config.escrow.attestation);
+  }, "fetchVerifiedEnclaveKey");
+  const enrollEscrow = /* @__PURE__ */ __name(async (token, providerType, privateKey, primaryDid, shares, shareVersion, signDidAuthVp, verifiedKey, pinMaterial, clearPin = false) => {
+    if (!config.escrow?.enabled) throw new Error("Escrow enrollment is disabled");
+    if (!signDidAuthVp) throw new Error("DID proof signing is required for escrow enrollment");
+    const { publicKey, keyId } = verifiedKey ?? await fetchVerifiedEnclaveKey();
+    const envelope = await encryptEscrowBlob(
+      {
+        recoveryShare: shares.recoveryShare,
+        did: primaryDid,
+        shareVersion,
+        ...pinMaterial ? { pinVerifier: pinMaterial.pinVerifier } : {}
+      },
+      publicKey,
+      keyId
+    );
+    const vp = await requestFreshDidAuthVp(
+      serverUrl,
+      privateKey,
+      primaryDid,
+      signDidAuthVp,
+      tenantId
+    );
+    await escrowRequest("", {
+      method: "POST",
+      headers: buildHeaders(token, vp, tenantId),
+      body: JSON.stringify({
+        authToken: token,
+        providerType,
+        envelope,
+        shareVersion,
+        enclaveKeyId: keyId,
+        ...pinMaterial ? { pinSalt: pinMaterial.pinSalt } : {},
+        ...clearPin ? { clearPin: true } : {}
+      })
+    });
+  }, "enrollEscrow");
+  const tryEnrollEscrow = /* @__PURE__ */ __name(async (...args) => {
+    if (!config.escrow?.enabled) return;
+    try {
+      await enrollEscrow(...args);
+    } catch (err) {
+      try {
+        if (config.onEscrowError) config.onEscrowError(err);
+        else console.warn("SSS: escrow enrollment failed");
+      } catch {
+        console.warn("SSS: escrow error reporting failed");
+      }
+    }
+  }, "tryEnrollEscrow");
+  const ensureEscrowEnrollmentUnguarded = /* @__PURE__ */ __name(async (self, params, storage2, forceRotate = false) => {
+    if (!config.escrow?.enabled) return { enrolled: false, reason: "disabled" };
+    const pin = params.options?.pin;
+    if (pin !== void 0) {
+      const validation = validatePin(pin);
+      if (!validation.ok)
+        throw new Error(
+          validation.reason === "length" ? "PIN must contain 6\u201312 digits." : "Choose a PIN without trivial or sequential patterns."
+        );
+    }
+    const status = await self.fetchServerKeyStatus(params.token, params.providerType);
+    if (status.escrowOptedOut) return { enrolled: false, reason: "opted-out" };
+    if (!forceRotate && pin === void 0 && status.shareVersion !== null && status.recoveryMethods.some(
+      (method) => method.type === "escrow" && method.shareVersion === status.shareVersion && (Boolean(method.confirmedAt) || "confirmationStatus" in method && method.confirmationStatus === "confirmed")
+    ))
+      return { enrolled: true, changed: false };
+    if (!status.primaryDid) throw new Error("Cannot enroll escrow without a primary DID");
+    if (!params.signDidAuthVp) {
+      throw new Error("DID proof signing is required for escrow enrollment");
+    }
+    if (!forceRotate && pin === void 0 && unenrolledRotation && unenrolledRotation.shareVersion === status.shareVersion && unenrolledRotation.primaryDid === status.primaryDid) {
+      const retry = unenrolledRotation;
+      await enrollEscrow(
+        params.token,
+        params.providerType,
+        params.privateKey,
+        retry.primaryDid,
+        retry.shares,
+        retry.shareVersion,
+        params.signDidAuthVp,
+        void 0,
+        void 0,
+        retry.clearPin
+      );
+      unenrolledRotation = void 0;
+      return { enrolled: true, changed: true, shareVersion: retry.shareVersion };
+    }
+    const verifiedKey = await fetchVerifiedEnclaveKey();
+    const pinSalt = pin !== void 0 ? generatePinSalt() : void 0;
+    const pinMaterial = pin !== void 0 && pinSalt !== void 0 ? { pinSalt, pinVerifier: await derivePinProof(pin, pinSalt) } : void 0;
+    const storageId = activeStorageId;
+    const primaryDid = status.primaryDid;
+    const { shares, shareVersion } = await withShareUpdateLock(
+      storage2,
+      storageId,
+      () => persistSharesWithoutLock(
+        params.privateKey,
+        serverUrl,
+        params.token,
+        params.providerType,
+        primaryDid,
+        storage2,
+        storageId,
+        void 0,
+        params.signDidAuthVp,
+        tenantId
+      )
+    );
+    lastEmailShare = shares.emailShare;
+    lastShareVersion = shareVersion;
+    lastServerSnapshot = {
+      currentVersion: shareVersion,
+      resolvedVersion: shareVersion,
+      authShare: shares.authShare,
+      primaryDid: status.primaryDid
+    };
+    unenrolledRotation = pinMaterial ? void 0 : { shares, shareVersion, primaryDid: status.primaryDid, clearPin: forceRotate };
+    await enrollEscrow(
+      params.token,
+      params.providerType,
+      params.privateKey,
+      status.primaryDid,
+      shares,
+      shareVersion,
+      params.signDidAuthVp,
+      verifiedKey,
+      pinMaterial,
+      forceRotate
+    );
+    unenrolledRotation = void 0;
+    return { enrolled: true, changed: true, shareVersion };
+  }, "ensureEscrowEnrollmentUnguarded");
+  const recordPromotion = /* @__PURE__ */ __name((primaryDid) => (snapshot) => {
+    lastEmailShare = void 0;
+    lastShareVersion = snapshot.currentVersion ?? void 0;
+    lastServerSnapshot = {
+      ...snapshot,
+      resolvedVersion: snapshot.currentVersion,
+      primaryDid
+    };
+  }, "recordPromotion");
+  const captureActiveUserGuard = /* @__PURE__ */ __name(() => {
+    const storageId = activeStorageId;
+    return () => {
+      if (activeStorageId !== storageId) {
+        throw new AtomicUpdateError(
+          "Active account changed during share update",
+          "verify_stored",
+          false
+        );
+      }
+    };
+  }, "captureActiveUserGuard");
   return {
     name: "sss",
     capabilities: {
@@ -19543,23 +21185,31 @@ function createSSSStrategy(config) {
     },
     // --- User scoping ---
     setActiveUser(userId) {
+      if (activeStorageId !== `sss-device-share:${userId}`) storageGeneration++;
       activeStorageId = `sss-device-share:${userId}`;
+      lastServerSnapshot = null;
+      pendingPhraseConfirmation = void 0;
+      pendingBackupConfirmation = void 0;
     },
     // --- Key lifecycle ---
     async hasLocalKey() {
       if (await storage.hasDeviceShare(activeStorageId)) return true;
+      if ((await readPendingShareCandidates(storage, activeStorageId)).length) return true;
       if (activeStorageId) {
         return storage.hasDeviceShare();
       }
       return false;
     },
     async getLocalKey() {
-      const scoped = await storage.getDeviceShare(activeStorageId);
+      const storage2 = guardedStorage();
+      const scoped = await storage2.getDeviceShare(activeStorageId);
       if (scoped) return scoped;
+      const pending = await readPendingShareCandidates(storage2, activeStorageId);
+      if (pending.length) return pending[pending.length - 1].share;
       if (activeStorageId) {
-        const legacy = await storage.getDeviceShare();
+        const legacy = await storage2.getDeviceShare();
         if (legacy) {
-          await storage.storeDeviceShare(legacy, activeStorageId);
+          await storage2.storeDeviceShare(legacy, activeStorageId);
           return legacy;
         }
       }
@@ -19568,8 +21218,20 @@ function createSSSStrategy(config) {
     async storeLocalKey(key) {
       return storage.storeDeviceShare(key, activeStorageId);
     },
-    async clearLocalKeys() {
-      return storage.clearAllShares(activeStorageId);
+    async clearLocalKeys(options) {
+      const storageId = activeStorageId;
+      if (options?.preservePending) {
+        const storage2 = guardedStorage();
+        return withShareUpdateLock(
+          storage2,
+          storageId,
+          () => storage2.deleteDeviceShare(storageId)
+        );
+      }
+      storageGeneration++;
+      await Promise.allSettled(localWrites);
+      await clearPendingShareCandidates(storage, storageId);
+      return storage.clearAllShares(storageId);
     },
     async splitKey(privateKey) {
       const { shares } = await splitAndVerify(privateKey);
@@ -19593,9 +21255,175 @@ function createSSSStrategy(config) {
       );
       return result.healthy;
     },
+    async getFreshDidAuthVp(privateKey, did, signDidAuthVp) {
+      return requestFreshDidAuthVp(serverUrl, privateKey, did, signDidAuthVp, tenantId);
+    },
+    async atomicUpdateShares(params) {
+      const storage2 = guardedStorage();
+      const result = await persistSharesAtomically(
+        params.privateKey,
+        serverUrl,
+        params.token,
+        params.providerType,
+        params.did,
+        storage2,
+        activeStorageId,
+        void 0,
+        params.signDidAuthVp,
+        tenantId,
+        recordPromotion(params.did),
+        captureActiveUserGuard()
+      );
+      lastEmailShare = result.shares.emailShare;
+      lastShareVersion = result.shareVersion;
+      lastServerSnapshot = {
+        currentVersion: result.shareVersion,
+        resolvedVersion: result.shareVersion,
+        authShare: result.shares.authShare,
+        primaryDid: params.did
+      };
+    },
+    async reconcileShares(params) {
+      const storage2 = guardedStorage();
+      const storageId = activeStorageId;
+      const assertActiveUser = /* @__PURE__ */ __name(() => {
+        if (activeStorageId !== storageId) {
+          throw new AtomicUpdateError(
+            "Active account changed during reconciliation",
+            "verify_stored",
+            false
+          );
+        }
+      }, "assertActiveUser");
+      return withShareUpdateLock(storage2, storageId, async () => {
+        let deviceShare = await storage2.getDeviceShare(storageId);
+        const pending = await readPendingShareCandidates(storage2, storageId);
+        if (!deviceShare && !pending.length) return null;
+        const resolution = await resolvePendingShareCandidates(
+          storage2,
+          storageId,
+          async () => {
+            const data = await fetchAuthShareRaw(
+              serverUrl,
+              params.token,
+              params.providerType,
+              void 0,
+              tenantId
+            );
+            return {
+              currentVersion: data?.shareVersion ?? null,
+              authShare: authShareToString(data?.authShare)
+            };
+          },
+          params.expectedDid,
+          params.didFromPrivateKey,
+          assertActiveUser,
+          recordPromotion(params.expectedDid),
+          async (version) => authShareToString(
+            (await fetchAuthShareRaw(
+              serverUrl,
+              params.token,
+              params.providerType,
+              version,
+              tenantId
+            ))?.authShare
+          )
+        );
+        assertActiveUser();
+        if (resolution.privateKey) {
+          return { privateKey: resolution.privateKey, did: params.expectedDid };
+        }
+        const { currentVersion, authShare: currentAuthShare } = resolution.snapshot;
+        if (currentVersion === null && !currentAuthShare) return null;
+        deviceShare = await storage2.getDeviceShare(storageId);
+        const localVersion = await storage2.getShareVersion(storageId);
+        if (!deviceShare) return null;
+        const candidates = /* @__PURE__ */ new Map();
+        const addCandidate = /* @__PURE__ */ __name((version, authShare) => {
+          if (version !== null && authShare && !candidates.has(version)) {
+            candidates.set(version, authShare);
+          }
+        }, "addCandidate");
+        addCandidate(
+          lastServerSnapshot?.resolvedVersion ?? null,
+          lastServerSnapshot?.authShare ?? null
+        );
+        addCandidate(currentVersion, currentAuthShare);
+        const versionsToTry = /* @__PURE__ */ new Set();
+        if (localVersion !== null) versionsToTry.add(localVersion);
+        if (currentVersion !== null) {
+          for (let version = currentVersion; version >= 1 && version >= currentVersion - MAX_RECONCILIATION_HISTORY; version--) {
+            versionsToTry.add(version);
+          }
+        }
+        for (const version of versionsToTry) {
+          if (candidates.has(version)) continue;
+          const data = await fetchAuthShareRaw(
+            serverUrl,
+            params.token,
+            params.providerType,
+            version,
+            tenantId
+          );
+          addCandidate(version, authShareToString(data?.authShare));
+        }
+        for (const [candidateVersion, authShare] of candidates) {
+          const health = await verifyStoredShares(
+            {
+              getDevice: /* @__PURE__ */ __name(async () => deviceShare, "getDevice"),
+              getAuth: /* @__PURE__ */ __name(async () => authShare, "getAuth")
+            },
+            params.expectedDid,
+            params.didFromPrivateKey
+          );
+          if (!health.healthy) continue;
+          assertActiveUser();
+          const privateKey = await reconstructFromShares([deviceShare, authShare]);
+          if (candidateVersion === currentVersion) {
+            if (localVersion !== currentVersion) {
+              await storage2.storeShareVersion(candidateVersion, storageId);
+            }
+            assertActiveUser();
+            lastServerSnapshot = {
+              currentVersion,
+              resolvedVersion: candidateVersion,
+              authShare,
+              primaryDid: params.expectedDid
+            };
+            return localVersion === currentVersion ? null : { privateKey, did: params.expectedDid };
+          }
+          const result = await persistSharesWithoutLock(
+            privateKey,
+            serverUrl,
+            params.token,
+            params.providerType,
+            params.expectedDid,
+            storage2,
+            storageId,
+            params.didFromPrivateKey,
+            params.signDidAuthVp,
+            tenantId,
+            recordPromotion(params.expectedDid),
+            assertActiveUser
+          );
+          assertActiveUser();
+          lastEmailShare = result.shares.emailShare;
+          lastShareVersion = result.shareVersion;
+          lastServerSnapshot = {
+            currentVersion: result.shareVersion,
+            resolvedVersion: result.shareVersion,
+            authShare: result.shares.authShare,
+            primaryDid: params.expectedDid
+          };
+          return { privateKey, did: params.expectedDid };
+        }
+        return null;
+      });
+    },
     // --- Server communication ---
     async fetchServerKeyStatus(token, providerType) {
-      const localVersion = await storage.getShareVersion(activeStorageId);
+      const storage2 = guardedStorage();
+      const localVersion = await storage2.getShareVersion(activeStorageId);
       const data = await fetchAuthShareRaw(
         serverUrl,
         token,
@@ -19604,7 +21432,7 @@ function createSSSStrategy(config) {
         tenantId
       );
       if (!data) {
-        hasRecoveryEmail = false;
+        lastServerSnapshot = null;
         return {
           exists: false,
           needsMigration: false,
@@ -19612,16 +21440,25 @@ function createSSSStrategy(config) {
           recoveryMethods: [],
           authShare: null,
           shareVersion: null,
-          maskedRecoveryEmail: null
+          maskedRecoveryEmail: null,
+          sssActivationState: null
         };
       }
       const rawAuthShare = data.authShare;
-      const authShareString = typeof rawAuthShare === "object" && rawAuthShare !== null ? rawAuthShare.encryptedData ?? null : typeof rawAuthShare === "string" ? rawAuthShare : null;
+      const authShareString = authShareToString(rawAuthShare);
       const serverVersion = data.shareVersion ?? null;
-      if (serverVersion != null && localVersion == null) {
-        storage.storeShareVersion(serverVersion, activeStorageId).catch((e) => console.warn("SSS: failed to backfill local shareVersion", e));
-      }
-      hasRecoveryEmail = !!data.maskedRecoveryEmail;
+      if (
+        // Version 0 means "no auth share yet" and must never be pinned locally.
+        serverVersion != null && serverVersion > 0 && localVersion == null && !(await readPendingShareCandidates(storage2, activeStorageId)).length
+      ) {
+        storage2.storeShareVersion(serverVersion, activeStorageId).catch((e) => console.warn("SSS: failed to backfill local shareVersion", e));
+      }
+      lastServerSnapshot = {
+        currentVersion: serverVersion,
+        resolvedVersion: authShareString ? localVersion ?? serverVersion : null,
+        authShare: authShareString,
+        primaryDid: data.primaryDid || null
+      };
       return {
         exists: !!rawAuthShare || !!data.keyProvider || !!data.primaryDid,
         needsMigration: data.keyProvider === "web3auth",
@@ -19629,35 +21466,258 @@ function createSSSStrategy(config) {
         recoveryMethods: data.recoveryMethods || [],
         authShare: authShareString,
         shareVersion: serverVersion,
-        maskedRecoveryEmail: data.maskedRecoveryEmail ?? null
+        maskedRecoveryEmail: data.maskedRecoveryEmail ?? null,
+        escrowOptedOut: data.escrowOptedOut === true,
+        escrowPin: data.escrowPin,
+        sssActivationState: data.sssActivationState ?? "active"
       };
     },
     async storeAuthShare(token, providerType, authShare, primaryDid, didAuthVp) {
-      const { shareVersion } = await putAuthShare(
-        serverUrl,
-        token,
-        providerType,
-        authShare,
-        primaryDid,
-        didAuthVp,
-        tenantId
+      const storage2 = guardedStorage();
+      const { shareVersion } = await withRotationLock(
+        () => putAuthShare(
+          serverUrl,
+          token,
+          providerType,
+          authShare,
+          primaryDid,
+          didAuthVp,
+          tenantId
+        )
       );
-      await storage.storeShareVersion(shareVersion, activeStorageId);
+      await storage2.storeShareVersion(shareVersion, activeStorageId);
       lastShareVersion = shareVersion;
     },
-    async markMigrated(token, providerType, didAuthVp) {
-      const response = await fetch(`${serverUrl}/keys/migrate`, {
+    async markMigrated(token, providerType, didAuthVp) {
+      const response = await fetch(`${serverUrl}/keys/migrate`, {
+        method: "POST",
+        headers: buildHeaders(token, didAuthVp, tenantId),
+        body: JSON.stringify({ authToken: token, providerType })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to mark migrated: ${describeHttpStatus(response)}`);
+      }
+    },
+    async activate(token, providerType, didAuthVp) {
+      const response = await fetch(`${serverUrl}/keys/activate`, {
         method: "POST",
         headers: buildHeaders(token, didAuthVp, tenantId),
         body: JSON.stringify({ authToken: token, providerType })
       });
       if (!response.ok) {
-        throw new Error(`Failed to mark migrated: ${response.statusText}`);
+        throw new Error(`Failed to activate SSS key: ${describeHttpStatus(response)}`);
       }
     },
     // --- Recovery execution ---
+    async getEscrowEnrollmentState(params) {
+      if (!config.escrow?.enabled) return { state: "disabled" };
+      const status = await this.fetchServerKeyStatus(params.token, params.providerType);
+      if (status.escrowOptedOut) return { state: "opted-out", escrowPin: status.escrowPin };
+      const state = status.shareVersion !== null && status.recoveryMethods.some(
+        (method) => method.type === "escrow" && method.shareVersion === status.shareVersion && (Boolean(method.confirmedAt) || "confirmationStatus" in method && method.confirmationStatus === "confirmed")
+      ) ? "enrolled" : "not-enrolled";
+      return { state, escrowPin: status.escrowPin };
+    },
+    async disableEscrowRecovery(params) {
+      const status = await this.fetchServerKeyStatus(params.token, params.providerType);
+      if (!status.primaryDid) throw new Error("Cannot disable escrow without a primary DID");
+      const vp = await requestFreshDidAuthVp(
+        serverUrl,
+        params.privateKey,
+        status.primaryDid,
+        params.signDidAuthVp,
+        tenantId
+      );
+      await escrowRequest("", {
+        method: "DELETE",
+        headers: buildHeaders(params.token, vp, tenantId),
+        body: JSON.stringify({
+          authToken: params.token,
+          providerType: params.providerType,
+          optOut: true
+        })
+      });
+    },
+    async enableEscrowRecovery(params) {
+      const storage2 = guardedStorage();
+      return withRotationLock(async () => {
+        if (!config.escrow?.enabled)
+          return { enrolled: false, reason: "disabled" };
+        const status = await this.fetchServerKeyStatus(params.token, params.providerType);
+        if (!status.primaryDid)
+          throw new Error("Cannot enable escrow without a primary DID");
+        const vp = await requestFreshDidAuthVp(
+          serverUrl,
+          params.privateKey,
+          status.primaryDid,
+          params.signDidAuthVp,
+          tenantId
+        );
+        await escrowRequest("/opt-in", {
+          method: "POST",
+          headers: buildHeaders(params.token, vp, tenantId),
+          body: JSON.stringify({
+            authToken: params.token,
+            providerType: params.providerType
+          })
+        });
+        return ensureEscrowEnrollmentUnguarded(this, params, storage2);
+      });
+    },
+    async setEscrowPin({ pin, ...params }) {
+      const storage2 = guardedStorage();
+      const result = await withRotationLock(
+        () => ensureEscrowEnrollmentUnguarded(this, { ...params, options: { pin } }, storage2)
+      );
+      if (!result.enrolled) {
+        throw new Error("Automatic recovery is not available for this account.");
+      }
+    },
+    async clearEscrowPin(params) {
+      const storage2 = guardedStorage();
+      const result = await withRotationLock(
+        () => ensureEscrowEnrollmentUnguarded(this, params, storage2, true)
+      );
+      if (!result.enrolled) {
+        throw new Error("Automatic recovery is not available for this account.");
+      }
+    },
+    /** Enroll missing/stale escrow material using the standard atomic rotation. */
+    async ensureEscrowEnrollment(params) {
+      const storage2 = guardedStorage();
+      if (params.options?.pin !== void 0)
+        return withRotationLock(
+          () => ensureEscrowEnrollmentUnguarded(this, params, storage2)
+        );
+      if (escrowEnrollmentInFlight) return escrowEnrollmentInFlight;
+      escrowEnrollmentInFlight = withRotationLock(
+        () => ensureEscrowEnrollmentUnguarded(this, params, storage2)
+      );
+      try {
+        return await escrowEnrollmentInFlight;
+      } finally {
+        escrowEnrollmentInFlight = void 0;
+      }
+    },
+    /** Start or explicitly restart a hold with fresh client-bound resume secrets. */
+    async startEscrowRecovery(params) {
+      const sessionProof = params.recoverySessionToken !== void 0;
+      if (sessionProof ? params.token !== void 0 || params.providerType !== void 0 : !params.token || !params.providerType) {
+        throw new Error("Provide exactly one identity proof");
+      }
+      const pair = await generateEscrowKeyPair();
+      const result = await escrowRequest(
+        "/recover",
+        {
+          method: "POST",
+          headers: buildHeaders("", void 0, params.tenantId ?? tenantId),
+          body: JSON.stringify({
+            clientEphemeralPublicKey: pair.publicKey,
+            ...params.options?.restart ? { restart: true } : {},
+            ...params.options?.releasePolicy ? { releasePolicy: params.options.releasePolicy } : {},
+            ...sessionProof ? { recoverySessionToken: params.recoverySessionToken } : { authToken: params.token, providerType: params.providerType }
+          })
+        },
+        params.options?.releasePolicy === "pin"
+      );
+      return { ...result, clientEphemeralPrivateKey: pair.privateKey };
+    },
+    /** Read hold status; secrets (auth or resume token) never travel in a URL. */
+    async getEscrowRecoveryStatus(params) {
+      const query = new URLSearchParams(
+        "holdId" in params ? { holdId: params.holdId } : { providerType: params.providerType }
+      );
+      const secret = "holdId" in params ? params.resumeToken : params.token;
+      const result = await escrowRequest(
+        `/status?${query}`,
+        {
+          method: "GET",
+          headers: {
+            ...buildHeaders("", void 0, tenantId),
+            "X-Auth-Token": secret
+          }
+        }
+      );
+      return result.hold;
+    },
+    /** Cancel a pending hold with a fresh DID-owner proof. */
+    async cancelEscrowRecovery(params) {
+      const status = await this.fetchServerKeyStatus(params.token, params.providerType);
+      if (!status.primaryDid) throw new Error("Cannot cancel escrow without a primary DID");
+      const vp = await requestFreshDidAuthVp(
+        serverUrl,
+        params.privateKey,
+        status.primaryDid,
+        params.signDidAuthVp,
+        tenantId
+      );
+      const result = await escrowRequest("/cancel", {
+        method: "POST",
+        headers: buildHeaders(params.token, vp, tenantId),
+        body: JSON.stringify({
+          authToken: params.token,
+          providerType: params.providerType
+        })
+      });
+      return { cancelled: result.cancelled };
+    },
     async executeRecovery(params) {
-      const { token, providerType, input, didFromPrivateKey } = params;
+      const storage2 = guardedStorage();
+      const { token, providerType, input, didFromPrivateKey, signDidAuthVp } = params;
+      if (input.method === "escrow" || input.method === "escrow-pin") {
+        if (!didFromPrivateKey)
+          throw new Error("DID verification is required for escrow recovery");
+        const start = input.method === "escrow-pin" ? await this.startEscrowRecovery({
+          token,
+          providerType,
+          options: { releasePolicy: "pin" }
+        }) : input;
+        let pinProof;
+        if (input.method === "escrow-pin") {
+          if (!("pinSalt" in start) || !start.pinSalt || !start.resumeToken)
+            throw new Error("PIN recovery response is missing required material");
+          pinProof = await derivePinProof(input.pin, start.pinSalt);
+        }
+        const material = await escrowRequest(
+          "/complete",
+          {
+            method: "POST",
+            headers: buildHeaders("", void 0, tenantId),
+            body: JSON.stringify({
+              holdId: start.holdId,
+              resumeToken: start.resumeToken,
+              ...pinProof ? { pinProof } : {}
+            })
+          },
+          input.method === "escrow-pin"
+        );
+        const plaintext = await openEscrowRelease(
+          material.sealedShare,
+          start.clientEphemeralPrivateKey
+        );
+        if (plaintext.holdId !== start.holdId || plaintext.did !== material.primaryDid || plaintext.shareVersion !== material.shareVersion) {
+          throw new Error("Escrow recovery material does not match the request");
+        }
+        const authShare = material.authShare.encryptedData;
+        const privateKey2 = await reconstructFromShares([
+          plaintext.recoveryShare,
+          authShare
+        ]);
+        if (!material.primaryDid || await didFromPrivateKey(privateKey2) !== material.primaryDid) {
+          throw new Error(
+            "Recovery produced an incorrect key. Try another recovery method."
+          );
+        }
+        pendingIdentityRecovery = {
+          privateKey: privateKey2,
+          primaryDid: material.primaryDid,
+          recoveryShare: plaintext.recoveryShare,
+          authShare,
+          rebindSessionToken: material.rebindSessionToken
+        };
+        if (!token) return { privateKey: privateKey2, did: material.primaryDid };
+        return this.completeIdentityRecovery({ token, providerType, signDidAuthVp });
+      }
       let recoveryShare;
       let recoveryShareVersion;
       switch (input.method) {
@@ -19751,14 +21811,61 @@ function createSSSStrategy(config) {
           );
         }
       }
-      await storage.storeDeviceShare(recoveryShare, activeStorageId);
-      const versionToStore = recoveryShareVersion ?? serverData.shareVersion ?? 1;
-      await storage.storeShareVersion(versionToStore, activeStorageId);
+      const { shares, shareVersion } = await persistSharesAtomically(
+        privateKey,
+        serverUrl,
+        token,
+        providerType,
+        primaryDid,
+        storage2,
+        activeStorageId,
+        didFromPrivateKey,
+        signDidAuthVp,
+        tenantId,
+        recordPromotion(primaryDid),
+        captureActiveUserGuard()
+      );
+      lastEmailShare = shares.emailShare;
+      lastShareVersion = shareVersion;
+      lastServerSnapshot = {
+        currentVersion: shareVersion,
+        resolvedVersion: shareVersion,
+        authShare: shares.authShare,
+        primaryDid
+      };
+      await tryEnrollEscrow(
+        token,
+        providerType,
+        privateKey,
+        primaryDid,
+        shares,
+        shareVersion,
+        signDidAuthVp
+      );
       return { privateKey, did: primaryDid };
     },
     // --- Recovery setup ---
     async setupRecoveryMethod(params) {
+      const storage2 = guardedStorage();
       const { token, providerType, privateKey, input, authUser, signDidAuthVp } = params;
+      if (input.method === "escrow" && input.pin !== void 0) {
+        if (!signDidAuthVp)
+          throw new Error("DID proof signing is required for escrow enrollment");
+        const result = await this.enableEscrowRecovery({
+          token,
+          providerType,
+          privateKey,
+          signDidAuthVp,
+          options: { pin: input.pin }
+        });
+        if (!result.enrolled || !result.changed)
+          throw new Error("Escrow enrollment is disabled");
+        return { method: "escrow", shareVersion: result.shareVersion };
+      }
+      if (input.method === "escrow" && !config.escrow?.enabled) {
+        throw new Error("Escrow enrollment is disabled");
+      }
+      const escrowKey = input.method === "escrow" ? await fetchVerifiedEnclaveKey() : void 0;
       let passkeyCredential;
       if (input.method === "passkey") {
         if (!isWebAuthnSupported()) {
@@ -19768,10 +21875,6 @@ function createSSSStrategy(config) {
         const userName = authUser?.email || authUser?.phone || authUser?.id || "";
         passkeyCredential = await createPasskeyCredential(userId, userName);
       }
-      const vpJwt = signDidAuthVp ? await signDidAuthVp(privateKey) : void 0;
-      const { shares } = await splitAndVerify(privateKey);
-      lastEmailShare = shares.emailShare;
-      await storage.storeDeviceShare(shares.deviceShare, activeStorageId);
       const serverData = await fetchAuthShareRaw(
         serverUrl,
         token,
@@ -19780,39 +21883,42 @@ function createSSSStrategy(config) {
         tenantId
       );
       const primaryDid = serverData?.primaryDid || "";
-      const { shareVersion } = await putAuthShare(
+      if (!primaryDid) throw new Error("Cannot set up recovery without a primary DID");
+      const { shares, shareVersion } = await persistSharesAtomically(
+        privateKey,
         serverUrl,
         token,
         providerType,
-        shares.authShare,
         primaryDid,
-        vpJwt,
-        tenantId
+        storage2,
+        activeStorageId,
+        void 0,
+        signDidAuthVp,
+        tenantId,
+        recordPromotion(primaryDid),
+        captureActiveUserGuard()
       );
-      await storage.storeShareVersion(shareVersion, activeStorageId);
-      if (enableEmailBackupShare && input.method !== "email" && lastEmailShare) {
-        const resend = hasRecoveryEmail ? sendEmailShareToRecoveryEmail(
-          serverUrl,
-          token,
-          providerType,
-          lastEmailShare,
-          shareVersion,
-          tenantId
-        ) : authUser?.email ? sendEmailBackupShare(
-          serverUrl,
-          token,
-          providerType,
-          lastEmailShare,
-          authUser.email,
-          shareVersion,
-          tenantId
-        ) : Promise.resolve();
-        resend.catch(
-          (e) => console.warn("Email backup share re-send failed (non-fatal):", e)
-        );
-        lastEmailShare = void 0;
-      }
+      lastEmailShare = shares.emailShare;
+      lastShareVersion = shareVersion;
+      lastServerSnapshot = {
+        currentVersion: shareVersion,
+        resolvedVersion: shareVersion,
+        authShare: shares.authShare,
+        primaryDid
+      };
       switch (input.method) {
+        case "escrow":
+          await enrollEscrow(
+            token,
+            providerType,
+            privateKey,
+            primaryDid,
+            shares,
+            shareVersion,
+            signDidAuthVp,
+            escrowKey
+          );
+          return { method: "escrow", shareVersion };
         case "passkey": {
           const credential = passkeyCredential;
           const encryptedShare = await encryptShareWithPasskey(
@@ -19832,9 +21938,38 @@ function createSSSStrategy(config) {
               credentialId: credential.credentialId,
               shareVersion
             },
-            vpJwt,
+            signDidAuthVp ? await requestFreshDidAuthVp(
+              serverUrl,
+              privateKey,
+              primaryDid,
+              signDidAuthVp,
+              tenantId
+            ) : void 0,
             tenantId
           );
+          await postRecoveryConfirmation(
+            serverUrl,
+            token,
+            providerType,
+            { type: "passkey", credentialId: credential.credentialId },
+            signDidAuthVp ? await requestFreshDidAuthVp(
+              serverUrl,
+              privateKey,
+              primaryDid,
+              signDidAuthVp,
+              tenantId
+            ) : void 0,
+            tenantId
+          );
+          await tryEnrollEscrow(
+            token,
+            providerType,
+            privateKey,
+            primaryDid,
+            shares,
+            shareVersion,
+            signDidAuthVp
+          );
           return { method: "passkey", credentialId: credential.credentialId };
         }
         case "phrase": {
@@ -19847,10 +21982,38 @@ function createSSSStrategy(config) {
               type: "phrase",
               shareVersion
             },
-            vpJwt,
+            signDidAuthVp ? await requestFreshDidAuthVp(
+              serverUrl,
+              privateKey,
+              primaryDid,
+              signDidAuthVp,
+              tenantId
+            ) : void 0,
             tenantId
           );
-          return { method: "phrase", phrase };
+          const challengeWordIndices = selectRecoveryPhraseChallengeIndices(
+            phrase.split(/\s+/).length
+          );
+          const challengeWordOptions = await buildRecoveryPhraseChallengeOptions(
+            phrase,
+            challengeWordIndices
+          );
+          pendingPhraseConfirmation = { phrase, challengeWordIndices };
+          await tryEnrollEscrow(
+            token,
+            providerType,
+            privateKey,
+            primaryDid,
+            shares,
+            shareVersion,
+            signDidAuthVp
+          );
+          return {
+            method: "phrase",
+            phrase,
+            challengeWordIndices,
+            challengeWordOptions
+          };
         }
         case "backup": {
           const encrypted = await encryptWithPassword(
@@ -19862,6 +22025,7 @@ function createSSSStrategy(config) {
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             primaryDid: input.did,
             shareVersion,
+            shareChecksum: await calculateShareChecksum(shares.recoveryShare),
             encryptedShare: {
               ciphertext: encrypted.ciphertext,
               iv: encrypted.iv,
@@ -19877,36 +22041,121 @@ function createSSSStrategy(config) {
               type: "backup",
               shareVersion
             },
-            vpJwt,
+            signDidAuthVp ? await requestFreshDidAuthVp(
+              serverUrl,
+              privateKey,
+              primaryDid,
+              signDidAuthVp,
+              tenantId
+            ) : void 0,
             tenantId
           );
+          pendingBackupConfirmation = {
+            backupFile,
+            recoveryShare: shares.recoveryShare
+          };
+          await tryEnrollEscrow(
+            token,
+            providerType,
+            privateKey,
+            primaryDid,
+            shares,
+            shareVersion,
+            signDidAuthVp
+          );
           return { method: "backup", backupFile };
         }
         case "email": {
-          await sendEmailShareToRecoveryEmail(
+          const didAuthVp = signDidAuthVp ? await requestFreshDidAuthVp(
+            serverUrl,
+            privateKey,
+            primaryDid,
+            signDidAuthVp,
+            tenantId
+          ) : void 0;
+          await sendEmailBackupShare(
             serverUrl,
             token,
             providerType,
             shares.emailShare,
+            input.email,
+            escrowRelayPublicKey,
+            escrowRelayKeyId,
+            emailBranding,
             shareVersion,
+            didAuthVp,
             tenantId
           );
-          await postRecoveryMethod(
-            serverUrl,
+          await tryEnrollEscrow(
             token,
             providerType,
-            {
-              type: "email",
-              shareVersion
-            },
-            vpJwt,
-            tenantId
+            privateKey,
+            primaryDid,
+            shares,
+            shareVersion,
+            signDidAuthVp
           );
-          hasRecoveryEmail = true;
           return { method: "email" };
         }
       }
     },
+    async confirmRecoveryMethod(params) {
+      const { token, providerType, privateKey, input, signDidAuthVp } = params;
+      const primaryDid = lastServerSnapshot?.primaryDid;
+      if (!primaryDid) throw new Error("Cannot confirm recovery without a primary DID");
+      const confirmationBody = { type: input.method };
+      if (input.method === "phrase") {
+        const pending = pendingPhraseConfirmation;
+        if (!pending) throw new Error("Generate a new recovery phrase to continue");
+        const phraseWords = pending.phrase.trim().toLowerCase().split(/\s+/);
+        const matches = input.challengeWords.length === pending.challengeWordIndices.length && pending.challengeWordIndices.every(
+          (wordIndex, answerIndex) => input.challengeWords[answerIndex]?.trim().toLowerCase() === phraseWords[wordIndex]
+        );
+        if (!matches) {
+          throw new Error("Those words do not match. Check your phrase and try again.");
+        }
+      } else if (input.method === "backup") {
+        const pending = pendingBackupConfirmation;
+        if (!pending) throw new Error("Generate a new backup file to continue");
+        let suppliedBackup;
+        let decryptedShare;
+        try {
+          suppliedBackup = JSON.parse(input.fileContents);
+          decryptedShare = await decryptWithPassword(
+            suppliedBackup.encryptedShare.ciphertext,
+            suppliedBackup.encryptedShare.iv,
+            suppliedBackup.encryptedShare.salt,
+            input.password,
+            suppliedBackup.encryptedShare.kdfParams
+          );
+        } catch {
+          throw new Error("Incorrect password or corrupted data. Please try again.");
+        }
+        const checksum = await calculateShareChecksum(decryptedShare);
+        if (suppliedBackup.shareChecksum !== checksum || pending.backupFile.shareChecksum !== checksum || decryptedShare !== pending.recoveryShare) {
+          throw new Error("This backup file could not be verified. Please try again.");
+        }
+      } else {
+        confirmationBody.code = input.code;
+      }
+      const didAuthVp = signDidAuthVp ? await requestFreshDidAuthVp(
+        serverUrl,
+        privateKey,
+        primaryDid,
+        signDidAuthVp,
+        tenantId
+      ) : void 0;
+      await postRecoveryConfirmation(
+        serverUrl,
+        token,
+        providerType,
+        confirmationBody,
+        didAuthVp,
+        tenantId
+      );
+      if (input.method === "phrase") pendingPhraseConfirmation = void 0;
+      if (input.method === "backup") pendingBackupConfirmation = void 0;
+    },
     async getAvailableRecoveryMethods(token, providerType) {
       try {
         const serverData = await fetchAuthShareRaw(
@@ -19917,15 +22166,274 @@ function createSSSStrategy(config) {
           tenantId
         );
         const methods = serverData?.recoveryMethods || [];
-        if (enableEmailBackupShare && !methods.some((m) => m.type === "email")) {
-          methods.push({ type: "email", createdAt: /* @__PURE__ */ new Date() });
-        }
-        return methods;
+        const activationState = serverData?.sssActivationState ?? "active";
+        return methods.filter((method) => {
+          if (method.confirmedAt) return true;
+          if (method.confirmationStatus) return false;
+          return activationState === "active";
+        });
       } catch (e) {
         console.error("Error getting recovery methods:", e);
         return [];
       }
     },
+    async startIdentityRecovery(email) {
+      await postJson(
+        `${serverUrl}/keys/recovery-session/start`,
+        { email },
+        buildHeaders("", void 0, tenantId)
+      );
+    },
+    async verifyIdentityRecovery(email, code) {
+      const result = await postJson(
+        `${serverUrl}/keys/recovery-session/verify`,
+        { email, code },
+        buildHeaders("", void 0, tenantId)
+      );
+      return {
+        ...result,
+        recoveryMethods: result.recoveryMethods.map((method) => ({
+          ...method,
+          createdAt: new Date(method.createdAt)
+        }))
+      };
+    },
+    async prepareIdentityRecovery(params) {
+      const { input } = params;
+      if (input.method === "escrow") {
+        throw new Error("Use executeRecovery to complete an escrow hold");
+      }
+      let recoveryShare;
+      switch (input.method) {
+        case "passkey":
+          break;
+        case "phrase":
+          if (!await validateRecoveryPhrase(input.phrase)) {
+            throw new Error("Invalid recovery phrase");
+          }
+          recoveryShare = await recoveryPhraseToShare(input.phrase);
+          break;
+        case "backup": {
+          const backup = JSON.parse(input.fileContents);
+          if (backup.version !== 1) throw new Error("Unsupported backup file version");
+          recoveryShare = await decryptWithPassword(
+            backup.encryptedShare.ciphertext,
+            backup.encryptedShare.iv,
+            backup.encryptedShare.salt,
+            input.password,
+            backup.encryptedShare.kdfParams
+          );
+          break;
+        }
+        case "email":
+          recoveryShare = parseVersionedEmailShare(input.emailShare.trim()).share;
+          break;
+      }
+      try {
+        const material = await postJson(
+          `${serverUrl}/keys/recovery-session/recover`,
+          {
+            recoverySessionToken: params.recoverySessionToken,
+            type: input.method,
+            ...input.method === "passkey" ? { credentialId: input.credentialId } : {}
+          },
+          buildHeaders("", void 0, tenantId)
+        );
+        if (input.method === "passkey") {
+          if (!material.encryptedShare) {
+            throw new Error("No passkey recovery data found");
+          }
+          recoveryShare = await decryptShareWithPasskey({
+            encryptedData: material.encryptedShare.encryptedData,
+            iv: material.encryptedShare.iv,
+            credentialId: input.credentialId
+          });
+        }
+        if (!recoveryShare) throw new Error("Recovery data was empty");
+        const authShare = material.authShare.encryptedData;
+        let privateKey;
+        try {
+          privateKey = await reconstructFromShares([recoveryShare, authShare]);
+        } catch {
+          throw new Error(
+            "Recovery produced an incorrect key. Try another recovery method."
+          );
+        }
+        const derivedDid = await params.didFromPrivateKey(privateKey);
+        if (!derivedDid || derivedDid !== material.primaryDid) {
+          throw new Error(
+            "Recovery produced an incorrect key. Try another recovery method."
+          );
+        }
+        pendingIdentityRecovery = {
+          privateKey,
+          primaryDid: material.primaryDid,
+          recoveryShare,
+          authShare,
+          rebindSessionToken: material.rebindSessionToken
+        };
+        return { privateKey, did: material.primaryDid };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Identity recovery failed";
+        throw new IdentityRecoverySessionConsumedError(message);
+      }
+    },
+    hasPendingIdentityRecovery() {
+      return Boolean(pendingIdentityRecovery);
+    },
+    cancelIdentityRecovery() {
+      pendingIdentityRecovery = void 0;
+    },
+    async completeIdentityRecovery(params) {
+      const storage2 = guardedStorage();
+      const generation = storageGeneration;
+      const pending = pendingIdentityRecovery;
+      const signDidAuthVp = params.signDidAuthVp;
+      if (!pending) throw new Error("No identity recovery is waiting for a new sign-in");
+      if (!signDidAuthVp) {
+        throw new Error("DID proof signing is required to bind a new sign-in");
+      }
+      const storageId = activeStorageId;
+      const { shares, shareVersion } = await withShareUpdateLock(
+        storage2,
+        storageId,
+        () => withRotationLock(async () => {
+          const assertActive = /* @__PURE__ */ __name(() => {
+            if (activeStorageId !== storageId || pendingIdentityRecovery !== pending || storageGeneration !== generation) {
+              throw new Error("This recovery request was cancelled.");
+            }
+          }, "assertActive");
+          assertActive();
+          const candidates = await readPendingShareCandidates(storage2, storageId);
+          if (pending.rebind && pending.rebind.storageId !== storageId) {
+            throw new Error("Active account changed during identity recovery");
+          }
+          if (candidates.some(
+            (candidate) => candidate.share !== pending.rebind?.shares.deviceShare
+          )) {
+            throw new Error(
+              "Reconcile the pending share update before binding a sign-in"
+            );
+          }
+          let shareVersion2;
+          const retry = pending.rebind?.attempted ?? false;
+          if (retry && pending.rebind) {
+            const current = await fetchAuthShareRaw(
+              serverUrl,
+              params.token,
+              params.providerType,
+              void 0,
+              tenantId
+            );
+            const authShare = authShareToString(current?.authShare);
+            if (authShare && current?.shareVersion != null) {
+              const health = await verifyStoredShares(
+                {
+                  getDevice: /* @__PURE__ */ __name(async () => pending.rebind.shares.deviceShare, "getDevice"),
+                  getAuth: /* @__PURE__ */ __name(async () => authShare, "getAuth")
+                },
+                pending.primaryDid,
+                async (key) => key === pending.privateKey ? pending.primaryDid : ""
+              );
+              if (health.healthy) shareVersion2 = current.shareVersion;
+            }
+          }
+          assertActive();
+          if (shareVersion2 === void 0) {
+            const didAuthVp = await requestFreshDidAuthVp(
+              serverUrl,
+              pending.privateKey,
+              pending.primaryDid,
+              signDidAuthVp,
+              tenantId
+            );
+            assertActive();
+            pending.rebind ??= {
+              shares: (await splitAndVerify(pending.privateKey)).shares,
+              storageId,
+              attempted: false
+            };
+            const rebind = pending.rebind;
+            if (!candidates.some(
+              (candidate) => candidate.share === rebind.shares.deviceShare
+            )) {
+              await addPendingShareCandidate(
+                storage2,
+                { share: rebind.shares.deviceShare, createdAt: Date.now() },
+                storageId
+              );
+            }
+            assertActive();
+            rebind.attempted = true;
+            try {
+              const response = await postJson(
+                `${serverUrl}/keys/recovery-session/rebind`,
+                {
+                  recoverySessionToken: pending.rebindSessionToken,
+                  providerType: params.providerType,
+                  primaryDid: pending.primaryDid,
+                  authShare: {
+                    encryptedData: rebind.shares.authShare,
+                    encryptedDek: "",
+                    iv: ""
+                  }
+                },
+                {
+                  ...buildHeaders("", didAuthVp, tenantId),
+                  "X-Auth-Token": params.token
+                }
+              );
+              shareVersion2 = response.shareVersion;
+            } catch (error) {
+              if (error instanceof ShareWriteRejectedError && !retry) {
+                await removePendingShareCandidate(
+                  storage2,
+                  rebind.shares.deviceShare,
+                  storageId
+                );
+                pending.rebind = void 0;
+              }
+              throw error;
+            }
+          }
+          if (shareVersion2 === void 0 || !pending.rebind) {
+            throw new Error("Server did not confirm the new share");
+          }
+          assertActive();
+          const shares2 = pending.rebind.shares;
+          await storage2.storeDeviceShare(shares2.deviceShare, storageId);
+          await storage2.storeShareVersion(shareVersion2, storageId);
+          await clearPendingShareCandidates(storage2, storageId);
+          assertActive();
+          lastEmailShare = shares2.emailShare;
+          lastShareVersion = shareVersion2;
+          lastServerSnapshot = {
+            currentVersion: shareVersion2,
+            resolvedVersion: shareVersion2,
+            authShare: shares2.authShare,
+            primaryDid: pending.primaryDid
+          };
+          pendingIdentityRecovery = void 0;
+          return { shares: shares2, shareVersion: shareVersion2 };
+        })
+      );
+      await tryEnrollEscrow(
+        params.token,
+        params.providerType,
+        pending.privateKey,
+        pending.primaryDid,
+        shares,
+        shareVersion,
+        signDidAuthVp,
+        void 0,
+        void 0,
+        true
+      );
+      if (activeStorageId !== storageId || storageGeneration !== generation) {
+        throw new Error("This recovery request was cancelled.");
+      }
+      return { privateKey: pending.privateKey, did: pending.primaryDid };
+    },
     // --- Contact method management ---
     async upgradeContactMethod(token, providerType, previousPhone, email, code) {
       const res = await fetch(`${serverUrl}/keys/upgrade-contact-method`, {
@@ -19948,7 +22456,7 @@ function createSSSStrategy(config) {
       return { customToken: data?.customToken };
     },
     // --- Email backup ---
-    async sendEmailBackupShare(token, providerType, _privateKey, email) {
+    async sendEmailBackupShare(token, providerType, _privateKey, email, didAuthVp) {
       if (!enableEmailBackupShare) return;
       if (!lastEmailShare) {
         console.warn(
@@ -19956,29 +22464,22 @@ function createSSSStrategy(config) {
         );
         return;
       }
-      if (hasRecoveryEmail) {
-        await sendEmailShareToRecoveryEmail(
-          serverUrl,
-          token,
-          providerType,
-          lastEmailShare,
-          lastShareVersion,
-          tenantId
-        );
-      } else {
-        if (!email) {
-          console.warn("Cannot send email backup share: no email address");
-          return;
-        }
+      if (email) {
         await sendEmailBackupShare(
           serverUrl,
           token,
           providerType,
           lastEmailShare,
           email,
+          escrowRelayPublicKey,
+          escrowRelayKeyId,
+          emailBranding,
           lastShareVersion,
+          didAuthVp,
           tenantId
         );
+      } else {
+        throw new Error("Enter a recovery email before sending a recovery key");
       }
       lastEmailShare = void 0;
       lastShareVersion = void 0;
@@ -19995,6 +22496,8 @@ function createSSSStrategy(config) {
       return [SSS_DB_NAME];
     },
     async cleanup() {
+      storageGeneration++;
+      await Promise.allSettled(localWrites);
     }
   };
 }
@@ -20087,13 +22590,7 @@ var decryptShareFromTransfer = /* @__PURE__ */ __name(async (payload, recipientP
 }, "decryptShareFromTransfer");
 
 // src/qr-login.ts
-var buildHeaders2 = /* @__PURE__ */ __name((token) => {
-  const headers = { "Content-Type": "application/json" };
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  return headers;
-}, "buildHeaders");
+var buildHeaders2 = /* @__PURE__ */ __name(() => ({ "Content-Type": "application/json" }), "buildHeaders");
 var createQrLoginSession = /* @__PURE__ */ __name(async (config) => {
   const ephemeralKeypair = await generateEphemeralKeypair();
   const response = await fetch(`${config.serverUrl}/qr-login/session`, {
@@ -20161,10 +22658,14 @@ var pollUntilApproved = /* @__PURE__ */ __name(async (config, sessionId, ephemer
     await new Promise((resolve, reject) => {
       const timer = setTimeout(resolve, intervalMs);
       if (options?.signal) {
-        options.signal.addEventListener("abort", () => {
-          clearTimeout(timer);
-          reject(new Error("QR login polling aborted"));
-        }, { once: true });
+        options.signal.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timer);
+            reject(new Error("QR login polling aborted"));
+          },
+          { once: true }
+        );
       }
     });
   }
@@ -20216,43 +22717,68 @@ var notifyDevicesForQrSession = /* @__PURE__ */ __name(async (config, sessionId,
     return { sent: false, deviceCount: 0 };
   }
 }, "notifyDevicesForQrSession");
-
-// src/types.ts
-var import_types = __toESM(require_dist());
 var export_AuthSessionError = import_types.AuthSessionError;
 export {
   AtomicUpdateError,
   export_AuthSessionError as AuthSessionError,
   DEFAULT_KDF_PARAMS,
+  EMAIL_RELAY_ALGORITHM,
+  EMAIL_RELAY_ENVELOPE_VERSION,
+  ESCROW_ALGORITHM,
+  ESCROW_BLOB_INFO,
+  ESCROW_CLIENT_KEY_ID,
+  ESCROW_ENVELOPE_VERSION,
+  ESCROW_PIN_MAX_ATTEMPTS,
+  ESCROW_RELEASE_INFO,
+  EscrowHoldRestartThrottledError,
+  EscrowPinLockedError,
+  EscrowPinMismatchError,
+  EscrowPinThrottledError,
+  EscrowPinUnavailableError,
+  EscrowRequestError,
+  IdentityRecoverySessionConsumedError,
+  PIN_MAX_LENGTH,
+  PIN_MIN_LENGTH,
   SSSApiClient,
   SSSKeyManager,
   SSS_THRESHOLD,
   SSS_TOTAL_SHARES,
   ShareVerificationError,
+  ShareWriteRejectedError,
   approveQrLoginSession,
   atomicRecovery,
   atomicShareUpdate,
   base64ToBuffer,
   bufferToBase64,
+  buildRecoveryPhraseChallengeOptions,
   bytesToHex,
   clearAllShares,
+  constantTimeEqualHex,
   countWords,
   createAdaptiveStorage,
   createPasskeyCredential,
   createQrLoginSession,
   createSSSKeyManager,
   createSSSStrategy,
+  decryptEmailRelayPayload,
+  decryptEscrowBlob,
   decryptShareFromTransfer,
   decryptShareWithPasskey,
   decryptWithPassword,
   deleteDeviceShare,
   deriveKeyFromPasskey,
   deriveKeyFromPassword,
+  derivePinProof,
+  encryptEmailRelayPayload,
+  encryptEscrowBlob,
   encryptShareForTransfer,
   encryptShareWithPasskey,
   encryptWithPassword,
   generateEd25519PrivateKey,
+  generateEmailRelayConfirmationCode,
   generateEphemeralKeypair,
+  generateEscrowKeyPair,
+  generatePinSalt,
   generateRecoveryPhrase,
   getDeviceShare,
   getQrLoginSessionInfo,
@@ -20263,18 +22789,28 @@ export {
   isPublicComputerMode,
   isWebAuthnSupported,
   listAllDeviceShares,
+  normalizePin,
   notifyDevicesForQrSession,
+  openEscrowRelease,
+  parseEmailRelayEnvelope,
+  parseEmailRelayPlaintext,
+  parseEscrowBlobPlaintext,
+  parseEscrowEnvelope,
+  parseEscrowReleasePlaintext,
   pollQrLoginSession,
   pollUntilApproved,
   reconstructFromShares,
   reconstructPrivateKey,
   recoveryPhraseToShare,
+  sealEscrowRelease,
   setPublicComputerMode,
   shareToRecoveryPhrase,
   splitAndVerify,
   splitPrivateKey,
   storeDeviceShare,
   storeShareVersion,
+  validatePin,
   validateRecoveryPhrase,
+  verifyEnclaveAttestation,
   verifyStoredShares
 };