on-zero 0.16.19 → 0.16.20

package/dist/esm/helpers/recoverZeroClient.mjs

@@ -1,17 +1,41 @@
+import { globalValue } from "./globalValue.mjs";
 const RECOVER_GUARD_MS = 6e4;
 const RELOAD_LATCH_TIMEOUT_MS = 15e3;
+const GROUP_TRANSITION_REASONS = /* @__PURE__ */new Set(["NewClientGroup", "VersionNotSupported", "SchemaVersionNotSupported"]);
 const LOCAL_STORE_LOST = "Expected IndexedDB not found";
 const SQLITE_ERROR_NAME = "SqliteError";
 const SQLITE_STATEMENT_FINALIZED = "This statement has been finalized";
 const STORE_CLOSED = "Store is closed";
 const STORE_CLOSED_REPEAT_MIN_MS = 2e3;
 const STORE_CLOSED_REPEAT_MAX_MS = 6e4;
-let reloadScheduled = false;
-let reloadInProgress = false;
-let reloadLatchTimer;
-const pendingDeletes = [];
-const pendingInPlaceRecoveries = [];
-const inMemoryGuard = /* @__PURE__ */new Map();
+function sharedRecoveryState() {
+  return globalValue("on-zero:recovery-shared", () => ({
+    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 {
+    return globalThis.location?.href ?? "";
+  } catch {
+    return "";
+  }
+}
+function guardStorageKey(reasonKey) {
+  return `on-zero-recover-${documentScope()}-${reasonKey}`;
+}
 function defaultGuardStorage() {
   try {
     if (typeof window === "undefined" || !window.sessionStorage) return void 0;
@@ -21,13 +45,9 @@ function defaultGuardStorage() {
   }
 }
 function recoveryGuardOpen(reasonKey, guardStorage) {
-  let documentScope = "";
-  try {
-    documentScope = globalThis.location?.href ?? "";
-  } catch {}
-  const key = `on-zero-recover-${documentScope}-${reasonKey}`;
+  const key = guardStorageKey(reasonKey);
   const now = Date.now();
-  const memLast = inMemoryGuard.get(key) ?? 0;
+  const memLast = sharedRecoveryState().inMemoryGuard.get(key) ?? 0;
   if (memLast > 0 && now - memLast < RECOVER_GUARD_MS) return false;
   const storage = guardStorage ?? defaultGuardStorage();
   if (storage) {
@@ -38,30 +58,423 @@ function recoveryGuardOpen(reasonKey, guardStorage) {
       storage.setItem(key, String(now));
     } catch {}
   }
-  inMemoryGuard.set(key, now);
+  sharedRecoveryState().inMemoryGuard.set(key, now);
   return true;
 }
-let lastStoreClosedAtMs = 0;
+function readRecoveryMarker(reasonKey, guardStorage) {
+  const storage = guardStorage ?? defaultGuardStorage();
+  if (!storage) return null;
+  let raw = null;
+  try {
+    raw = storage.getItem(guardStorageKey(reasonKey));
+  } catch {
+    return null;
+  }
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) return {
+    t: Number(raw)
+  };
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.t !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeRecoveryMarker(reasonKey, marker, guardStorage) {
+  const storage = guardStorage ?? defaultGuardStorage();
+  if (!storage) return;
+  try {
+    storage.setItem(guardStorageKey(reasonKey), JSON.stringify(marker));
+  } catch {}
+}
+function clearRecoveryMarker(reasonKey, guardStorage) {
+  const storage = 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 {}
+}
 function armReloadLatchTimeout() {
+  const shared = sharedRecoveryState();
   if (typeof setTimeout !== "function") return;
-  if (reloadLatchTimer) clearTimeout(reloadLatchTimer);
-  reloadLatchTimer = setTimeout(() => {
-    reloadLatchTimer = void 0;
-    reloadScheduled = false;
+  if (shared.reloadLatchTimer) clearTimeout(shared.reloadLatchTimer);
+  shared.reloadLatchTimer = setTimeout(() => {
+    shared.reloadLatchTimer = void 0;
+    shared.reloadScheduled = false;
   }, RELOAD_LATCH_TIMEOUT_MS);
-  if (reloadLatchTimer && typeof reloadLatchTimer === "object" && "unref" in reloadLatchTimer) {
-    reloadLatchTimer.unref();
+  if (shared.reloadLatchTimer && typeof shared.reloadLatchTimer === "object" && "unref" in shared.reloadLatchTimer) {
+    shared.reloadLatchTimer.unref();
   }
 }
 function disarmReloadLatchTimeout() {
-  if (reloadLatchTimer) {
-    clearTimeout(reloadLatchTimer);
-    reloadLatchTimer = void 0;
+  const shared = sharedRecoveryState();
+  if (shared.reloadLatchTimer) {
+    clearTimeout(shared.reloadLatchTimer);
+    shared.reloadLatchTimer = void 0;
+  }
+}
+function pushGlobalDelete(deps) {
+  const shared = sharedRecoveryState();
+  if (shared.pendingDeletes.some(entry => entry.owner === deps.deleteLocalState)) {
+    return;
+  }
+  shared.pendingDeletes.push({
+    owner: deps.deleteLocalState,
+    run: () => Promise.resolve().then(deps.deleteLocalState)
+  });
+}
+function removeGlobalDelete(owner) {
+  const pending = sharedRecoveryState().pendingDeletes;
+  const index = pending.findIndex(entry => entry.owner === owner);
+  if (index !== -1) pending.splice(index, 1);
+}
+function removeGlobalRemint(fn) {
+  if (!fn) return;
+  const pending = sharedRecoveryState().pendingInPlaceRecoveries;
+  const index = pending.indexOf(fn);
+  if (index !== -1) pending.splice(index, 1);
+}
+function seqOf(deps) {
+  const shared = sharedRecoveryState();
+  let 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;
+  let result;
+  try {
+    result = deps.getGroupID();
+  } catch {
+    return;
+  }
+  if (typeof result === "string") {
+    if (result) sharedRecoveryState().groupByDeps.set(deps, result);
+    return;
+  }
+  void Promise.resolve(result).then(id => {
+    if (typeof id === "string" && id) sharedRecoveryState().groupByDeps.set(deps, id);
+  }, () => {});
+}
+function cachedGroupID(deps) {
+  return sharedRecoveryState().groupByDeps.get(deps);
+}
+function primeGroupCache(deps) {
+  refreshGroupCache(deps);
+}
+function participantKey(deps) {
+  return deps.recoverInPlace ?? deps.deleteLocalState;
+}
+function transitionKey(deps) {
+  return `${documentScope()}\0${deps.clientIdentity ?? ""}`;
+}
+function findOpenTransitionParticipant(deps) {
+  const 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) {
+  const shared = sharedRecoveryState();
+  const now = Date.now();
+  const emitKey = terminalKey(key, reasonKey);
+  const lastEmitted = shared.terminalEmitted.get(emitKey) ?? 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 {}
+  try {
+    globalThis.dispatchEvent?.(new CustomEvent("on-zero-fatal", {
+      detail: {
+        reasonKey,
+        reason: message
+      }
+    }));
+  } catch {}
+}
+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;
+  for (const participant of transition.participants.values()) {
+    if (!participant.reminted && !participant.skipped) return;
+  }
+  if (transition.pendingWaits > 0) return;
+  settleTransition(transition, "completed");
+}
+function failTransition(transition, input) {
+  if (transition.settled) return;
+  const groups = [...new Set([...transition.participants.values()].map(participant => participant.oldGroupID).filter(group => typeof group === "string"))];
+  settleTransition(transition, "terminal");
+  for (const reasonKey of /* @__PURE__ */new Set([...transition.reasons, input.reasonKey])) {
+    stampTerminal(transition.key, reasonKey, input.signalDeps.guardStorage, input.message, groups);
+  }
+  emitTerminalOnce(input.signalDeps, transition.key, input.reasonKey, input.message);
+}
+function makeWrappedRemint(transition, participant) {
+  return async () => {
+    if (participant.skipped || participant.reminted) return true;
+    const remint = participant.deps.recoverInPlace;
+    if (!remint) {
+      participant.skipped = true;
+      checkTransitionComplete(transition);
+      return false;
+    }
+    let ok;
+    try {
+      ok = await remint();
+    } catch (error) {
+      const [firstReason] = transition.reasons;
+      failTransition(transition, {
+        reasonKey: firstReason ?? "NewClientGroup",
+        message: `in-place recovery threw (${error instanceof Error ? error.message : String(error)})`,
+        signalDeps: participant.deps
+      });
+      return false;
+    }
+    if (!ok) {
+      participant.skipped = true;
+      checkTransitionComplete(transition);
+      return false;
+    }
+    participant.reminted = true;
+    const awaitReconnected = participant.deps.awaitReconnected;
+    if (awaitReconnected) {
+      transition.pendingWaits += 1;
+      try {
+        await Promise.race([awaitReconnected(), transition.settledPromise]);
+      } catch {} finally {
+        transition.pendingWaits -= 1;
+      }
+    }
+    checkTransitionComplete(transition);
+    return true;
+  };
+}
+async function runParticipantImmediate(transition, participant) {
+  const doDelete = participant.dropLocalState && !participant.deleteExecuted;
+  const doRemint = !participant.remintExecuted;
+  participant.deleteExecuted = true;
+  participant.remintExecuted = true;
+  if (doDelete) {
+    try {
+      await participant.deps.deleteLocalState();
+    } catch {}
+  }
+  if (doRemint) {
+    if (participant.wrappedRemint) await participant.wrappedRemint();else {
+      participant.skipped = true;
+      checkTransitionComplete(transition);
+    }
+  }
+}
+function joinTransition(transition, deps, reasonKey, dropLocalState) {
+  transition.reasons.add(reasonKey);
+  const key = participantKey(deps);
+  const 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);
+  const 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) {
+  const shared = sharedRecoveryState();
+  const key = transitionKey(deps);
+  let notifySettled;
+  const settledPromise = new Promise(resolve => {
+    notifySettled = resolve;
+  });
+  const 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;
+    for (const participant of transition.participants.values()) {
+      void runParticipantImmediate(transition, participant);
+    }
+    return;
+  }
+  shared.reloadScheduled = true;
+  armReloadLatchTimeout();
+  const runReload = () => performReload(deps);
+  if (deps.scheduleReload) {
+    deps.scheduleReload({
+      reason: message,
+      reasonKey,
+      dropLocalState,
+      performReload: runReload
+    });
+  } else {
+    void runReload();
+  }
+}
+function checkTransitionGuard(deps, reasonKey) {
+  const shared = sharedRecoveryState();
+  const key = transitionKey(deps);
+  const now = Date.now();
+  const myGroup = cachedGroupID(deps);
+  const 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";
+    }
+  }
+  const marker = readRecoveryMarker(reasonKey, deps.guardStorage);
+  if (marker && marker.t > 0 && now - marker.t < RECOVER_GUARD_MS) {
+    const 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) {
+      emitTerminalOnce(deps, key, reasonKey, marker.msg ?? `update needed (${reasonKey}) \u2014 recovery already failed, not retrying`);
+      return "silent";
+    }
+    if (myGroup !== void 0 && markerGroups !== void 0 && markerGroups.includes(myGroup)) {
+      const message2 = `update needed (${reasonKey}) \u2014 client group ${myGroup} \u2192 ${myGroup} (unchanged after reload), not reloading`;
+      stampTerminal(key, reasonKey, deps.guardStorage, message2, markerGroups);
+      emitTerminalOnce(deps, key, reasonKey, message2);
+      return "silent";
+    }
+    const message = `update needed (${reasonKey}) \u2014 already recovered once, not reloading`;
+    stampTerminal(key, reasonKey, deps.guardStorage, message, markerGroups ?? []);
+    emitTerminalOnce(deps, key, reasonKey, message);
+    return "silent";
+  }
+  return "allow";
+}
+function handlePostTransitionSignal(transition, deps, reasonKey, message, dropLocalState) {
+  const shared = sharedRecoveryState();
+  const newGroup = cachedGroupID(deps);
+  const oldGroups = [...new Set([...transition.participants.values()].map(participant => participant.oldGroupID).filter(group => 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;
+  }
+  const now = Date.now();
+  const budget = shared.unknownPostSignals.get(transition.key);
+  const 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: (freshBudget?.count ?? 0) + 1,
+    windowStartMs: freshBudget?.windowStartMs ?? now
+  });
+  settleTransition(transition, "superseded");
+  startTransition(deps, reasonKey, message, dropLocalState);
+}
+function recoverViaGroupTransition(deps, reasonKey, message, dropLocalState) {
+  const key = transitionKey(deps);
+  const 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) {
-  if (reloadInProgress) return Promise.resolve();
-  reloadInProgress = true;
+  const shared = sharedRecoveryState();
+  if (shared.reloadInProgress) return Promise.resolve();
+  shared.reloadInProgress = true;
   disarmReloadLatchTimeout();
   const doReload = deps.reload ?? (() => {
     const reload = globalThis.location?.reload;
@@ -69,36 +482,104 @@ function performReload(deps) {
     reload.call(globalThis.location);
     return true;
   });
-  let inPlaceRecoveries = [];
+  let globalDeletes = [];
+  let globalRemints = [];
+  let openTransitions = [];
+  const transitionDeletes = [];
+  const transitionRemints = [];
   return Promise.resolve().then(() => {
-    inPlaceRecoveries = pendingInPlaceRecoveries.splice(0);
-    return Promise.allSettled(pendingDeletes.splice(0).map(run => run()));
+    globalDeletes = shared.pendingDeletes.splice(0);
+    globalRemints = shared.pendingInPlaceRecoveries.splice(0);
+    openTransitions = [...shared.transitions.values()].filter(transition => !transition.settled);
+    for (const transition of openTransitions) {
+      transition.remintsExecuted = true;
+      for (const participant of transition.participants.values()) {
+        if (participant.dropLocalState && !participant.deleteExecuted) {
+          participant.deleteExecuted = true;
+          const runDelete = participant.deps.deleteLocalState;
+          transitionDeletes.push(() => 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);
+          }
+        }
+      }
+    }
+    return Promise.allSettled([...globalDeletes.map(entry => entry.run()), ...transitionDeletes.map(run => run())]);
   }).then(() => deps.beforeReload?.()).catch(() => {}).then(async () => {
-    const reloadStarted = doReload();
-    if (reloadStarted !== false) return;
+    let reloadStarted = false;
     try {
-      const results = await Promise.all(inPlaceRecoveries.map(recover2 => recover2()));
-      if (inPlaceRecoveries.length > 0 && results.some(recovered => !recovered)) {
+      reloadStarted = doReload();
+    } catch {
+      reloadStarted = false;
+    }
+    if (reloadStarted !== false) {
+      noteTransitionsReloading(openTransitions);
+      return;
+    }
+    try {
+      const liveRemints = transitionRemints.filter(({
+        transition
+      }) => !transition.settled);
+      const results = await Promise.all([...globalRemints.map(recover2 => recover2()), ...liveRemints.map(({
+        run
+      }) => run())]);
+      const globalResults = results.slice(0, globalRemints.length);
+      if (globalRemints.length > 0 && globalResults.some(recovered => !recovered)) {
         console.error("[on-zero] recovery could not reload or reconstruct the client");
       }
     } 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) {
+  for (const transition of transitions) {
+    if (transition.settled) continue;
+    const groups = [...new Set([...transition.participants.values()].map(participant => participant.oldGroupID).filter(group => typeof group === "string"))];
+    const [firstParticipant] = transition.participants.values();
+    for (const reasonKey of transition.reasons) {
+      writeRecoveryMarker(reasonKey, {
+        t: Date.now(),
+        groups
+      }, firstParticipant?.deps.guardStorage);
+    }
+    settleTransition(transition, "reloading");
+  }
+}
 function recover(deps, reasonKey, message, dropLocalState) {
   if (typeof window === "undefined") return;
   deps.onRecovery?.(reasonKey);
-  if (dropLocalState) {
-    pendingDeletes.push(() => 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);
+  const shared = sharedRecoveryState();
+  const 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({
@@ -116,7 +597,7 @@ function recover(deps, reasonKey, message, dropLocalState) {
     } catch {}
     return;
   }
-  reloadScheduled = true;
+  shared.reloadScheduled = true;
   armReloadLatchTimeout();
   console.warn(`[on-zero] ${message} \u2014 recovering`);
   deps.zeroEvents.emit({
@@ -137,6 +618,7 @@ function recover(deps, reasonKey, message, dropLocalState) {
   }
 }
 function makeZeroRecovery(deps) {
+  seqOf(deps);
   return {
     onUpdateNeeded(reason) {
       const dropLocalState = reason.type === "SchemaVersionNotSupported";
@@ -237,8 +719,9 @@ function classifyZeroRecoveryLog(level, args, nowMs = Date.now()) {
     };
   }
   if (text.includes(STORE_CLOSED) && !isBenignStoreClosedLog(text)) {
-    const prevMs = lastStoreClosedAtMs;
-    lastStoreClosedAtMs = nowMs;
+    const shared = sharedRecoveryState();
+    const 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",
@@ -274,16 +757,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 };
+  const 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.mjs.map