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

package/dist/server-query-client.cjs

@@ -101,7 +101,13 @@ function recordFarmEventTrace(event) {
       activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
     }
     const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) recordSpanError(activeSpan, error);
+    if (error !== void 0) {
+      if (event.type === "render.error") {
+        recordSpanException(activeSpan, error);
+      } else {
+        recordSpanError(activeSpan, error);
+      }
+    }
   }
   const completedTraceContext = recordCompletedEventSpan(event, activeContext);
   return traceContext ?? completedTraceContext;
@@ -198,12 +204,26 @@ function getCompletedSpanDescriptor(event) {
   }
 }
 __name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
+function hashFarmCacheKey(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+__name(hashFarmCacheKey, "hashFarmCacheKey");
 function toEventAttributes(event) {
   const attributes = {};
+  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
   for (const [key, value] of Object.entries(event)) {
     if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
       continue;
     }
+    if (redactKey && key === "key" && typeof value === "string") {
+      attributes["farm.key_hash"] = hashFarmCacheKey(value);
+      continue;
+    }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
       attributes[`farm.${key}`] = value;
     } else if (Array.isArray(value)) {
@@ -223,9 +243,14 @@ function getEventError(event) {
   return "error" in event ? event.error : void 0;
 }
 __name(getEventError, "getEventError");
-function recordSpanError(span, error) {
+function recordSpanException(span, error) {
   const normalized = error instanceof Error ? error : new Error(String(error));
   span.recordException(normalized);
+  return normalized;
+}
+__name(recordSpanException, "recordSpanException");
+function recordSpanError(span, error) {
+  const normalized = recordSpanException(span, error);
   span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
 }
 __name(recordSpanError, "recordSpanError");
@@ -1037,6 +1062,31 @@ function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
 __name(stableSerialize, "stableSerialize");
 
 // src/client-cache.ts
+var invalidationTrackers = /* @__PURE__ */ new WeakMap();
+function trackFarmClientCacheInvalidations(cache) {
+  let trackers = invalidationTrackers.get(cache);
+  if (!trackers) {
+    trackers = /* @__PURE__ */ new Set();
+    invalidationTrackers.set(cache, trackers);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  trackers.add(keys);
+  return {
+    has(key) {
+      const resolved = cache.resolveKey(key);
+      for (const invalidated of keys) {
+        if (cache.resolveKey(invalidated) === resolved) return true;
+      }
+      return false;
+    },
+    dispose() {
+      if (!trackers.delete(keys)) return;
+      keys.clear();
+      if (trackers.size === 0) invalidationTrackers.delete(cache);
+    }
+  };
+}
+__name(trackFarmClientCacheInvalidations, "trackFarmClientCacheInvalidations");
 var cacheFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((unsubscribe) => unsubscribe()) : void 0;
 function subscribeWeakCache(reference) {
   const unsubscribe = subscribeFarmCacheInvalidation((key) => {
@@ -1052,6 +1102,7 @@ function subscribeWeakCache(reference) {
   return dispose;
 }
 __name(subscribeWeakCache, "subscribeWeakCache");
+var DEFAULT_GC_SWEEP_INTERVAL_MS = 3e4;
 var _FarmClientDataCache = class _FarmClientDataCache {
   constructor(options = {}) {
     this.entries = /* @__PURE__ */ new Map();
@@ -1059,6 +1110,7 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     this.invalidatedAt = /* @__PURE__ */ new Map();
     this.listeners = /* @__PURE__ */ new Map();
     this.inflight = /* @__PURE__ */ new Map();
+    this.gcSweepIntervalMs = options.gcSweepIntervalMs ?? DEFAULT_GC_SWEEP_INTERVAL_MS;
     if (options.subscribeToInvalidation !== false) {
       if (typeof WeakRef === "function") {
         const reference = new WeakRef(this);
@@ -1075,6 +1127,10 @@ var _FarmClientDataCache = class _FarmClientDataCache {
   get size() {
     return this.entries.size;
   }
+  /** @internal Attach or detach the persistence engine's observation sink. */
+  attachPersistence(sink) {
+    this.persistence = sink;
+  }
   resolveKey(key) {
     let resolved = key;
     const seen = /* @__PURE__ */ new Set();
@@ -1090,6 +1146,7 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     if (!entry) return void 0;
     if (entry.gcAt !== void 0 && now >= entry.gcAt) {
       this.entries.delete(resolved);
+      this.persistence?.onDelete(resolved);
       this.emit(resolved);
       return void 0;
     }
@@ -1103,6 +1160,8 @@ var _FarmClientDataCache = class _FarmClientDataCache {
       this.invalidatedAt.delete(resolved);
     }
     this.entries.set(resolved, nextEntry);
+    if (nextEntry.gcAt !== void 0) this.scheduleGcSweep();
+    this.persistence?.onSet(resolved, nextEntry);
     this.emit(resolved);
     return this;
   }
@@ -1110,6 +1169,7 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     const resolved = this.resolveKey(key);
     const deleted = this.entries.delete(resolved);
     this.inflight.delete(resolved);
+    if (deleted) this.persistence?.onDelete(resolved);
     this.emit(resolved);
     return deleted;
   }
@@ -1119,11 +1179,16 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     this.aliases.clear();
     this.invalidatedAt.clear();
     this.inflight.clear();
+    this.persistence?.onClear();
     for (const key of keys) this.emit(key);
   }
   dispose() {
     this.unsubscribeInvalidation?.();
     this.unsubscribeInvalidation = void 0;
+    if (this.gcTimer !== void 0) {
+      clearTimeout(this.gcTimer);
+      this.gcTimer = void 0;
+    }
     this.clear();
   }
   isStale(key, now = Date.now()) {
@@ -1132,6 +1197,7 @@ var _FarmClientDataCache = class _FarmClientDataCache {
   }
   invalidate(key, now = Date.now()) {
     const resolved = this.resolveKey(key);
+    for (const keys of invalidationTrackers.get(this) ?? []) keys.add(resolved);
     this.invalidatedAt.set(resolved, now);
     const entry = this.entries.get(resolved);
     if (entry) {
@@ -1151,8 +1217,9 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
     if (aliasEntry && !this.entries.has(resolved)) {
       this.entries.set(resolved, aliasEntry);
+      this.persistence?.onSet(resolved, aliasEntry);
     }
-    this.entries.delete(alias);
+    if (this.entries.delete(alias)) this.persistence?.onDelete(alias);
     this.invalidatedAt.delete(alias);
     const invalidatedAt = [aliasInvalidatedAt, resolvedInvalidatedAt].reduce(
       (latest, value) => value === void 0 ? latest : latest === void 0 ? value : Math.max(latest, value),
@@ -1192,7 +1259,9 @@ var _FarmClientDataCache = class _FarmClientDataCache {
     listeners.add(listener);
     return () => {
       listeners.delete(listener);
-      if (listeners.size === 0) this.listeners.delete(key);
+      if (listeners.size === 0 && this.listeners.get(key) === listeners) {
+        this.listeners.delete(key);
+      }
     };
   }
   getInflight(key) {
@@ -1204,6 +1273,30 @@ var _FarmClientDataCache = class _FarmClientDataCache {
   deleteInflight(key) {
     this.inflight.delete(this.resolveKey(key));
   }
+  scheduleGcSweep() {
+    if (this.gcSweepIntervalMs === false || this.gcTimer !== void 0) return;
+    const timer = setTimeout(() => {
+      this.gcTimer = void 0;
+      this.sweepExpiredEntries();
+    }, this.gcSweepIntervalMs);
+    timer.unref?.();
+    this.gcTimer = timer;
+  }
+  sweepExpiredEntries(now = Date.now()) {
+    const watched = /* @__PURE__ */ new Set();
+    for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
+    let remaining = false;
+    for (const [key, entry] of this.entries) {
+      if (entry.gcAt === void 0) continue;
+      if (now < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
+        remaining = true;
+        continue;
+      }
+      this.entries.delete(key);
+      this.persistence?.onDelete(key);
+    }
+    if (remaining) this.scheduleGcSweep();
+  }
   emit(key, event) {
     this.notifyListeners(key, event);
     for (const [alias, target] of this.aliases) {
@@ -1228,6 +1321,21 @@ function getFarmClientDataCache() {
 }
 __name(getFarmClientDataCache, "getFarmClientDataCache");
 
+// src/client-revalidation.ts
+function attachRevalidationListeners(refresh, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
+  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
+  if (onFocus) window.addEventListener("focus", onFocus);
+  if (onOnline) window.addEventListener("online", onOnline);
+  return () => {
+    if (onFocus) window.removeEventListener("focus", onFocus);
+    if (onOnline) window.removeEventListener("online", onOnline);
+  };
+}
+__name(attachRevalidationListeners, "attachRevalidationListeners");
+
 // src/server-query-protocol.ts
 var FARM_SERVER_QUERY_RESULT_VERSION = 1;
 function isFarmServerQueryResult(value) {
@@ -1244,9 +1352,30 @@ var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_ST
   functionIds: /* @__PURE__ */ new WeakMap(),
   nextFunctionId: 0,
   active: [],
-  latestOwners: /* @__PURE__ */ new Map()
+  latestOwners: /* @__PURE__ */ new Map(),
+  owners: /* @__PURE__ */ new Set()
 });
 serverQueryClientState.latestOwners ?? (serverQueryClientState.latestOwners = /* @__PURE__ */ new Map());
+serverQueryClientState.owners ?? (serverQueryClientState.owners = /* @__PURE__ */ new Set());
+function isServerQueryOwnerSuperseded(owner, key) {
+  const cache = getFarmClientDataCache();
+  const resolved = cache.resolveKey(key);
+  for (const superseded of owner.supersededKeys ?? []) {
+    if (cache.resolveKey(superseded) === resolved) return true;
+  }
+  return false;
+}
+__name(isServerQueryOwnerSuperseded, "isServerQueryOwnerSuperseded");
+function claimServerQueryKey(owner, key) {
+  if (isServerQueryOwnerSuperseded(owner, key)) return false;
+  const resolved = getFarmClientDataCache().resolveKey(key);
+  for (const older of serverQueryClientState.owners) {
+    if (older === owner) break;
+    older.supersededKeys.add(resolved);
+  }
+  return true;
+}
+__name(claimServerQueryKey, "claimServerQueryKey");
 var RAW_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
 function assertNotRawServerQueryInBrowser(query) {
   if (typeof window === "undefined" || typeof document === "undefined") return;
@@ -1280,22 +1409,34 @@ function completeFarmServerQueryAction(invocation, value) {
   if (invocation.provisionalKey) {
     cache.alias(invocation.provisionalKey, metadata.key);
   }
+  const owner = invocation.owner;
+  if (owner && serverQueryClientState.owners.has(owner) && !claimServerQueryKey(owner, metadata.key)) {
+    return value.data;
+  }
+  const invalidated = invocation.owner?.invalidations?.has(
+    metadata.key
+  );
   cache.set(metadata.key, {
     data: value.data,
     updatedAt: metadata.updatedAt,
-    staleAt: metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
+    staleAt: invalidated ? 0 : metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
     status: "success",
     error: null,
-    fetching: false
+    fetching: false,
+    persist: metadata.persist === true ? true : void 0
   });
   return value.data;
 }
 __name(completeFarmServerQueryAction, "completeFarmServerQueryAction");
 function shouldApplyFarmServerQueryActionResult(invocation) {
   if (!invocation.provisionalKey || !invocation.owner) return true;
-  return serverQueryClientState.latestOwners.get(invocation.provisionalKey) === invocation.owner;
+  return isCurrentServerQueryOwner(invocation.provisionalKey, invocation.owner);
 }
 __name(shouldApplyFarmServerQueryActionResult, "shouldApplyFarmServerQueryActionResult");
+function isCurrentServerQueryOwner(provisionalKey, owner) {
+  return serverQueryClientState.latestOwners.get(provisionalKey) === owner && !isServerQueryOwnerSuperseded(owner, provisionalKey);
+}
+__name(isCurrentServerQueryOwner, "isCurrentServerQueryOwner");
 function createServerQueryCallKey(query, input) {
   let id = serverQueryClientState.functionIds.get(query);
   if (!id) {
@@ -1311,12 +1452,14 @@ async function fetchServerQuery(query, input, options = {}) {
   const entry = cache.get(provisionalKey);
   const stale = cache.isStale(provisionalKey);
   const inflight = cache.getInflight(provisionalKey);
-  if (inflight && !options.force) return inflight;
-  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
-  if (!options.force && entry && stale && entry.status !== "pending" && entry.status !== "error" && (options.swr ?? true)) {
-    void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+  if (!options.force && entry && stale && (entry.status !== "pending" || entry.updatedAt !== 0) && entry.status !== "error" && (options.swr ?? true)) {
+    if (!inflight) {
+      void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+    }
     return entry.data;
   }
+  if (inflight && !options.force) return inflight;
+  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
   return executeServerQuery(query, input, provisionalKey, options);
 }
 __name(fetchServerQuery, "fetchServerQuery");
@@ -1329,8 +1472,13 @@ async function executeServerQuery(query, input, provisionalKey, options) {
   const cache = getFarmClientDataCache();
   const inflight = cache.getInflight(provisionalKey);
   if (inflight && !options.force) return inflight;
-  const owner = {};
+  const owner = {
+    invalidations: trackFarmClientCacheInvalidations(cache),
+    supersededKeys: /* @__PURE__ */ new Set()
+  };
   serverQueryClientState.latestOwners.set(provisionalKey, owner);
+  serverQueryClientState.owners.add(owner);
+  claimServerQueryKey(owner, provisionalKey);
   const previous = cache.get(provisionalKey);
   cache.set(provisionalKey, {
     data: previous?.data,
@@ -1355,12 +1503,12 @@ async function executeServerQuery(query, input, provisionalKey, options) {
       }
       const data = await pending;
       const transported = cache.get(provisionalKey);
-      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner && (!transported || transported.fetching)) {
+      if (isCurrentServerQueryOwner(provisionalKey, owner) && (!transported || transported.fetching)) {
         const updatedAt = Date.now();
         cache.set(provisionalKey, {
           data,
           updatedAt,
-          staleAt: options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
+          staleAt: owner.invalidations.has(provisionalKey) ? 0 : options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
           status: "success",
           error: null,
           fetching: false
@@ -1369,7 +1517,7 @@ async function executeServerQuery(query, input, provisionalKey, options) {
       return data;
     } catch (cause) {
       const error = normalizeServerQueryError(cause);
-      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
+      if (isCurrentServerQueryOwner(provisionalKey, owner)) {
         const current = cache.get(provisionalKey);
         cache.set(provisionalKey, {
           data: current?.data,
@@ -1384,12 +1532,17 @@ async function executeServerQuery(query, input, provisionalKey, options) {
       }
       throw error;
     } finally {
+      const invalidated = isCurrentServerQueryOwner(provisionalKey, owner) && owner.invalidations.has(provisionalKey);
+      owner.invalidations.dispose();
+      serverQueryClientState.owners.delete(owner);
+      owner.supersededKeys.clear();
       if (cache.getInflight(provisionalKey) === promise) {
         cache.deleteInflight(provisionalKey);
       }
       if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
         serverQueryClientState.latestOwners.delete(provisionalKey);
       }
+      if (invalidated) cache.invalidate(provisionalKey);
     }
   })();
   cache.setInflight(provisionalKey, promise);
@@ -1411,19 +1564,29 @@ function useServerQuery(query, input, options = {}) {
   const inputRef = (0, import_react.useRef)(input);
   const optionsRef = (0, import_react.useRef)(options);
   const mountedKeyRef = (0, import_react.useRef)(void 0);
+  const pendingInvalidationRef = (0, import_react.useRef)(false);
   inputRef.current = input;
   optionsRef.current = options;
   const subscribe = (0, import_react.useCallback)(
-    (listener) => cache.subscribe(key, listener),
+    (listener) => cache.subscribe(key, (event) => {
+      if (event === "invalidate") pendingInvalidationRef.current = true;
+      else if (cache.get(key)?.fetching) {
+        pendingInvalidationRef.current = false;
+      }
+      listener();
+    }),
     [cache, key]
   );
   const getSnapshot = (0, import_react.useCallback)(() => cache.get(key), [cache, key]);
   const entry = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
   const run = (0, import_react.useCallback)(
-    (force = false) => fetchServerQuery(query, inputRef.current, {
-      ...optionsRef.current,
-      force
-    }),
+    (force = false) => {
+      pendingInvalidationRef.current = false;
+      return fetchServerQuery(query, inputRef.current, {
+        ...optionsRef.current,
+        force
+      });
+    },
     [query]
   );
   (0, import_react.useEffect)(() => {
@@ -1433,23 +1596,21 @@ function useServerQuery(query, input, options = {}) {
     }
     const firstReadForKey = mountedKeyRef.current !== key;
     if (firstReadForKey) mountedKeyRef.current = key;
-    if (firstReadForKey && (!entry || cache.isStale(key)) || entry?.invalidatedAt !== void 0 && !entry.fetching) {
+    if (firstReadForKey && (!entry || cache.isStale(key)) || pendingInvalidationRef.current && entry?.invalidatedAt !== void 0 && !entry.fetching) {
       void run().catch(() => void 0);
     }
   }, [cache, entry, key, options.enabled, run]);
   (0, import_react.useEffect)(() => {
-    if (options.enabled === false || typeof window === "undefined") return;
-    const refreshIfStale = /* @__PURE__ */ __name(() => {
-      if (cache.isStale(key)) void run().catch(() => void 0);
-    }, "refreshIfStale");
-    const onFocus = options.refetchOnWindowFocus === false ? void 0 : refreshIfStale;
-    const onOnline = options.refetchOnReconnect === false ? void 0 : refreshIfStale;
-    if (onFocus) window.addEventListener("focus", onFocus);
-    if (onOnline) window.addEventListener("online", onOnline);
-    return () => {
-      if (onFocus) window.removeEventListener("focus", onFocus);
-      if (onOnline) window.removeEventListener("online", onOnline);
-    };
+    if (options.enabled === false) return;
+    return attachRevalidationListeners(
+      () => {
+        if (cache.isStale(key)) void run().catch(() => void 0);
+      },
+      {
+        refetchOnWindowFocus: options.refetchOnWindowFocus,
+        refetchOnReconnect: options.refetchOnReconnect
+      }
+    );
   }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
   const status = entry?.status ?? (entry ? "success" : "idle");
   const fetching = entry?.fetching ?? false;

package/dist/server-query-client.d.mts

@@ -1,7 +1,7 @@
-import { F as FarmClientCacheStatus } from './client-cache-CopR_MaI.mjs';
+import { F as FarmClientCacheStatus } from './client-cache-CCK-fCe0.mjs';
 import { ServerQuery } from './server-query.mjs';
-import { S as ServerQueryFetchOptions } from './server-query-runtime-B50KAcj5.mjs';
-export { F as FarmServerQueryActionInvocation, b as beginFarmServerQueryAction, c as completeFarmServerQueryAction, f as fetchServerQuery, p as prefetchServerQuery, s as shouldApplyFarmServerQueryActionResult } from './server-query-runtime-B50KAcj5.mjs';
+import { S as ServerQueryFetchOptions } from './server-query-runtime-aP52iuL5.mjs';
+export { F as FarmServerQueryActionInvocation, b as beginFarmServerQueryAction, c as completeFarmServerQueryAction, f as fetchServerQuery, p as prefetchServerQuery, s as shouldApplyFarmServerQueryActionResult } from './server-query-runtime-aP52iuL5.mjs';
 import './cache.mjs';
 import './server-fn.mjs';
 import './server-fn-error-DDh14a0V.mjs';

package/dist/server-query-client.d.ts

@@ -1,7 +1,7 @@
-import { F as FarmClientCacheStatus } from './client-cache-Djy_TlE8.js';
+import { F as FarmClientCacheStatus } from './client-cache-BMxuFqwH.js';
 import { ServerQuery } from './server-query.js';
-import { S as ServerQueryFetchOptions } from './server-query-runtime-3zAj77yv.js';
-export { F as FarmServerQueryActionInvocation, b as beginFarmServerQueryAction, c as completeFarmServerQueryAction, f as fetchServerQuery, p as prefetchServerQuery, s as shouldApplyFarmServerQueryActionResult } from './server-query-runtime-3zAj77yv.js';
+import { S as ServerQueryFetchOptions } from './server-query-runtime-DXRNhX_3.js';
+export { F as FarmServerQueryActionInvocation, b as beginFarmServerQueryAction, c as completeFarmServerQueryAction, f as fetchServerQuery, p as prefetchServerQuery, s as shouldApplyFarmServerQueryActionResult } from './server-query-runtime-DXRNhX_3.js';
 import './cache.js';
 import './server-fn.js';
 import './server-fn-error-DDh14a0V.js';

package/dist/server-query-client.mjs

@@ -1,20 +1,20 @@
 "use client";
 import {
   useServerQuery
-} from "./chunk-KOTSX5JH.mjs";
+} from "./chunk-52BR7LTX.mjs";
 import {
   beginFarmServerQueryAction,
   completeFarmServerQueryAction,
   fetchServerQuery,
   prefetchServerQuery,
   shouldApplyFarmServerQueryActionResult
-} from "./chunk-EXCGBERG.mjs";
-import "./chunk-DLBUAJTK.mjs";
-import "./chunk-SCFX4UTD.mjs";
-import "./chunk-AXVJCMVF.mjs";
-import "./chunk-RBRLLZL5.mjs";
+} from "./chunk-WD2EBM3I.mjs";
+import "./chunk-WMJGA32P.mjs";
+import "./chunk-EHTUKVSW.mjs";
+import "./chunk-2HDOV47R.mjs";
+import "./chunk-34IAPZBG.mjs";
 import "./chunk-WZ5QFROO.mjs";
-import "./chunk-ZRBCBOEX.mjs";
+import "./chunk-N2FY2QZ7.mjs";
 import "./chunk-CGILA3WO.mjs";
 export {
   beginFarmServerQueryAction,

package/dist/{server-query-runtime-3zAj77yv.d.ts → server-query-runtime-DXRNhX_3.d.ts}

@@ -7,6 +7,8 @@ type FarmServerQueryResult<TData> = {
         key: string;
         staleTime: number | false;
         updatedAt: number;
+        /** Declared by the query; allows the client persistence adapter to store the entry. */
+        persist?: boolean;
     };
     data: TData;
 };

package/dist/{server-query-runtime-B50KAcj5.d.mts → server-query-runtime-aP52iuL5.d.mts}

@@ -7,6 +7,8 @@ type FarmServerQueryResult<TData> = {
         key: string;
         staleTime: number | false;
         updatedAt: number;
+        /** Declared by the query; allows the client persistence adapter to store the entry. */
+        persist?: boolean;
     };
     data: TData;
 };

package/dist/server-query.cjs

@@ -95,7 +95,13 @@ function recordFarmEventTrace(event) {
       activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
     }
     const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) recordSpanError(activeSpan, error);
+    if (error !== void 0) {
+      if (event.type === "render.error") {
+        recordSpanException(activeSpan, error);
+      } else {
+        recordSpanError(activeSpan, error);
+      }
+    }
   }
   const completedTraceContext = recordCompletedEventSpan(event, activeContext);
   return traceContext ?? completedTraceContext;
@@ -192,12 +198,26 @@ function getCompletedSpanDescriptor(event) {
   }
 }
 __name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
+function hashFarmCacheKey(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+__name(hashFarmCacheKey, "hashFarmCacheKey");
 function toEventAttributes(event) {
   const attributes = {};
+  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
   for (const [key, value] of Object.entries(event)) {
     if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
       continue;
     }
+    if (redactKey && key === "key" && typeof value === "string") {
+      attributes["farm.key_hash"] = hashFarmCacheKey(value);
+      continue;
+    }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
       attributes[`farm.${key}`] = value;
     } else if (Array.isArray(value)) {
@@ -217,9 +237,14 @@ function getEventError(event) {
   return "error" in event ? event.error : void 0;
 }
 __name(getEventError, "getEventError");
-function recordSpanError(span, error) {
+function recordSpanException(span, error) {
   const normalized = error instanceof Error ? error : new Error(String(error));
   span.recordException(normalized);
+  return normalized;
+}
+__name(recordSpanException, "recordSpanException");
+function recordSpanError(span, error) {
+  const normalized = recordSpanException(span, error);
   span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
 }
 __name(recordSpanError, "recordSpanError");
@@ -378,16 +403,29 @@ function getFarmCacheInvalidationState() {
   });
 }
 __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function warnFarmCacheListenerError(scope, error) {
+  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
+}
+__name(warnFarmCacheListenerError, "warnFarmCacheListenerError");
 function notifyFarmCacheInvalidation(key) {
   if (typeof key !== "string" || key.length === 0) return;
   for (const listener of getFarmCacheInvalidationState().listeners) {
-    listener(key);
+    try {
+      listener(key);
+    } catch (error) {
+      warnFarmCacheListenerError("invalidation", error);
+    }
   }
 }
 __name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
 function notifyFarmCacheTask(task) {
   for (const listener of getFarmCacheInvalidationState().taskListeners) {
-    listener(task);
+    try {
+      listener(task);
+    } catch (error) {
+      warnFarmCacheListenerError("task", error);
+    }
   }
 }
 __name(notifyFarmCacheTask, "notifyFarmCacheTask");
@@ -1507,7 +1545,8 @@ function createServerQuery(options) {
       return createFarmServerQueryResult(data, {
         key: clientKey,
         staleTime,
-        updatedAt
+        updatedAt,
+        ...options.persist === true ? { persist: true } : {}
       });
     }, "handler")
   });

package/dist/server-query.d.mts

@@ -12,6 +12,8 @@ type ServerQueryOptions<TSchema extends ServerFnSchema | undefined, TResult, TMi
     key: ServerQueryKey<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
     /** Milliseconds, a duration string such as "30s", or false for no expiry. */
     staleTime?: ServerQueryStaleTime;
+    /** Allow the configured client cache persistence adapter to store results on the device. */
+    persist?: boolean;
     handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
 };
 type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
@@ -21,6 +23,8 @@ type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, T
     key: ServerQueryKey<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
     /** Milliseconds, a duration string such as "30s", or false for no expiry. */
     staleTime?: ServerQueryStaleTime;
+    /** Allow the configured client cache persistence adapter to store results on the device. */
+    persist?: boolean;
     handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
 };
 type ServerQuery<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput) => Promise<TResult> : (input: TInput) => Promise<TResult>) & {

package/dist/server-query.d.ts

@@ -12,6 +12,8 @@ type ServerQueryOptions<TSchema extends ServerFnSchema | undefined, TResult, TMi
     key: ServerQueryKey<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
     /** Milliseconds, a duration string such as "30s", or false for no expiry. */
     staleTime?: ServerQueryStaleTime;
+    /** Allow the configured client cache persistence adapter to store results on the device. */
+    persist?: boolean;
     handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
 };
 type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
@@ -21,6 +23,8 @@ type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, T
     key: ServerQueryKey<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
     /** Milliseconds, a duration string such as "30s", or false for no expiry. */
     staleTime?: ServerQueryStaleTime;
+    /** Allow the configured client cache persistence adapter to store results on the device. */
+    persist?: boolean;
     handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
 };
 type ServerQuery<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput) => Promise<TResult> : (input: TInput) => Promise<TResult>) & {