on-zero 0.16.19 → 0.16.20

package/dist/esm/helpers/recoverZeroClient.native.js

@@ -1,3 +1,4 @@
+import { globalValue } from "./globalValue.native.js";
 function _instanceof(left, right) {
   "@swc/helpers - instanceof";
 
@@ -12,18 +13,45 @@ function _type_of(obj) {
 }
 var RECOVER_GUARD_MS = 6e4;
 var RELOAD_LATCH_TIMEOUT_MS = 15e3;
+var GROUP_TRANSITION_REASONS = /* @__PURE__ */new Set(["NewClientGroup", "VersionNotSupported", "SchemaVersionNotSupported"]);
 var LOCAL_STORE_LOST = "Expected IndexedDB not found";
 var SQLITE_ERROR_NAME = "SqliteError";
 var SQLITE_STATEMENT_FINALIZED = "This statement has been finalized";
 var STORE_CLOSED = "Store is closed";
 var STORE_CLOSED_REPEAT_MIN_MS = 2e3;
 var STORE_CLOSED_REPEAT_MAX_MS = 6e4;
-var reloadScheduled = false;
-var reloadInProgress = false;
-var reloadLatchTimer;
-var pendingDeletes = [];
-var pendingInPlaceRecoveries = [];
-var inMemoryGuard = /* @__PURE__ */new Map();
+function sharedRecoveryState() {
+  return globalValue("on-zero:recovery-shared", function () {
+    return {
+      reloadScheduled: false,
+      reloadInProgress: false,
+      reloadLatchTimer: void 0,
+      pendingDeletes: [],
+      pendingInPlaceRecoveries: [],
+      inMemoryGuard: /* @__PURE__ */new Map(),
+      constructionSeq: 0,
+      constructionSeqByDeps: /* @__PURE__ */new WeakMap(),
+      groupByDeps: /* @__PURE__ */new WeakMap(),
+      transitions: /* @__PURE__ */new Map(),
+      terminalMemory: /* @__PURE__ */new Map(),
+      terminalEmitted: /* @__PURE__ */new Map(),
+      unknownPostSignals: /* @__PURE__ */new Map(),
+      lastStoreClosedAtMs: 0
+    };
+  });
+}
+function documentScope() {
+  try {
+    var _ref;
+    var _globalThis_location;
+    return (_ref = (_globalThis_location = globalThis.location) === null || _globalThis_location === void 0 ? void 0 : _globalThis_location.href) !== null && _ref !== void 0 ? _ref : "";
+  } catch (unused) {
+    return "";
+  }
+}
+function guardStorageKey(reasonKey) {
+  return `on-zero-recover-${documentScope()}-${reasonKey}`;
+}
 function defaultGuardStorage() {
   try {
     if (typeof window === "undefined" || !window.sessionStorage) return void 0;
@@ -33,16 +61,10 @@ function defaultGuardStorage() {
   }
 }
 function recoveryGuardOpen(reasonKey, guardStorage) {
-  var _inMemoryGuard_get;
-  var documentScope = "";
-  try {
-    var _ref;
-    var _globalThis_location;
-    documentScope = (_ref = (_globalThis_location = globalThis.location) === null || _globalThis_location === void 0 ? void 0 : _globalThis_location.href) !== null && _ref !== void 0 ? _ref : "";
-  } catch (unused) {}
-  var key = `on-zero-recover-${documentScope}-${reasonKey}`;
+  var _sharedRecoveryState_inMemoryGuard_get;
+  var key = guardStorageKey(reasonKey);
   var now = Date.now();
-  var memLast = (_inMemoryGuard_get = inMemoryGuard.get(key)) !== null && _inMemoryGuard_get !== void 0 ? _inMemoryGuard_get : 0;
+  var memLast = (_sharedRecoveryState_inMemoryGuard_get = sharedRecoveryState().inMemoryGuard.get(key)) !== null && _sharedRecoveryState_inMemoryGuard_get !== void 0 ? _sharedRecoveryState_inMemoryGuard_get : 0;
   if (memLast > 0 && now - memLast < RECOVER_GUARD_MS) return false;
   var storage = guardStorage !== null && guardStorage !== void 0 ? guardStorage : defaultGuardStorage();
   if (storage) {
@@ -53,31 +75,503 @@ function recoveryGuardOpen(reasonKey, guardStorage) {
       storage.setItem(key, String(now));
     } catch (unused) {}
   }
-  inMemoryGuard.set(key, now);
+  sharedRecoveryState().inMemoryGuard.set(key, now);
   return true;
 }
-var lastStoreClosedAtMs = 0;
+function readRecoveryMarker(reasonKey, guardStorage) {
+  var storage = guardStorage !== null && guardStorage !== void 0 ? guardStorage : defaultGuardStorage();
+  if (!storage) return null;
+  var raw = null;
+  try {
+    raw = storage.getItem(guardStorageKey(reasonKey));
+  } catch (unused) {
+    return null;
+  }
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) return {
+    t: Number(raw)
+  };
+  try {
+    var parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.t !== "number") return null;
+    return parsed;
+  } catch (unused) {
+    return null;
+  }
+}
+function writeRecoveryMarker(reasonKey, marker, guardStorage) {
+  var storage = guardStorage !== null && guardStorage !== void 0 ? guardStorage : defaultGuardStorage();
+  if (!storage) return;
+  try {
+    storage.setItem(guardStorageKey(reasonKey), JSON.stringify(marker));
+  } catch (unused) {}
+}
+function clearRecoveryMarker(reasonKey, guardStorage) {
+  var storage = guardStorage !== null && guardStorage !== void 0 ? guardStorage : defaultGuardStorage();
+  if (!storage) return;
+  try {
+    if (typeof storage.removeItem === "function") {
+      storage.removeItem(guardStorageKey(reasonKey));
+    } else {
+      storage.setItem(guardStorageKey(reasonKey), JSON.stringify({
+        t: 0
+      }));
+    }
+  } catch (unused) {}
+}
 function armReloadLatchTimeout() {
+  var shared = sharedRecoveryState();
   if (typeof setTimeout !== "function") return;
-  if (reloadLatchTimer) clearTimeout(reloadLatchTimer);
-  reloadLatchTimer = setTimeout(function () {
-    reloadLatchTimer = void 0;
-    reloadScheduled = false;
+  if (shared.reloadLatchTimer) clearTimeout(shared.reloadLatchTimer);
+  shared.reloadLatchTimer = setTimeout(function () {
+    shared.reloadLatchTimer = void 0;
+    shared.reloadScheduled = false;
   }, RELOAD_LATCH_TIMEOUT_MS);
-  if (reloadLatchTimer && (typeof reloadLatchTimer === "undefined" ? "undefined" : _type_of(reloadLatchTimer)) === "object" && "unref" in reloadLatchTimer) {
-    reloadLatchTimer.unref();
+  if (shared.reloadLatchTimer && _type_of(shared.reloadLatchTimer) === "object" && "unref" in shared.reloadLatchTimer) {
+    shared.reloadLatchTimer.unref();
   }
 }
 function disarmReloadLatchTimeout() {
-  if (reloadLatchTimer) {
-    clearTimeout(reloadLatchTimer);
-    reloadLatchTimer = void 0;
+  var shared = sharedRecoveryState();
+  if (shared.reloadLatchTimer) {
+    clearTimeout(shared.reloadLatchTimer);
+    shared.reloadLatchTimer = void 0;
+  }
+}
+function pushGlobalDelete(deps) {
+  var shared = sharedRecoveryState();
+  if (shared.pendingDeletes.some(function (entry) {
+    return entry.owner === deps.deleteLocalState;
+  })) {
+    return;
+  }
+  shared.pendingDeletes.push({
+    owner: deps.deleteLocalState,
+    run: function run() {
+      return Promise.resolve().then(deps.deleteLocalState);
+    }
+  });
+}
+function removeGlobalDelete(owner) {
+  var pending = sharedRecoveryState().pendingDeletes;
+  var index = pending.findIndex(function (entry) {
+    return entry.owner === owner;
+  });
+  if (index !== -1) pending.splice(index, 1);
+}
+function removeGlobalRemint(fn) {
+  if (!fn) return;
+  var pending = sharedRecoveryState().pendingInPlaceRecoveries;
+  var index = pending.indexOf(fn);
+  if (index !== -1) pending.splice(index, 1);
+}
+function seqOf(deps) {
+  var shared = sharedRecoveryState();
+  var seq = shared.constructionSeqByDeps.get(deps);
+  if (seq === void 0) {
+    seq = ++shared.constructionSeq;
+    shared.constructionSeqByDeps.set(deps, seq);
+  }
+  return seq;
+}
+function refreshGroupCache(deps) {
+  if (!deps.getGroupID) return;
+  var result;
+  try {
+    result = deps.getGroupID();
+  } catch (unused) {
+    return;
+  }
+  if (typeof result === "string") {
+    if (result) sharedRecoveryState().groupByDeps.set(deps, result);
+    return;
   }
+  void Promise.resolve(result).then(function (id) {
+    if (typeof id === "string" && id) sharedRecoveryState().groupByDeps.set(deps, id);
+  }, function () {});
+}
+function cachedGroupID(deps) {
+  return sharedRecoveryState().groupByDeps.get(deps);
+}
+function primeGroupCache(deps) {
+  refreshGroupCache(deps);
+}
+function participantKey(deps) {
+  var _deps_recoverInPlace;
+  return (_deps_recoverInPlace = deps.recoverInPlace) !== null && _deps_recoverInPlace !== void 0 ? _deps_recoverInPlace : deps.deleteLocalState;
+}
+function transitionKey(deps) {
+  var _deps_clientIdentity;
+  return `${documentScope()}\0${(_deps_clientIdentity = deps.clientIdentity) !== null && _deps_clientIdentity !== void 0 ? _deps_clientIdentity : ""}`;
+}
+function findOpenTransitionParticipant(deps) {
+  var transition = sharedRecoveryState().transitions.get(transitionKey(deps));
+  if (!transition || transition.settled) return void 0;
+  if (seqOf(deps) > transition.startSeq) return void 0;
+  return transition.participants.get(participantKey(deps));
+}
+function isGroupTransitionOpen() {
+  return sharedRecoveryState().transitions.size > 0;
+}
+function terminalKey(key, reasonKey) {
+  return `${key}\0${reasonKey}`;
+}
+function stampTerminal(key, reasonKey, guardStorage, message, groups) {
+  sharedRecoveryState().terminalMemory.set(terminalKey(key, reasonKey), {
+    t: Date.now(),
+    groups
+  });
+  writeRecoveryMarker(reasonKey, {
+    t: Date.now(),
+    terminal: true,
+    groups,
+    msg: message
+  }, guardStorage);
+}
+function emitTerminalOnce(deps, key, reasonKey, message) {
+  var _shared_terminalEmitted_get;
+  var shared = sharedRecoveryState();
+  var now = Date.now();
+  var emitKey = terminalKey(key, reasonKey);
+  var lastEmitted = (_shared_terminalEmitted_get = shared.terminalEmitted.get(emitKey)) !== null && _shared_terminalEmitted_get !== void 0 ? _shared_terminalEmitted_get : 0;
+  if (lastEmitted > 0 && now - lastEmitted < RECOVER_GUARD_MS) return;
+  shared.terminalEmitted.set(emitKey, now);
+  try {
+    console.error(`[on-zero] ${message}`);
+    deps.zeroEvents.emit({
+      type: "fatal",
+      reasonKey,
+      reason: message
+    });
+  } catch (unused) {}
+  try {
+    var _globalThis_dispatchEvent, _globalThis;
+    (_globalThis_dispatchEvent = (_globalThis = globalThis).dispatchEvent) === null || _globalThis_dispatchEvent === void 0 ? void 0 : _globalThis_dispatchEvent.call(_globalThis, new CustomEvent("on-zero-fatal", {
+      detail: {
+        reasonKey,
+        reason: message
+      }
+    }));
+  } catch (unused) {}
+}
+function settleTransition(transition, outcome) {
+  if (transition.settled) return;
+  transition.settled = true;
+  transition.outcome = outcome;
+  sharedRecoveryState().transitions.delete(transition.key);
+  transition.notifySettled();
+}
+function checkTransitionComplete(transition) {
+  if (transition.settled) return;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = transition.participants.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var participant = _step.value;
+      if (!participant.reminted && !participant.skipped) return;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  if (transition.pendingWaits > 0) return;
+  settleTransition(transition, "completed");
+}
+function failTransition(transition, input) {
+  if (transition.settled) return;
+  var groups = [...new Set([...transition.participants.values()].map(function (participant) {
+    return participant.oldGroupID;
+  }).filter(function (group) {
+    return typeof group === "string";
+  }))];
+  settleTransition(transition, "terminal");
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = (/* @__PURE__ */new Set([...transition.reasons, input.reasonKey]))[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var reasonKey = _step.value;
+      stampTerminal(transition.key, reasonKey, input.signalDeps.guardStorage, input.message, groups);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  emitTerminalOnce(input.signalDeps, transition.key, input.reasonKey, input.message);
+}
+function makeWrappedRemint(transition, participant) {
+  return async function () {
+    if (participant.skipped || participant.reminted) return true;
+    var remint = participant.deps.recoverInPlace;
+    if (!remint) {
+      participant.skipped = true;
+      checkTransitionComplete(transition);
+      return false;
+    }
+    var ok;
+    try {
+      ok = await remint();
+    } catch (error) {
+      var [firstReason] = transition.reasons;
+      failTransition(transition, {
+        reasonKey: firstReason !== null && firstReason !== void 0 ? firstReason : "NewClientGroup",
+        message: `in-place recovery threw (${_instanceof(error, Error) ? error.message : String(error)})`,
+        signalDeps: participant.deps
+      });
+      return false;
+    }
+    if (!ok) {
+      participant.skipped = true;
+      checkTransitionComplete(transition);
+      return false;
+    }
+    participant.reminted = true;
+    var awaitReconnected = participant.deps.awaitReconnected;
+    if (awaitReconnected) {
+      transition.pendingWaits += 1;
+      try {
+        await Promise.race([awaitReconnected(), transition.settledPromise]);
+      } catch (unused) {} finally {
+        transition.pendingWaits -= 1;
+      }
+    }
+    checkTransitionComplete(transition);
+    return true;
+  };
+}
+async function runParticipantImmediate(transition, participant) {
+  var doDelete = participant.dropLocalState && !participant.deleteExecuted;
+  var doRemint = !participant.remintExecuted;
+  participant.deleteExecuted = true;
+  participant.remintExecuted = true;
+  if (doDelete) {
+    try {
+      await participant.deps.deleteLocalState();
+    } catch (unused) {}
+  }
+  if (doRemint) {
+    if (participant.wrappedRemint) await participant.wrappedRemint();else {
+      participant.skipped = true;
+      checkTransitionComplete(transition);
+    }
+  }
+}
+function joinTransition(transition, deps, reasonKey, dropLocalState) {
+  transition.reasons.add(reasonKey);
+  var key = participantKey(deps);
+  var existing = transition.participants.get(key);
+  if (existing) {
+    if (dropLocalState && !existing.dropLocalState) {
+      existing.dropLocalState = true;
+      if (existing.deleteExecuted) pushGlobalDelete(deps);
+    }
+    return;
+  }
+  removeGlobalDelete(deps.deleteLocalState);
+  removeGlobalRemint(deps.recoverInPlace);
+  var participant = {
+    deps,
+    dropLocalState,
+    deleteExecuted: false,
+    remintExecuted: false,
+    reminted: false,
+    skipped: false,
+    oldGroupID: cachedGroupID(deps),
+    wrappedRemint: null
+  };
+  participant.wrappedRemint = makeWrappedRemint(transition, participant);
+  transition.participants.set(key, participant);
+  if (transition.remintsExecuted) void runParticipantImmediate(transition, participant);
+}
+function startTransition(deps, reasonKey, message, dropLocalState) {
+  var shared = sharedRecoveryState();
+  var key = transitionKey(deps);
+  var notifySettled;
+  var settledPromise = new Promise(function (resolve) {
+    notifySettled = resolve;
+  });
+  var transition = {
+    key,
+    reasons: /* @__PURE__ */new Set([reasonKey]),
+    participants: /* @__PURE__ */new Map(),
+    startSeq: shared.constructionSeq,
+    startedAtMs: Date.now(),
+    remintsExecuted: false,
+    pendingWaits: 0,
+    settled: false,
+    outcome: null,
+    settledPromise,
+    notifySettled
+  };
+  shared.transitions.set(key, transition);
+  joinTransition(transition, deps, reasonKey, dropLocalState);
+  console.warn(`[on-zero] ${message} \u2014 recovering`);
+  deps.zeroEvents.emit({
+    type: "recovering",
+    reasonKey,
+    reason: message
+  });
+  if (shared.reloadScheduled && !shared.reloadInProgress) return;
+  if (shared.reloadInProgress) {
+    transition.remintsExecuted = true;
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = transition.participants.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var participant = _step.value;
+        void runParticipantImmediate(transition, participant);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return;
+  }
+  shared.reloadScheduled = true;
+  armReloadLatchTimeout();
+  var runReload = function runReload2() {
+    return performReload(deps);
+  };
+  if (deps.scheduleReload) {
+    deps.scheduleReload({
+      reason: message,
+      reasonKey,
+      dropLocalState,
+      performReload: runReload
+    });
+  } else {
+    void runReload();
+  }
+}
+function checkTransitionGuard(deps, reasonKey) {
+  var shared = sharedRecoveryState();
+  var key = transitionKey(deps);
+  var now = Date.now();
+  var myGroup = cachedGroupID(deps);
+  var memory = shared.terminalMemory.get(terminalKey(key, reasonKey));
+  if (memory && memory.t > 0 && now - memory.t < RECOVER_GUARD_MS) {
+    if (myGroup !== void 0 && memory.groups.length > 0 && !memory.groups.includes(myGroup)) {
+      shared.terminalMemory.delete(terminalKey(key, reasonKey));
+    } else {
+      return "silent";
+    }
+  }
+  var marker = readRecoveryMarker(reasonKey, deps.guardStorage);
+  if (marker && marker.t > 0 && now - marker.t < RECOVER_GUARD_MS) {
+    var markerGroups = marker.groups && marker.groups.length > 0 ? marker.groups : void 0;
+    if (myGroup !== void 0 && markerGroups !== void 0 && !markerGroups.includes(myGroup)) {
+      clearRecoveryMarker(reasonKey, deps.guardStorage);
+      return "allow";
+    }
+    if (marker.terminal) {
+      var _marker_msg;
+      emitTerminalOnce(deps, key, reasonKey, (_marker_msg = marker.msg) !== null && _marker_msg !== void 0 ? _marker_msg : `update needed (${reasonKey}) \u2014 recovery already failed, not retrying`);
+      return "silent";
+    }
+    if (myGroup !== void 0 && markerGroups !== void 0 && markerGroups.includes(myGroup)) {
+      var message = `update needed (${reasonKey}) \u2014 client group ${myGroup} \u2192 ${myGroup} (unchanged after reload), not reloading`;
+      stampTerminal(key, reasonKey, deps.guardStorage, message, markerGroups);
+      emitTerminalOnce(deps, key, reasonKey, message);
+      return "silent";
+    }
+    var message1 = `update needed (${reasonKey}) \u2014 already recovered once, not reloading`;
+    stampTerminal(key, reasonKey, deps.guardStorage, message1, markerGroups !== null && markerGroups !== void 0 ? markerGroups : []);
+    emitTerminalOnce(deps, key, reasonKey, message1);
+    return "silent";
+  }
+  return "allow";
+}
+function handlePostTransitionSignal(transition, deps, reasonKey, message, dropLocalState) {
+  var _ref, _ref1;
+  var shared = sharedRecoveryState();
+  var newGroup = cachedGroupID(deps);
+  var oldGroups = [...new Set([...transition.participants.values()].map(function (participant) {
+    return participant.oldGroupID;
+  }).filter(function (group) {
+    return typeof group === "string";
+  }))];
+  if (newGroup !== void 0 && oldGroups.length > 0) {
+    if (!oldGroups.includes(newGroup)) {
+      settleTransition(transition, "superseded");
+      startTransition(deps, reasonKey, message, dropLocalState);
+      return;
+    }
+    failTransition(transition, {
+      reasonKey,
+      message: `${message} \u2014 client group ${newGroup} did not change after recovery (still ${oldGroups.join(", ")}), not retrying`,
+      signalDeps: deps
+    });
+    return;
+  }
+  var now = Date.now();
+  var budget = shared.unknownPostSignals.get(transition.key);
+  var freshBudget = budget && now - budget.windowStartMs < RECOVER_GUARD_MS ? budget : null;
+  if (freshBudget && freshBudget.count >= 1) {
+    failTransition(transition, {
+      reasonKey,
+      message: `${message} \u2014 recovery did not resolve the client group, not retrying`,
+      signalDeps: deps
+    });
+    return;
+  }
+  shared.unknownPostSignals.set(transition.key, {
+    count: ((_ref = freshBudget === null || freshBudget === void 0 ? void 0 : freshBudget.count) !== null && _ref !== void 0 ? _ref : 0) + 1,
+    windowStartMs: (_ref1 = freshBudget === null || freshBudget === void 0 ? void 0 : freshBudget.windowStartMs) !== null && _ref1 !== void 0 ? _ref1 : now
+  });
+  settleTransition(transition, "superseded");
+  startTransition(deps, reasonKey, message, dropLocalState);
+}
+function recoverViaGroupTransition(deps, reasonKey, message, dropLocalState) {
+  var key = transitionKey(deps);
+  var open = sharedRecoveryState().transitions.get(key);
+  if (open && !open.settled) {
+    if (seqOf(deps) > open.startSeq) {
+      handlePostTransitionSignal(open, deps, reasonKey, message, dropLocalState);
+      return;
+    }
+    joinTransition(open, deps, reasonKey, dropLocalState);
+    return;
+  }
+  if (checkTransitionGuard(deps, reasonKey) !== "allow") return;
+  startTransition(deps, reasonKey, message, dropLocalState);
 }
 function performReload(deps) {
   var _deps_reload;
-  if (reloadInProgress) return Promise.resolve();
-  reloadInProgress = true;
+  var shared = sharedRecoveryState();
+  if (shared.reloadInProgress) return Promise.resolve();
+  shared.reloadInProgress = true;
   disarmReloadLatchTimeout();
   var doReload = (_deps_reload = deps.reload) !== null && _deps_reload !== void 0 ? _deps_reload : function () {
     var _globalThis_location;
@@ -86,23 +580,116 @@ function performReload(deps) {
     reload.call(globalThis.location);
     return true;
   };
-  var inPlaceRecoveries = [];
+  var globalDeletes = [];
+  var globalRemints = [];
+  var openTransitions = [];
+  var transitionDeletes = [];
+  var transitionRemints = [];
   return Promise.resolve().then(function () {
-    inPlaceRecoveries = pendingInPlaceRecoveries.splice(0);
-    return Promise.allSettled(pendingDeletes.splice(0).map(function (run) {
+    globalDeletes = shared.pendingDeletes.splice(0);
+    globalRemints = shared.pendingInPlaceRecoveries.splice(0);
+    openTransitions = [...shared.transitions.values()].filter(function (transition2) {
+      return !transition2.settled;
+    });
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = openTransitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var transition = _step.value;
+        transition.remintsExecuted = true;
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          var _loop = function () {
+            var participant = _step1.value;
+            if (participant.dropLocalState && !participant.deleteExecuted) {
+              participant.deleteExecuted = true;
+              var runDelete = participant.deps.deleteLocalState;
+              transitionDeletes.push(function () {
+                return Promise.resolve().then(runDelete);
+              });
+            }
+            if (!participant.remintExecuted) {
+              participant.remintExecuted = true;
+              if (participant.wrappedRemint) {
+                transitionRemints.push({
+                  transition,
+                  run: participant.wrappedRemint
+                });
+              } else {
+                participant.skipped = true;
+                checkTransitionComplete(transition);
+              }
+            }
+          };
+          for (var _iterator1 = transition.participants.values()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) _loop();
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return Promise.allSettled([...globalDeletes.map(function (entry) {
+      return entry.run();
+    }), ...transitionDeletes.map(function (run) {
       return run();
-    }));
+    })]);
   }).then(function () {
     var _deps_beforeReload;
     return (_deps_beforeReload = deps.beforeReload) === null || _deps_beforeReload === void 0 ? void 0 : _deps_beforeReload.call(deps);
   }).catch(function () {}).then(async function () {
-    var reloadStarted = doReload();
-    if (reloadStarted !== false) return;
+    var reloadStarted = false;
     try {
-      var results = await Promise.all(inPlaceRecoveries.map(function (recover2) {
+      reloadStarted = doReload();
+    } catch (unused) {
+      reloadStarted = false;
+    }
+    if (reloadStarted !== false) {
+      noteTransitionsReloading(openTransitions);
+      return;
+    }
+    try {
+      var liveRemints = transitionRemints.filter(function (param) {
+        var {
+          transition
+        } = param;
+        return !transition.settled;
+      });
+      var results = await Promise.all([...globalRemints.map(function (recover2) {
         return recover2();
-      }));
-      if (inPlaceRecoveries.length > 0 && results.some(function (recovered) {
+      }), ...liveRemints.map(function (param) {
+        var {
+          run
+        } = param;
+        return run();
+      })]);
+      var globalResults = results.slice(0, globalRemints.length);
+      if (globalRemints.length > 0 && globalResults.some(function (recovered) {
         return !recovered;
       })) {
         console.error("[on-zero] recovery could not reload or reconstruct the client");
@@ -110,24 +697,90 @@ function performReload(deps) {
     } catch (error) {
       console.error("[on-zero] in-place recovery failed", error);
     } finally {
-      reloadInProgress = false;
-      reloadScheduled = false;
+      shared.reloadInProgress = false;
+      shared.reloadScheduled = false;
     }
   });
 }
+function noteTransitionsReloading(transitions) {
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = transitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var transition = _step.value;
+      if (transition.settled) continue;
+      var groups = [...new Set([...transition.participants.values()].map(function (participant) {
+        return participant.oldGroupID;
+      }).filter(function (group) {
+        return typeof group === "string";
+      }))];
+      var [firstParticipant] = transition.participants.values();
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = transition.reasons[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var reasonKey = _step1.value;
+          writeRecoveryMarker(reasonKey, {
+            t: Date.now(),
+            groups
+          }, firstParticipant === null || firstParticipant === void 0 ? void 0 : firstParticipant.deps.guardStorage);
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      settleTransition(transition, "reloading");
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+}
 function recover(deps, reasonKey, message, dropLocalState) {
   var _deps_onRecovery;
   if (typeof window === "undefined") return;
   (_deps_onRecovery = deps.onRecovery) === null || _deps_onRecovery === void 0 ? void 0 : _deps_onRecovery.call(deps, reasonKey);
-  if (dropLocalState) {
-    pendingDeletes.push(function () {
-      return Promise.resolve().then(deps.deleteLocalState);
-    });
+  refreshGroupCache(deps);
+  if (GROUP_TRANSITION_REASONS.has(reasonKey)) {
+    recoverViaGroupTransition(deps, reasonKey, message, dropLocalState);
+    return;
   }
-  if (deps.recoverInPlace && !pendingInPlaceRecoveries.includes(deps.recoverInPlace)) {
-    pendingInPlaceRecoveries.push(deps.recoverInPlace);
+  var shared = sharedRecoveryState();
+  var participant = findOpenTransitionParticipant(deps);
+  if (!participant) {
+    if (dropLocalState) {
+      pushGlobalDelete(deps);
+    }
+    if (deps.recoverInPlace && !shared.pendingInPlaceRecoveries.includes(deps.recoverInPlace)) {
+      shared.pendingInPlaceRecoveries.push(deps.recoverInPlace);
+    }
+  } else if (dropLocalState && !participant.dropLocalState) {
+    participant.dropLocalState = true;
+    if (participant.deleteExecuted) pushGlobalDelete(deps);
   }
-  if (reloadScheduled) return;
+  if (shared.reloadScheduled) return;
   if (!recoveryGuardOpen(reasonKey, deps.guardStorage)) {
     console.error(`[on-zero] ${message} \u2014 already recovered once, not reloading`);
     deps.zeroEvents.emit({
@@ -146,7 +799,7 @@ function recover(deps, reasonKey, message, dropLocalState) {
     } catch (unused) {}
     return;
   }
-  reloadScheduled = true;
+  shared.reloadScheduled = true;
   armReloadLatchTimeout();
   console.warn(`[on-zero] ${message} \u2014 recovering`);
   deps.zeroEvents.emit({
@@ -169,6 +822,7 @@ function recover(deps, reasonKey, message, dropLocalState) {
   }
 }
 function makeZeroRecovery(deps) {
+  seqOf(deps);
   return {
     onUpdateNeeded(reason) {
       var dropLocalState = reason.type === "SchemaVersionNotSupported";
@@ -276,8 +930,9 @@ function classifyZeroRecoveryLog(level, args) {
     };
   }
   if (text.includes(STORE_CLOSED) && !isBenignStoreClosedLog(text)) {
-    var prevMs = lastStoreClosedAtMs;
-    lastStoreClosedAtMs = nowMs;
+    var shared = sharedRecoveryState();
+    var prevMs = shared.lastStoreClosedAtMs;
+    shared.lastStoreClosedAtMs = nowMs;
     if (prevMs > 0 && nowMs - prevMs >= STORE_CLOSED_REPEAT_MIN_MS && nowMs - prevMs <= STORE_CLOSED_REPEAT_MAX_MS) {
       return {
         reasonKey: "store-closed-repeat",
@@ -321,16 +976,21 @@ function isRecoverableZeroStalePokeMessage(message) {
   return message.includes("Server returned unexpected base cookie during sync") || message.includes("Received cookie") && message.includes("is < than last snapshot cookie") && message.includes("ignoring client view");
 }
 function resetRecoveryStateForTests() {
-  reloadScheduled = false;
-  reloadInProgress = false;
-  if (reloadLatchTimer) {
-    clearTimeout(reloadLatchTimer);
-    reloadLatchTimer = void 0;
-  }
-  pendingDeletes.length = 0;
-  pendingInPlaceRecoveries.length = 0;
-  lastStoreClosedAtMs = 0;
-  inMemoryGuard.clear();
-}
-export { classifyZeroRecoveryLog, composeRecoveryLogSink, isRecoverableZeroStalePokeMessage, makeZeroRecovery, resetRecoveryStateForTests };
+  var shared = sharedRecoveryState();
+  shared.reloadScheduled = false;
+  shared.reloadInProgress = false;
+  if (shared.reloadLatchTimer) {
+    clearTimeout(shared.reloadLatchTimer);
+    shared.reloadLatchTimer = void 0;
+  }
+  shared.pendingDeletes.length = 0;
+  shared.pendingInPlaceRecoveries.length = 0;
+  shared.lastStoreClosedAtMs = 0;
+  shared.inMemoryGuard.clear();
+  shared.transitions.clear();
+  shared.terminalMemory.clear();
+  shared.terminalEmitted.clear();
+  shared.unknownPostSignals.clear();
+}
+export { classifyZeroRecoveryLog, composeRecoveryLogSink, isGroupTransitionOpen, isRecoverableZeroStalePokeMessage, makeZeroRecovery, primeGroupCache, resetRecoveryStateForTests };
 //# sourceMappingURL=recoverZeroClient.native.js.map