@multiplatform.one/frappe 6.0.4 → 6.3.0

package/dist/cjs/sync/persistence.spec.cjs

@@ -1,562 +0,0 @@
-var import_vitest = require("vitest");
-var import_persistence = require("./persistence.cjs");
-var import_storage = require("./storage.cjs");
-var import_types = require("./types.cjs");
-import_vitest.vi.mock("./storage", () => ({
-  PlatformStorageKV: import_vitest.vi.fn().mockImplementation(function () {
-    this.getItem = import_vitest.vi.fn().mockResolvedValue(null);
-    this.setItem = import_vitest.vi.fn().mockResolvedValue(void 0);
-    this.removeItem = import_vitest.vi.fn().mockResolvedValue(void 0);
-    return this;
-  }),
-  IndexedDBKV: import_vitest.vi.fn().mockImplementation(function () {
-    this.getItem = import_vitest.vi.fn().mockResolvedValue(null);
-    this.setItem = import_vitest.vi.fn().mockResolvedValue(void 0);
-    this.removeItem = import_vitest.vi.fn().mockResolvedValue(void 0);
-    return this;
-  })
-}));
-(0, import_vitest.describe)("PersistenceManager", () => {
-  let persistenceManager;
-  let mockNormalizedCache;
-  let mockMutationJournal;
-  let mockSubscriptionManager;
-  let mockMutationEngine;
-  let mockStorage;
-  let mockBroadcastChannel;
-  let mockLocalStorage;
-  let mockDocument;
-  (0, import_vitest.beforeEach)(() => {
-    import_vitest.vi.clearAllMocks();
-    import_vitest.vi.useFakeTimers();
-    mockStorage = {
-      getItem: import_vitest.vi.fn().mockResolvedValue(null),
-      setItem: import_vitest.vi.fn().mockResolvedValue(void 0),
-      removeItem: import_vitest.vi.fn().mockResolvedValue(void 0)
-    };
-    mockBroadcastChannel = {
-      postMessage: import_vitest.vi.fn(),
-      close: import_vitest.vi.fn(),
-      onmessage: null
-    };
-    global.BroadcastChannel = import_vitest.vi.fn().mockImplementation(function () {
-      return mockBroadcastChannel;
-    });
-    mockLocalStorage = {
-      getItem: import_vitest.vi.fn().mockReturnValue(null),
-      setItem: import_vitest.vi.fn(),
-      removeItem: import_vitest.vi.fn()
-    };
-    Object.defineProperty(global, "localStorage", {
-      value: mockLocalStorage,
-      writable: true
-    });
-    mockDocument = {
-      hidden: false,
-      addEventListener: import_vitest.vi.fn(),
-      removeEventListener: import_vitest.vi.fn()
-    };
-    Object.defineProperty(global, "document", {
-      value: mockDocument,
-      writable: true
-    });
-    Object.defineProperty(global, "indexedDB", {
-      value: {},
-      writable: true
-    });
-    Object.defineProperty(global, "window", {
-      value: {
-        addEventListener: import_vitest.vi.fn(),
-        removeEventListener: import_vitest.vi.fn()
-      },
-      writable: true
-    });
-    mockNormalizedCache = {
-      state: {
-        docs: {},
-        pages: {}
-      }
-    };
-    mockMutationJournal = {
-      listPending: import_vitest.vi.fn().mockReturnValue([]),
-      add: import_vitest.vi.fn()
-    };
-    mockSubscriptionManager = {
-      getAllSubscriptions: import_vitest.vi.fn().mockReturnValue(/* @__PURE__ */new Map())
-    };
-    mockMutationEngine = {
-      getTemporaryIdToRealNameMap: import_vitest.vi.fn().mockReturnValue(/* @__PURE__ */new Map())
-    };
-    import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
-    import_vitest.vi.spyOn(console, "debug").mockImplementation(() => {});
-  });
-  (0, import_vitest.afterEach)(() => {
-    if (persistenceManager) {
-      persistenceManager.destroy();
-      persistenceManager = void 0;
-    }
-    import_vitest.vi.restoreAllMocks();
-    import_vitest.vi.useRealTimers();
-    global.BroadcastChannel = void 0;
-    global.localStorage = void 0;
-    global.document = void 0;
-    global.indexedDB = void 0;
-    global.window = void 0;
-  });
-  (0, import_vitest.describe)("constructor and initialization", () => {
-    (0, import_vitest.it)("should initialize without persistence when no persistKey provided", () => {
-      const options = {};
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(import_storage.PlatformStorageKV).not.toHaveBeenCalled();
-      (0, import_vitest.expect)(import_storage.IndexedDBKV).not.toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should initialize with IndexedDB when available", () => {
-      const options = {
-        persistKey: "test-key"
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(import_storage.IndexedDBKV).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should fallback to PlatformStorageKV when IndexedDB not available", () => {
-      global.indexedDB = void 0;
-      const options = {
-        persistKey: "test-key"
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(import_storage.PlatformStorageKV).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should use provided storage when specified", () => {
-      const options = {
-        persistKey: "test-key",
-        storage: mockStorage
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(import_storage.PlatformStorageKV).not.toHaveBeenCalled();
-      (0, import_vitest.expect)(import_storage.IndexedDBKV).not.toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should setup BroadcastChannel when persistKey provided", () => {
-      const options = {
-        persistKey: "test-key"
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(global.BroadcastChannel).toHaveBeenCalledWith("frappe-sync:test-key");
-    });
-    (0, import_vitest.it)("should not setup BroadcastChannel when not available", () => {
-      global.BroadcastChannel = void 0;
-      const options = {
-        persistKey: "test-key"
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(persistenceManager).toBeDefined();
-    });
-    (0, import_vitest.it)("should setup tab coordination with default config", () => {
-      const options = {
-        persistKey: "test-key"
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(mockDocument.addEventListener).toHaveBeenCalledWith("visibilitychange", import_vitest.expect.any(Function));
-    });
-    (0, import_vitest.it)("should not setup tab coordination when disabled", () => {
-      const options = {
-        persistKey: "test-key",
-        tabCoordination: {
-          activeTabPriority: false
-        }
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(mockDocument.addEventListener).not.toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should use custom tab coordination config", () => {
-      const options = {
-        persistKey: "test-key",
-        tabCoordination: {
-          activeTabPriority: true,
-          leaderTimeout: 1e4,
-          handoffGracePeriod: 3e3
-        }
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      (0, import_vitest.expect)(persistenceManager).toBeDefined();
-    });
-  });
-  (0, import_vitest.describe)("persistence operations", () => {
-    (0, import_vitest.beforeEach)(() => {
-      const options = {
-        persistKey: "test-key",
-        storage: mockStorage
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-    });
-    (0, import_vitest.describe)("scheduleSave", () => {
-      (0, import_vitest.it)("should schedule a debounced save operation", () => {
-        persistenceManager.scheduleSave();
-        (0, import_vitest.expect)(mockStorage.setItem).not.toHaveBeenCalled();
-        import_vitest.vi.advanceTimersByTime(50);
-        (0, import_vitest.expect)(mockStorage.setItem).toHaveBeenCalledWith("test-key", import_vitest.expect.any(String));
-      });
-      (0, import_vitest.it)("should debounce multiple scheduleSave calls", () => {
-        persistenceManager.scheduleSave();
-        persistenceManager.scheduleSave();
-        persistenceManager.scheduleSave();
-        import_vitest.vi.advanceTimersByTime(50);
-        (0, import_vitest.expect)(mockStorage.setItem).toHaveBeenCalledTimes(1);
-      });
-      (0, import_vitest.it)("should not schedule save without persistKey", () => {
-        const options = {};
-        const pm = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-        pm.scheduleSave();
-        import_vitest.vi.advanceTimersByTime(50);
-        (0, import_vitest.expect)(mockStorage.setItem).not.toHaveBeenCalled();
-      });
-    });
-    (0, import_vitest.describe)("save", () => {
-      (0, import_vitest.it)("should save complete snapshot", async () => {
-        const mockSubscriptions = /* @__PURE__ */new Map([["sub1", {
-          id: "sub1",
-          query: {
-            doctype: "User"
-          },
-          checkpoint: "checkpoint1",
-          docIds: ["user1", "user2"]
-        }]]);
-        const mockJournalEntries = [{
-          id: "entry1",
-          entry: {
-            doctype: "TestDoc",
-            operation: import_types.Operation.Create,
-            status: import_types.Status.Pending,
-            values: {
-              doctype: "TestDoc",
-              name: "test1"
-            }
-          }
-        }];
-        const mockTempMappings = /* @__PURE__ */new Map([["temp1", "real1"]]);
-        mockSubscriptionManager.getAllSubscriptions.mockReturnValue(mockSubscriptions);
-        mockMutationJournal.listPending.mockReturnValue(mockJournalEntries);
-        mockMutationEngine.getTemporaryIdToRealNameMap.mockReturnValue(mockTempMappings);
-        persistenceManager.scheduleSave();
-        import_vitest.vi.advanceTimersByTime(50);
-        const savedData = JSON.parse(mockStorage.setItem.mock.calls[0][1]);
-        (0, import_vitest.expect)(savedData).toEqual({
-          subs: [{
-            id: "sub1",
-            query: {
-              doctype: "User"
-            },
-            checkpoint: "checkpoint1",
-            docIds: ["user1", "user2"]
-          }],
-          cache: mockNormalizedCache.state,
-          journal: mockJournalEntries,
-          temp: [["temp1", "real1"]]
-        });
-      });
-      (0, import_vitest.it)("should handle save errors gracefully", async () => {
-        mockStorage.setItem.mockRejectedValue(new Error("Save failed"));
-        persistenceManager.scheduleSave();
-        import_vitest.vi.advanceTimersByTime(50);
-        await import_vitest.vi.advanceTimersByTimeAsync(100);
-        (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith("Failed to save sync state:", import_vitest.expect.any(Error));
-      });
-    });
-    (0, import_vitest.describe)("load", () => {
-      (0, import_vitest.it)("should load and restore persisted state", async () => {
-        const persistedState = {
-          subs: [{
-            id: "sub1",
-            query: {
-              doctype: "User"
-            },
-            checkpoint: "checkpoint1",
-            docIds: ["user1", "user2"]
-          }],
-          cache: {
-            docs: {
-              user1: {
-                name: "User 1"
-              }
-            }
-          },
-          journal: [{
-            id: "entry1",
-            entry: {
-              type: "create"
-            }
-          }],
-          temp: [["temp1", "real1"]]
-        };
-        mockStorage.getItem.mockResolvedValue(JSON.stringify(persistedState));
-        const subscriptionsMap = /* @__PURE__ */new Map();
-        const tempMap = /* @__PURE__ */new Map();
-        mockSubscriptionManager.getAllSubscriptions.mockReturnValue(subscriptionsMap);
-        mockMutationEngine.getTemporaryIdToRealNameMap.mockReturnValue(tempMap);
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          storage: mockStorage
-        });
-        await import_vitest.vi.advanceTimersByTimeAsync(100);
-        (0, import_vitest.expect)(mockNormalizedCache.state).toEqual(persistedState.cache);
-        (0, import_vitest.expect)(subscriptionsMap.get("sub1")).toEqual(persistedState.subs[0]);
-        (0, import_vitest.expect)(mockMutationJournal.add).toHaveBeenCalledWith("entry1", {
-          type: "create"
-        });
-        (0, import_vitest.expect)(tempMap.get("temp1")).toBe("real1");
-      });
-      (0, import_vitest.it)("should handle missing persisted state", async () => {
-        mockStorage.getItem.mockResolvedValue(null);
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          storage: mockStorage
-        });
-        await import_vitest.vi.advanceTimersByTimeAsync(100);
-        (0, import_vitest.expect)(mockMutationJournal.add).not.toHaveBeenCalled();
-      });
-      (0, import_vitest.it)("should handle corrupted persisted state", async () => {
-        mockStorage.getItem.mockResolvedValue("invalid json");
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          storage: mockStorage
-        });
-        await import_vitest.vi.advanceTimersByTimeAsync(100);
-        (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith("Failed to load sync state:", import_vitest.expect.any(Error));
-      });
-      (0, import_vitest.it)("should handle load errors gracefully", async () => {
-        mockStorage.getItem.mockRejectedValue(new Error("Load failed"));
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          storage: mockStorage
-        });
-        await import_vitest.vi.advanceTimersByTimeAsync(100);
-        (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith("Failed to load sync state:", import_vitest.expect.any(Error));
-      });
-    });
-  });
-  (0, import_vitest.describe)("BroadcastChannel operations", () => {
-    (0, import_vitest.beforeEach)(() => {
-      const options = {
-        persistKey: "test-key"
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-    });
-    (0, import_vitest.it)("should handle reset message", () => {
-      const onResetCache = import_vitest.vi.fn();
-      const options = {
-        persistKey: "test-key",
-        onResetCache
-      };
-      const _pm = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      mockBroadcastChannel.onmessage({
-        data: "reset"
-      });
-      (0, import_vitest.expect)(onResetCache).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should handle backfill message", () => {
-      const onBackfillAll = import_vitest.vi.fn();
-      const options = {
-        persistKey: "test-key",
-        onBackfillAll
-      };
-      const _pm = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-      mockBroadcastChannel.onmessage({
-        data: "backfill"
-      });
-      (0, import_vitest.expect)(onBackfillAll).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should broadcast reset message", () => {
-      persistenceManager.broadcastReset();
-      (0, import_vitest.expect)(mockBroadcastChannel.postMessage).toHaveBeenCalledWith("reset");
-    });
-    (0, import_vitest.it)("should broadcast backfill message", () => {
-      persistenceManager.broadcastBackfill();
-      (0, import_vitest.expect)(mockBroadcastChannel.postMessage).toHaveBeenCalledWith("backfill");
-    });
-    (0, import_vitest.it)("should broadcast change message", () => {
-      persistenceManager.broadcastChange();
-      (0, import_vitest.expect)(mockBroadcastChannel.postMessage).toHaveBeenCalledWith("changed");
-    });
-  });
-  (0, import_vitest.describe)("tab coordination", () => {
-    (0, import_vitest.beforeEach)(() => {
-      const options = {
-        persistKey: "test-key",
-        tabCoordination: {
-          activeTabPriority: true,
-          leaderTimeout: 5e3,
-          handoffGracePeriod: 2e3
-        }
-      };
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, options);
-    });
-    (0, import_vitest.it)("should become leader when no existing leader", () => {
-      mockLocalStorage.getItem.mockReturnValue(null);
-      (0, import_vitest.expect)(mockLocalStorage.setItem).toHaveBeenCalledWith("frappe-sync-leader", import_vitest.expect.stringContaining('"tabId":"tab-'));
-    });
-    (0, import_vitest.it)("should not become leader when active leader exists", () => {
-      const activeLeader = {
-        tabId: "other-tab",
-        timestamp: Date.now(),
-        visibilityState: "visible",
-        lastVisibilityChange: Date.now()
-      };
-      mockLocalStorage.getItem.mockReturnValue(JSON.stringify(activeLeader));
-      mockLocalStorage.setItem.mockClear();
-      new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-        persistKey: "test-key",
-        tabCoordination: {
-          activeTabPriority: true
-        }
-      });
-      (0, import_vitest.expect)(mockLocalStorage.setItem).not.toHaveBeenCalledWith("frappe-sync-leader", import_vitest.expect.any(String));
-    });
-    (0, import_vitest.it)("should take over leadership from expired leader", () => {
-      const expiredLeader = {
-        tabId: "expired-tab",
-        timestamp: Date.now() - 1e4,
-        // 10 seconds ago
-        visibilityState: "visible",
-        lastVisibilityChange: Date.now() - 1e4
-      };
-      mockLocalStorage.getItem.mockReturnValue(JSON.stringify(expiredLeader));
-      (0, import_vitest.expect)(mockLocalStorage.setItem).toHaveBeenCalledWith("frappe-sync-leader", import_vitest.expect.stringContaining('"tabId":"tab-'));
-    });
-    (0, import_vitest.it)("should handle visibility changes", () => {
-      mockDocument.hidden = false;
-      const visibilityHandler = mockDocument.addEventListener.mock.calls.find(call => call[0] === "visibilitychange")?.[1];
-      (0, import_vitest.expect)(visibilityHandler).toBeDefined();
-      mockDocument.hidden = true;
-      visibilityHandler();
-      mockDocument.hidden = false;
-      visibilityHandler();
-      (0, import_vitest.expect)(visibilityHandler).toBeDefined();
-    });
-    (0, import_vitest.it)("should handle localStorage unavailability", () => {
-      global.localStorage = void 0;
-      (0, import_vitest.expect)(() => {
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          tabCoordination: {
-            activeTabPriority: true
-          }
-        });
-      }).not.toThrow();
-    });
-    (0, import_vitest.it)("should call leadership callbacks", () => {
-      const onBecomeLeader = import_vitest.vi.fn();
-      const onLoseLeadership = import_vitest.vi.fn();
-      mockLocalStorage.getItem.mockReturnValue(null);
-      new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-        persistKey: "test-key",
-        tabCoordination: {
-          activeTabPriority: true
-        },
-        onBecomeLeader,
-        onLoseLeadership
-      });
-      (0, import_vitest.expect)(onBecomeLeader).toHaveBeenCalled();
-    });
-  });
-  (0, import_vitest.describe)("operation tracking", () => {
-    (0, import_vitest.beforeEach)(() => {
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-        persistKey: "test-key"
-      });
-    });
-    (0, import_vitest.it)("should track and untrack operations", async () => {
-      const operation = Promise.resolve("result");
-      const trackedOperation = persistenceManager.trackOperation(operation);
-      (0, import_vitest.expect)(trackedOperation).toBe(operation);
-      await trackedOperation;
-      (0, import_vitest.expect)(trackedOperation).resolves.toBe("result");
-    });
-    (0, import_vitest.it)("should track rejected operations", async () => {
-      const operation = Promise.reject(new Error("Operation failed"));
-      const trackedOperation = persistenceManager.trackOperation(operation);
-      await (0, import_vitest.expect)(trackedOperation).rejects.toThrow("Operation failed");
-    });
-  });
-  (0, import_vitest.describe)("getIsLeader", () => {
-    (0, import_vitest.it)("should return current leadership status", () => {
-      mockLocalStorage.getItem.mockReturnValue(null);
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-        persistKey: "test-key"
-      });
-      (0, import_vitest.expect)(persistenceManager.getIsLeader()).toBe(true);
-    });
-  });
-  (0, import_vitest.describe)("destroy", () => {
-    (0, import_vitest.beforeEach)(() => {
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-        persistKey: "test-key"
-      });
-    });
-    (0, import_vitest.it)("should clean up timers and channels", () => {
-      persistenceManager.scheduleSave();
-      persistenceManager.destroy();
-      import_vitest.vi.advanceTimersByTime(50);
-      (0, import_vitest.expect)(mockBroadcastChannel.close).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should handle destroy without active resources", () => {
-      const pm = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {});
-      (0, import_vitest.expect)(() => pm.destroy()).not.toThrow();
-    });
-  });
-  (0, import_vitest.describe)("error handling", () => {
-    (0, import_vitest.it)("should handle BroadcastChannel constructor errors", () => {
-      global.BroadcastChannel.mockImplementation(function () {
-        throw new Error("BroadcastChannel failed");
-      });
-      (0, import_vitest.expect)(() => {
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key"
-        });
-      }).not.toThrow();
-    });
-    (0, import_vitest.it)("should handle localStorage setItem errors", () => {
-      mockLocalStorage.setItem.mockImplementation(() => {
-        throw new Error("Storage quota exceeded");
-      });
-      (0, import_vitest.expect)(() => {
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          tabCoordination: {
-            activeTabPriority: true
-          }
-        });
-      }).not.toThrow();
-      (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith(import_vitest.expect.stringContaining("Failed to update leader timestamp"), import_vitest.expect.any(Error));
-    });
-    (0, import_vitest.it)("should handle localStorage getItem errors", () => {
-      mockLocalStorage.getItem.mockImplementation(() => {
-        throw new Error("Storage access denied");
-      });
-      (0, import_vitest.expect)(() => {
-        new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-          persistKey: "test-key",
-          tabCoordination: {
-            activeTabPriority: true
-          }
-        });
-      }).not.toThrow();
-    });
-  });
-  (0, import_vitest.describe)("message handling", () => {
-    (0, import_vitest.beforeEach)(() => {
-      persistenceManager = new import_persistence.PersistenceManager(mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockMutationEngine, {
-        persistKey: "test-key"
-      });
-    });
-    (0, import_vitest.it)("should handle malformed broadcast messages", () => {
-      (0, import_vitest.expect)(() => {
-        mockBroadcastChannel.onmessage({
-          data: null
-        });
-        mockBroadcastChannel.onmessage({
-          data: void 0
-        });
-        mockBroadcastChannel.onmessage({});
-        mockBroadcastChannel.onmessage(null);
-      }).not.toThrow();
-    });
-  });
-});