@farm.js/core 0.1.0-beta.97 → 0.1.0-beta.98

package/dist/client.cjs

@@ -2470,6 +2470,7 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     const watched = /* @__PURE__ */ new Set();
     for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
     let remaining = false;
+    const swept = /* @__PURE__ */ new Set();
     for (const [key, entry] of this.entries) {
       if (entry.gcAt === void 0) continue;
       if (now2 < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
@@ -2478,9 +2479,28 @@ var _FarmClientDataCache = class _FarmClientDataCache {
       }
       this.entries.delete(key);
       this.persistence?.onDelete(key);
+      swept.add(key);
     }
+    if (swept.size > 0) this.sweepEntryMetadata(swept);
     if (remaining) this.scheduleGcSweep();
   }
+  /**
+   * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
+   * marks and provisional aliases are created per query invocation, so with
+   * dynamic keys they accumulate for the lifetime of the page even though the
+   * entries they describe are long gone.
+   */
+  sweepEntryMetadata(swept) {
+    for (const key of swept) this.invalidatedAt.delete(key);
+    for (const [alias, target] of this.aliases) {
+      if (this.entries.has(alias) || this.listeners.has(alias)) continue;
+      const resolved = this.resolveKey(target);
+      if (!swept.has(resolved)) continue;
+      if (this.entries.has(resolved) || this.listeners.has(resolved)) continue;
+      this.aliases.delete(alias);
+      this.invalidatedAt.delete(alias);
+    }
+  }
   emit(key, event) {
     this.notifyListeners(key, event);
     for (const [alias, target] of this.aliases) {
@@ -2491,7 +2511,12 @@ var _FarmClientDataCache = class _FarmClientDataCache {
   }
   notifyListeners(key, event) {
     for (const listener of this.listeners.get(key) ?? []) {
-      listener(event);
+      try {
+        listener(event);
+      } catch (error) {
+        const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
+      }
     }
   }
 };
@@ -5135,29 +5160,36 @@ __name(useServerQuery, "useServerQuery");
 
 // src/cache-invalidation-broadcast.ts
 var FARM_CACHE_INVALIDATION_CHANNEL = "farm:cache-invalidation";
-var activeBridge;
+var FARM_CACHE_INVALIDATION_BRIDGE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationBridge");
+var bridgeGlobal = globalThis;
 function enableCrossTabCacheInvalidation(options = {}) {
   if (typeof BroadcastChannel !== "function") return () => {
   };
   const channelName = options.channelName ?? FARM_CACHE_INVALIDATION_CHANNEL;
-  if (activeBridge) {
-    if (activeBridge.channelName !== channelName) {
+  const existing = bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE];
+  let bridge;
+  if (existing) {
+    if (existing.channelName !== channelName) {
       throw new Error(
-        `Cross-tab cache invalidation is already enabled on channel "${activeBridge.channelName}".`
+        `Cross-tab cache invalidation is already enabled on channel "${existing.channelName}".`
       );
     }
-    activeBridge.refCount += 1;
+    existing.refCount += 1;
+    bridge = existing;
   } else {
-    activeBridge = createBridge(channelName);
+    bridge = createBridge(channelName);
+    bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] = bridge;
   }
   let disposed = false;
   return () => {
-    if (disposed || !activeBridge) return;
+    if (disposed) return;
     disposed = true;
-    activeBridge.refCount -= 1;
-    if (activeBridge.refCount === 0) {
-      activeBridge.teardown();
-      activeBridge = void 0;
+    bridge.refCount -= 1;
+    if (bridge.refCount === 0) {
+      bridge.teardown();
+      if (bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] === bridge) {
+        bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] = void 0;
+      }
     }
   };
 }
@@ -5365,7 +5397,7 @@ function createSink(engine) {
       scheduleFlush(engine);
     },
     onClear() {
-      if (engine.disabled) return;
+      if (engine.disabled || engine.clearing) return;
       engine.pendingSets.clear();
       engine.pendingDeletes.clear();
       void engine.adapter.clear().catch((error) => disableEngine(engine, error));
@@ -5386,7 +5418,8 @@ function initPersistedClientCache(adapter, options = {}) {
     pendingDeletes: /* @__PURE__ */ new Set(),
     flushTimer: void 0,
     hydrating: false,
-    disabled: false
+    disabled: false,
+    clearing: false
   };
   activeEngine = engine;
   engine.cache.attachPersistence(createSink(engine));
@@ -5401,6 +5434,7 @@ function disposePersistedClientCache() {
   const engine = activeEngine;
   if (!engine) return;
   activeEngine = void 0;
+  engine.disabled = true;
   engine.cache.attachPersistence(void 0);
   if (engine.flushTimer !== void 0) {
     clearTimeout(engine.flushTimer);
@@ -5412,7 +5446,18 @@ function disposePersistedClientCache() {
 __name(disposePersistedClientCache, "disposePersistedClientCache");
 async function clearPersistedCache() {
   const engine = activeEngine;
-  if (!engine) return;
+  if (!engine) {
+    getFarmClientDataCache().clear();
+    return;
+  }
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  engine.clearing = true;
+  try {
+    engine.cache.clear();
+  } finally {
+    engine.clearing = false;
+  }
   engine.pendingSets.clear();
   engine.pendingDeletes.clear();
   try {
@@ -8595,7 +8640,7 @@ body {
 `;
 
 // package.json
-var version = "0.1.0-beta.97";
+var version = "0.1.0-beta.98";
 
 // src/version.ts
 var FARM_VERSION = version;