@multiplatform.one/frappe 6.0.0

package/dist/esm/sync/persistence.native.js

@@ -0,0 +1,883 @@
+import { Debouncer } from "@tanstack/pacer";
+import { onVisibilityChange } from "@multiplatform.one/platform";
+import { IndexedDBKV, PlatformStorageKV } from "./storage.native.js";
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function getLocalStorage() {
+  try {
+    return typeof globalThis !== "undefined" && "localStorage" in globalThis ? globalThis.localStorage : void 0;
+  } catch (unused) {
+    return void 0;
+  }
+}
+var PersistenceManager = /* @__PURE__ */function () {
+  "use strict";
+
+  function PersistenceManager2(normalizedCache, mutationJournal, subscriptionManager, mutationEngine) {
+    var _this = this;
+    var options = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : {};
+    _class_call_check(this, PersistenceManager2);
+    var _ref, _ref1, _ref2;
+    var _options_tabCoordination, _options_tabCoordination1, _options_tabCoordination2;
+    _define_property(this, "normalizedCache", void 0);
+    _define_property(this, "mutationJournal", void 0);
+    _define_property(this, "subscriptionManager", void 0);
+    _define_property(this, "mutationEngine", void 0);
+    _define_property(this, "options", void 0);
+    _define_property(this, "persistenceStorage", void 0);
+    _define_property(this, "saveDebouncer", void 0);
+    _define_property(this, "broadcastChannel", void 0);
+    _define_property(this, "isLeader", void 0);
+    _define_property(this, "tabId", void 0);
+    _define_property(this, "leaderCheckInterval", void 0);
+    _define_property(this, "visibilityState", void 0);
+    _define_property(this, "lastVisibilityChange", void 0);
+    _define_property(this, "pendingOperations", void 0);
+    _define_property(this, "acceptingNewWork", void 0);
+    _define_property(this, "handoffInProgress", void 0);
+    _define_property(this, "tabCoordinationConfig", void 0);
+    _define_property(this, "leaderKey", void 0);
+    _define_property(this, "cleanupVisibilityChange", void 0);
+    _define_property(this, "activeResponseTimers", void 0);
+    _define_property(this, "isDestroyed", void 0);
+    this.normalizedCache = normalizedCache;
+    this.mutationJournal = mutationJournal;
+    this.subscriptionManager = subscriptionManager;
+    this.mutationEngine = mutationEngine;
+    this.options = options;
+    this.saveDebouncer = new Debouncer(function () {
+      return void _this.save();
+    }, {
+      wait: 50
+    });
+    this.isLeader = false;
+    this.tabId = this.generateTabId();
+    this.visibilityState = "visible";
+    this.lastVisibilityChange = Date.now();
+    this.pendingOperations = /* @__PURE__ */new Set();
+    this.acceptingNewWork = true;
+    this.handoffInProgress = false;
+    this.leaderKey = "frappe-sync-leader";
+    this.activeResponseTimers = /* @__PURE__ */new Set();
+    this.isDestroyed = false;
+    this.tabCoordinationConfig = {
+      activeTabPriority: (_ref = (_options_tabCoordination = options.tabCoordination) === null || _options_tabCoordination === void 0 ? void 0 : _options_tabCoordination.activeTabPriority) !== null && _ref !== void 0 ? _ref : true,
+      leaderTimeout: (_ref1 = (_options_tabCoordination1 = options.tabCoordination) === null || _options_tabCoordination1 === void 0 ? void 0 : _options_tabCoordination1.leaderTimeout) !== null && _ref1 !== void 0 ? _ref1 : 5e3,
+      handoffGracePeriod: (_ref2 = (_options_tabCoordination2 = options.tabCoordination) === null || _options_tabCoordination2 === void 0 ? void 0 : _options_tabCoordination2.handoffGracePeriod) !== null && _ref2 !== void 0 ? _ref2 : 2e3
+    };
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    this.setupPersistence();
+    this.setupBroadcastChannel();
+    if (this.tabCoordinationConfig.activeTabPriority) {
+      this.setupTabCoordination();
+    }
+  }
+  _create_class(PersistenceManager2, [{
+    key: "setupPersistence",
+    value: (
+    /**
+    * Sets up persistence storage based on environment and options.
+    */
+    function setupPersistence() {
+      if (!this.options.persistKey) return;
+      if (this.options.storage) {
+        this.persistenceStorage = this.options.storage;
+      } else if (typeof indexedDB !== "undefined") {
+        this.persistenceStorage = new IndexedDBKV();
+      } else {
+        this.persistenceStorage = new PlatformStorageKV();
+      }
+      void this.load();
+    })
+  }, {
+    key: "setupBroadcastChannel",
+    value: (
+    /**
+    * Sets up BroadcastChannel for cross-tab coordination.
+    * Handles both simple string messages and structured TabMessage types.
+    */
+    function setupBroadcastChannel() {
+      var _this = this;
+      if (!this.options.persistKey || typeof BroadcastChannel === "undefined") return;
+      try {
+        this.broadcastChannel = new BroadcastChannel(`frappe-sync:${this.options.persistKey}`);
+      } catch (unused) {
+        return;
+      }
+      this.broadcastChannel.onmessage = function (e) {
+        if (typeof (e === null || e === void 0 ? void 0 : e.data) === "string") {
+          if (e.data === "reset" && _this.options.onResetCache) {
+            _this.options.onResetCache();
+          }
+          if (e.data === "backfill" && _this.options.onBackfillAll) {
+            _this.options.onBackfillAll();
+          }
+          return;
+        }
+        var message = e === null || e === void 0 ? void 0 : e.data;
+        if (!message || !message.type) return;
+        switch (message.type) {
+          case "visibility-check":
+            if (message.fromTab !== _this.tabId) {
+              _this.broadcastToTabs({
+                type: "visibility-response",
+                tabId: _this.tabId,
+                isVisible: _this.visibilityState === "visible"
+              });
+            }
+            break;
+          case "leadership-request":
+            if (_this.isLeader && message.visibilityState === "visible" && _this.visibilityState === "hidden") {
+              _this.initiateGracefulHandoff();
+            }
+            break;
+          case "leadership-handoff":
+            if (message.toTab === _this.tabId) {
+              if (message.state) {
+                _this.restoreStateFromHandoff(message.state);
+              }
+              _this.becomeLeader();
+            }
+            break;
+          case "mutation":
+            if (!_this.isLeader && message.mutation) {
+              _this.handleRemoteMutation(message.mutation);
+            }
+            break;
+          case "sync-state":
+            if (!_this.isLeader && message.state) {
+              _this.restoreStateFromHandoff(message.state);
+            }
+            break;
+          case "heartbeat":
+            break;
+          case "visibility-response":
+            break;
+        }
+      };
+    })
+  }, {
+    key: "handleRemoteMutation",
+    value: (
+    /**
+    * Handles a mutation relayed from another tab.
+    * Updates local cache with the mutation's effects.
+    */
+    function handleRemoteMutation(mutation) {
+      if (mutation.doc) {
+        if (mutation.operation === "delete") {
+          this.normalizedCache.remove({
+            doctype: mutation.doc.doctype,
+            name: mutation.doc.name
+          });
+        } else {
+          this.normalizedCache.upsert(mutation.doc);
+        }
+      }
+    })
+  }, {
+    /**
+    * Broadcasts a mutation to other tabs.
+    * Called by SyncModule after a successful mutation.
+    */
+    key: "broadcastMutation",
+    value: function broadcastMutation(mutation) {
+      if (!this.isLeader) return;
+      this.broadcastToTabs({
+        type: "mutation",
+        mutation
+      });
+    }
+  }, {
+    key: "restoreStateFromHandoff",
+    value: (
+    /**
+    * Restores state received from a leadership handoff or sync-state message.
+    */
+    function restoreStateFromHandoff(state) {
+      if (!state || (typeof state === "undefined" ? "undefined" : _type_of(state)) !== "object") return;
+      var handoffState = state;
+      if (handoffState.cache) {
+        this.normalizedCache.state = handoffState.cache;
+      }
+      if (handoffState.subscriptions && Array.isArray(handoffState.subscriptions)) {
+        var subscriptions = this.subscriptionManager.getAllSubscriptions();
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = handoffState.subscriptions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var subscription = _step.value;
+            if (subscription === null || subscription === void 0 ? void 0 : subscription.id) {
+              subscriptions.set(subscription.id, subscription);
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+      }
+      if (handoffState.tempMappings && Array.isArray(handoffState.tempMappings)) {
+        var tempMap = this.mutationEngine.getTemporaryIdToRealNameMap();
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = handoffState.tempMappings[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var [tempId, realId] = _step1.value;
+            tempMap.set(tempId, realId);
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+      }
+    })
+  }, {
+    /**
+    * Schedules a debounced save operation.
+    */
+    key: "scheduleSave",
+    value: function scheduleSave() {
+      if (!this.options.persistKey) return;
+      this.saveDebouncer.maybeExecute();
+    }
+  }, {
+    key: "save",
+    value: (
+    /**
+    * Persists a snapshot of subscriptions, cache, journal, and temp mappings.
+    */
+    async function save() {
+      if (!this.options.persistKey || !this.persistenceStorage) return;
+      try {
+        var snapshot = {
+          subs: [...this.subscriptionManager.getAllSubscriptions().values()].map(function (s) {
+            return {
+              id: s.id,
+              query: s.query,
+              checkpoint: s.checkpoint,
+              docIds: s.docIds
+            };
+          }),
+          cache: this.normalizedCache.state,
+          journal: this.mutationJournal.listPending(),
+          temp: [...this.mutationEngine.getTemporaryIdToRealNameMap().entries()]
+        };
+        await this.persistenceStorage.setItem(this.options.persistKey, JSON.stringify(snapshot));
+      } catch (err) {
+        console.warn("Failed to save sync state:", err);
+      }
+    })
+  }, {
+    key: "load",
+    value: (
+    /**
+    * Loads a previously persisted snapshot if present.
+    */
+    async function load() {
+      if (!this.options.persistKey || !this.persistenceStorage) return;
+      try {
+        var raw = await this.persistenceStorage.getItem(this.options.persistKey);
+        if (!raw) return;
+        var snap = JSON.parse(raw);
+        if (snap === null || snap === void 0 ? void 0 : snap.cache) {
+          this.normalizedCache.state = snap.cache;
+        }
+        if (snap === null || snap === void 0 ? void 0 : snap.subs) {
+          var subscriptions = this.subscriptionManager.getAllSubscriptions();
+          var _iteratorNormalCompletion = true,
+            _didIteratorError = false,
+            _iteratorError = void 0;
+          try {
+            for (var _iterator = snap.subs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              var subscription = _step.value;
+              subscriptions.set(subscription.id, subscription);
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+        }
+        if ((snap === null || snap === void 0 ? void 0 : snap.journal) && Array.isArray(snap.journal)) {
+          var _iteratorNormalCompletion1 = true,
+            _didIteratorError1 = false,
+            _iteratorError1 = void 0;
+          try {
+            for (var _iterator1 = snap.journal[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+              var {
+                id,
+                entry
+              } = _step1.value;
+              this.mutationJournal.add(id, entry);
+            }
+          } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+              }
+            } finally {
+              if (_didIteratorError1) {
+                throw _iteratorError1;
+              }
+            }
+          }
+        }
+        if ((snap === null || snap === void 0 ? void 0 : snap.temp) && Array.isArray(snap.temp)) {
+          var tempMap = this.mutationEngine.getTemporaryIdToRealNameMap();
+          var _iteratorNormalCompletion2 = true,
+            _didIteratorError2 = false,
+            _iteratorError2 = void 0;
+          try {
+            for (var _iterator2 = snap.temp[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+              var [tempId, realId] = _step2.value;
+              tempMap.set(tempId, realId);
+            }
+          } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+              }
+            } finally {
+              if (_didIteratorError2) {
+                throw _iteratorError2;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        console.warn("Failed to load sync state:", err);
+      }
+    })
+  }, {
+    /**
+    * Broadcasts a reset message to other tabs.
+    */
+    key: "broadcastReset",
+    value: function broadcastReset() {
+      if (this.broadcastChannel) {
+        this.broadcastChannel.postMessage("reset");
+      }
+    }
+  }, {
+    /**
+    * Broadcasts a backfill message to other tabs.
+    */
+    key: "broadcastBackfill",
+    value: function broadcastBackfill() {
+      if (this.broadcastChannel) {
+        this.broadcastChannel.postMessage("backfill");
+      }
+    }
+  }, {
+    /**
+    * Broadcasts a generic change message to other tabs.
+    */
+    key: "broadcastChange",
+    value: function broadcastChange() {
+      if (this.broadcastChannel) {
+        this.broadcastChannel.postMessage("changed");
+      }
+    }
+  }, {
+    key: "setupTabCoordination",
+    value: (
+    /**
+    * Sets up tab coordination with active tab priority.
+    */
+    function setupTabCoordination() {
+      var _this = this;
+      this.visibilityState = document.hidden ? "hidden" : "visible";
+      this.cleanupVisibilityChange = onVisibilityChange(function (visible) {
+        if (_this.isDestroyed) return;
+        var wasVisible = _this.visibilityState === "visible";
+        _this.visibilityState = visible ? "visible" : "hidden";
+        _this.lastVisibilityChange = Date.now();
+        if (!wasVisible && _this.visibilityState === "visible") {
+          _this.evaluateLeadershipPriority();
+        } else if (wasVisible && _this.visibilityState === "hidden" && _this.isLeader) {
+          _this.considerLeadershipHandoff();
+        }
+      });
+      this.tryBecomeLeader();
+    })
+  }, {
+    key: "tryBecomeLeader",
+    value: (
+    /**
+    * Attempts to become the leader tab.
+    */
+    function tryBecomeLeader() {
+      var _this = this;
+      if (!getLocalStorage() || this.isDestroyed) return;
+      var now = Date.now();
+      var leaderData = this.getLeaderData();
+      if (!leaderData || now - leaderData.timestamp > this.tabCoordinationConfig.leaderTimeout || this.visibilityState === "visible" && leaderData.visibilityState === "hidden") {
+        this.becomeLeader();
+      } else {
+        if (this.leaderCheckInterval) {
+          clearInterval(this.leaderCheckInterval);
+        }
+        this.leaderCheckInterval = setInterval(function () {
+          if (!_this.isDestroyed) {
+            _this.checkLeadership();
+          }
+        }, this.tabCoordinationConfig.leaderTimeout / 2);
+      }
+    })
+  }, {
+    key: "becomeLeader",
+    value: (
+    /**
+    * Becomes the leader tab.
+    */
+    function becomeLeader() {
+      var _this = this;
+      if (this.isDestroyed) return;
+      this.isLeader = true;
+      this.updateLeaderTimestamp();
+      this.onBecomeLeader();
+      if (this.leaderCheckInterval) {
+        clearInterval(this.leaderCheckInterval);
+      }
+      this.leaderCheckInterval = setInterval(function () {
+        if (!_this.isDestroyed) {
+          _this.updateLeaderTimestamp();
+        }
+      }, this.tabCoordinationConfig.leaderTimeout / 2);
+    })
+  }, {
+    key: "updateLeaderTimestamp",
+    value: (
+    /**
+    * Updates leader timestamp in localStorage.
+    */
+    function updateLeaderTimestamp() {
+      var ls = getLocalStorage();
+      if (!ls) return;
+      var leaderData = {
+        tabId: this.tabId,
+        timestamp: Date.now(),
+        visibilityState: this.visibilityState,
+        lastVisibilityChange: this.lastVisibilityChange
+      };
+      try {
+        ls.setItem(this.leaderKey, JSON.stringify(leaderData));
+      } catch (error) {
+        console.warn("[PersistenceManager] Failed to update leader timestamp:", error);
+      }
+    })
+  }, {
+    key: "checkLeadership",
+    value: (
+    /**
+    * Checks if this tab should remain leader.
+    */
+    function checkLeadership() {
+      var leaderData = this.getLeaderData();
+      if (!leaderData) {
+        this.tryBecomeLeader();
+        return;
+      }
+      var now = Date.now();
+      if (this.isLeader) {
+        if (leaderData.tabId !== this.tabId) {
+          this.isLeader = false;
+          this.onLoseLeadership();
+        }
+      } else {
+        if (now - leaderData.timestamp > this.tabCoordinationConfig.leaderTimeout || this.visibilityState === "visible" && leaderData.visibilityState === "hidden" && now - this.lastVisibilityChange > 1e3) {
+          this.tryBecomeLeader();
+        }
+      }
+    })
+  }, {
+    key: "getLeaderData",
+    value: (
+    /**
+    * Gets current leader data from localStorage.
+    */
+    function getLeaderData() {
+      var ls = getLocalStorage();
+      if (!ls) return null;
+      try {
+        var data = ls.getItem(this.leaderKey);
+        return data ? JSON.parse(data) : null;
+      } catch (unused) {
+        return null;
+      }
+    })
+  }, {
+    key: "evaluateLeadershipPriority",
+    value: (
+    /**
+    * Evaluates if this tab should take leadership based on visibility priority.
+    */
+    function evaluateLeadershipPriority() {
+      if (this.isLeader) return;
+      var leaderData = this.getLeaderData();
+      if (!leaderData) {
+        this.tryBecomeLeader();
+        return;
+      }
+      if (leaderData.visibilityState === "hidden" && this.visibilityState === "visible") {
+        this.requestLeadershipHandoff();
+      }
+    })
+  }, {
+    key: "considerLeadershipHandoff",
+    value: (
+    /**
+    * Considers handing off leadership when tab becomes hidden.
+    */
+    function considerLeadershipHandoff() {
+      var _this = this;
+      if (!this.isLeader) return;
+      this.checkForActiveTabs(function (hasActiveTabs) {
+        if (hasActiveTabs) {
+          _this.initiateGracefulHandoff();
+        }
+      });
+    })
+  }, {
+    key: "requestLeadershipHandoff",
+    value:
+    // Otherwise, remain leader even though hidden
+    /**
+    * Requests leadership handoff from current leader.
+    */
+    function requestLeadershipHandoff() {
+      this.broadcastToTabs({
+        type: "leadership-request",
+        tabId: this.tabId,
+        visibilityState: this.visibilityState
+      });
+    }
+  }, {
+    key: "initiateGracefulHandoff",
+    value: (
+    /**
+    * Initiates graceful handoff to another tab.
+    */
+    async function initiateGracefulHandoff() {
+      if (!this.isLeader || this.handoffInProgress) return;
+      this.handoffInProgress = true;
+      this.acceptingNewWork = false;
+      await this.waitForPendingOperations();
+      var successor = await this.findSuccessor();
+      if (successor) {
+        var state = await this.captureState();
+        this.broadcastToTabs({
+          type: "leadership-handoff",
+          fromTab: this.tabId,
+          toTab: successor,
+          state
+        });
+        this.isLeader = false;
+        this.onLoseLeadership();
+      }
+      this.handoffInProgress = false;
+      this.acceptingNewWork = true;
+    })
+  }, {
+    key: "waitForPendingOperations",
+    value: (
+    /**
+    * Waits for all pending operations to complete.
+    */
+    async function waitForPendingOperations() {
+      var _this = this;
+      var timeout = new Promise(function (resolve) {
+        return setTimeout(resolve, _this.tabCoordinationConfig.handoffGracePeriod);
+      });
+      var operations = Promise.all(this.pendingOperations);
+      await Promise.race([operations, timeout]);
+    })
+  }, {
+    key: "findSuccessor",
+    value: (
+    /**
+    * Finds a suitable successor for leadership.
+    */
+    async function findSuccessor() {
+      var _this = this;
+      return new Promise(function (resolve) {
+        if (_this.isDestroyed) {
+          resolve(null);
+          return;
+        }
+        var responses = [];
+        var handleResponse = function handleResponse2(event) {
+          var _event_data;
+          if (((_event_data = event.data) === null || _event_data === void 0 ? void 0 : _event_data.type) === "visibility-response") {
+            responses.push({
+              tabId: event.data.tabId,
+              isVisible: event.data.isVisible
+            });
+          }
+        };
+        window.addEventListener("message", handleResponse);
+        _this.broadcastToTabs({
+          type: "visibility-check",
+          fromTab: _this.tabId
+        });
+        var responseTimer = setTimeout(function () {
+          var _responses_;
+          _this.activeResponseTimers.delete(responseTimer);
+          window.removeEventListener("message", handleResponse);
+          var visibleTab = responses.find(function (r) {
+            return r.isVisible;
+          });
+          resolve(visibleTab ? visibleTab.tabId : ((_responses_ = responses[0]) === null || _responses_ === void 0 ? void 0 : _responses_.tabId) || null);
+        }, 500);
+        _this.activeResponseTimers.add(responseTimer);
+      });
+    })
+  }, {
+    key: "checkForActiveTabs",
+    value: (
+    /**
+    * Checks if there are other active tabs.
+    */
+    function checkForActiveTabs(callback) {
+      var _this = this;
+      if (this.isDestroyed) {
+        callback(false);
+        return;
+      }
+      var responses = [];
+      var handleResponse = function handleResponse2(event) {
+        var _event_data;
+        if (((_event_data = event.data) === null || _event_data === void 0 ? void 0 : _event_data.type) === "visibility-response") {
+          responses.push(event.data.isVisible);
+        }
+      };
+      window.addEventListener("message", handleResponse);
+      this.broadcastToTabs({
+        type: "visibility-check",
+        fromTab: this.tabId
+      });
+      var responseTimer = setTimeout(function () {
+        _this.activeResponseTimers.delete(responseTimer);
+        window.removeEventListener("message", handleResponse);
+        callback(responses.some(function (isVisible) {
+          return isVisible;
+        }));
+      }, 500);
+      this.activeResponseTimers.add(responseTimer);
+    })
+  }, {
+    key: "captureState",
+    value: (
+    /**
+    * Captures current state for handoff.
+    */
+    async function captureState() {
+      return {
+        cache: this.normalizedCache.state,
+        journal: this.mutationJournal.listPending(),
+        subscriptions: [...this.subscriptionManager.getAllSubscriptions().values()],
+        tempMappings: [...this.mutationEngine.getTemporaryIdToRealNameMap().entries()]
+      };
+    })
+  }, {
+    key: "broadcastToTabs",
+    value: (
+    /**
+    * Broadcasts message to other tabs.
+    */
+    function broadcastToTabs(message) {
+      if (this.broadcastChannel) {
+        this.broadcastChannel.postMessage(message);
+      }
+      var ls = getLocalStorage();
+      if (ls) {
+        try {
+          var key = `frappe-sync-msg-${Date.now()}`;
+          ls.setItem(key, JSON.stringify(message));
+          setTimeout(function () {
+            return ls.removeItem(key);
+          }, 100);
+        } catch (unused) {}
+      }
+    })
+  }, {
+    key: "onBecomeLeader",
+    value: (
+    /**
+    * Handles becoming the leader.
+    */
+    function onBecomeLeader() {
+      console.debug(`[PersistenceManager] Tab ${this.tabId} became leader`);
+      if (this.options.onBecomeLeader) {
+        this.options.onBecomeLeader();
+      }
+    })
+  }, {
+    key: "onLoseLeadership",
+    value: (
+    /**
+    * Handles losing leadership.
+    */
+    function onLoseLeadership() {
+      console.debug(`[PersistenceManager] Tab ${this.tabId} lost leadership`);
+      if (this.leaderCheckInterval) {
+        clearInterval(this.leaderCheckInterval);
+        this.leaderCheckInterval = void 0;
+      }
+      if (this.options.onLoseLeadership) {
+        this.options.onLoseLeadership();
+      }
+    })
+  }, {
+    key: "generateTabId",
+    value: (
+    /**
+    * Generates a unique tab ID.
+    */
+    function generateTabId() {
+      return `tab-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    })
+  }, {
+    /**
+    * Tracks a pending operation.
+    */
+    key: "trackOperation",
+    value: function trackOperation(operation) {
+      var _this = this;
+      this.pendingOperations.add(operation);
+      operation.finally(function () {
+        _this.pendingOperations.delete(operation);
+      }).catch(function () {});
+      return operation;
+    }
+  }, {
+    /**
+    * Gets whether this tab is the leader.
+    */
+    key: "getIsLeader",
+    value: function getIsLeader() {
+      return this.isLeader;
+    }
+  }, {
+    /**
+    * Cleans up timers, event listeners, and channels.
+    */
+    key: "destroy",
+    value: function destroy() {
+      var _this_cleanupVisibilityChange, _this;
+      this.isDestroyed = true;
+      this.saveDebouncer.cancel();
+      if (this.leaderCheckInterval) {
+        clearInterval(this.leaderCheckInterval);
+        this.leaderCheckInterval = void 0;
+      }
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.activeResponseTimers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var timer = _step.value;
+          clearTimeout(timer);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      this.activeResponseTimers.clear();
+      (_this_cleanupVisibilityChange = (_this = this).cleanupVisibilityChange) === null || _this_cleanupVisibilityChange === void 0 ? void 0 : _this_cleanupVisibilityChange.call(_this);
+      this.cleanupVisibilityChange = void 0;
+      if (this.broadcastChannel) {
+        this.broadcastChannel.close();
+        this.broadcastChannel = void 0;
+      }
+      this.pendingOperations.clear();
+    }
+  }]);
+  return PersistenceManager2;
+}();
+export { PersistenceManager };
+//# sourceMappingURL=persistence.native.js.map