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

package/dist/{chunk-KWCNQUH5.mjs → chunk-EPDIF432.mjs}

@@ -1,7 +1,16 @@
 import {
+  invokeMutationWithRetry
+} from "./chunk-6EJHNHH4.mjs";
+import {
+  applyServerFnOptimisticUpdates,
   getAPIRouteRefMetadata,
-  isAPIRouteRef
-} from "./chunk-75CGAL6E.mjs";
+  isAPIRouteRef,
+  resolveServerFnInvalidateTargets,
+  settleServerFnOptimisticUpdates
+} from "./chunk-IZBX2TEU.mjs";
+import {
+  notifyClientObserver
+} from "./chunk-DU3PKDVQ.mjs";
 import {
   buildFarmRoutePath
 } from "./chunk-X5GRVT7B.mjs";
@@ -9,9 +18,18 @@ import {
   isFarmLocaleChangeHref,
   localizeActiveFarmHref
 } from "./chunk-ULD4ENAH.mjs";
+import {
+  getFarmClientDataCache
+} from "./chunk-WMJGA32P.mjs";
 import {
   getFarmTrailingSlashPreference
 } from "./chunk-RCNUKRBF.mjs";
+import {
+  decodeFarmCacheInvalidations,
+  encodeFarmCacheInvalidations,
+  notifyFarmCacheInvalidation,
+  subscribeFarmCacheInvalidation
+} from "./chunk-34IAPZBG.mjs";
 import {
   applyFarmBasePath,
   getFarmBasePath,
@@ -23,65 +41,156 @@ import {
 
 // src/mutation-client.ts
 import { useCallback, useMemo, useRef, useState } from "react";
+
+// src/client-network-status.ts
+function isNavigatorOnline() {
+  if (typeof navigator === "undefined" || typeof navigator.onLine !== "boolean") return true;
+  return navigator.onLine;
+}
+__name(isNavigatorOnline, "isNavigatorOnline");
+function subscribeOnline(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  window.addEventListener("online", listener);
+  return () => window.removeEventListener("online", listener);
+}
+__name(subscribeOnline, "subscribeOnline");
+
+// src/mutation-client.ts
 function useMutation(target, options = {}) {
+  return useMutationLifecycle(target, options).mutation;
+}
+__name(useMutation, "useMutation");
+function useMutationLifecycle(target, options = {}) {
   const initialData = options.initialData ?? null;
   const optionsRef = useRef(options);
   const targetRef = useRef(target);
   const requestIdRef = useRef(0);
+  const lastResetIdRef = useRef(0);
   const initialState = {
     pendingCount: 0,
+    pausedCount: 0,
     status: "idle",
     data: initialData,
     error: null,
     variables: void 0
   };
   const stateRef = useRef(initialState);
+  const resetWakersRef = useRef(/* @__PURE__ */ new Set());
   const [state, setState] = useState(initialState);
   optionsRef.current = options;
   targetRef.current = target;
   const setMutationState = useCallback(
     (value) => {
-      setState((current) => {
-        const next = typeof value === "function" ? value(current) : value;
-        stateRef.current = next;
-        return next;
-      });
+      const next = typeof value === "function" ? value(stateRef.current) : value;
+      stateRef.current = next;
+      setState(next);
     },
     []
   );
-  const mutateAsync = useCallback(
-    async (variables) => {
+  const waitForReconnect = useCallback(
+    async (requestId) => {
+      while (!isNavigatorOnline()) {
+        if (requestId < lastResetIdRef.current) return;
+        setMutationState((current) => ({ ...current, pausedCount: current.pausedCount + 1 }));
+        try {
+          await new Promise((resolve) => {
+            const wake = /* @__PURE__ */ __name(() => {
+              unsubscribe();
+              resetWakersRef.current.delete(wake);
+              resolve();
+            }, "wake");
+            const unsubscribe = subscribeOnline(wake);
+            resetWakersRef.current.add(wake);
+          });
+        } finally {
+          setMutationState((current) => ({
+            ...current,
+            pausedCount: Math.max(0, current.pausedCount - 1)
+          }));
+        }
+      }
+    },
+    [setMutationState]
+  );
+  const mutatePreparedAsync = useCallback(
+    async (prepare) => {
       const requestId = ++requestIdRef.current;
       const currentOptions = optionsRef.current;
       const previousData = stateRef.current.data;
-      const optimisticData = currentOptions.optimistic?.({
-        variables,
-        current: previousData
-      });
+      let variables;
+      let preparationFailed = false;
+      let preparationError;
+      try {
+        variables = prepare();
+      } catch (error) {
+        preparationFailed = true;
+        preparationError = error;
+      }
+      const optimisticData = preparationFailed ? void 0 : currentOptions.optimistic?.({ variables, current: previousData });
       const hasOptimisticData = optimisticData !== void 0;
-      setMutationState((current) => ({
-        pendingCount: current.pendingCount + 1,
-        status: "pending",
-        data: hasOptimisticData ? optimisticData : currentOptions.resetOnMutate === false ? current.data : null,
-        error: null,
-        variables
-      }));
+      setMutationState((current) => {
+        if (requestId < lastResetIdRef.current) return current;
+        const pendingCount = current.pendingCount + 1;
+        if (requestId !== requestIdRef.current) return { ...current, pendingCount };
+        return {
+          pendingCount,
+          pausedCount: current.pausedCount,
+          status: "pending",
+          data: hasOptimisticData ? optimisticData : currentOptions.resetOnMutate === false ? current.data : null,
+          error: null,
+          variables
+        };
+      });
+      const mutationTarget = targetRef.current;
+      const isAPITarget = isAPIRouteRef(mutationTarget);
+      const sharedOptimistic = !preparationFailed && !isAPITarget ? currentOptions.request?.optimistic : void 0;
+      const sharedSnapshots = sharedOptimistic?.update?.length ? applyServerFnOptimisticUpdates(sharedOptimistic.update) : [];
       try {
-        const mutationTarget = targetRef.current;
-        const rawResult = isAPIRouteRef(mutationTarget) ? await mutationTarget(variables, currentOptions.request) : await mutationTarget(variables);
-        const data = unwrapMutationResult(rawResult, isAPIRouteRef(mutationTarget));
+        if (preparationFailed) throw preparationError;
+        let data;
+        while (true) {
+          if (currentOptions.networkMode === "online") {
+            await waitForReconnect(requestId);
+            if (requestId < lastResetIdRef.current) {
+              throw new Error("Mutation reset while waiting for reconnection");
+            }
+          }
+          try {
+            const rawResult = isAPITarget ? await mutationTarget(variables, currentOptions.request) : await invokeMutationWithRetry(
+              () => targetRef.current(variables),
+              currentOptions.request?.retry,
+              // A reset disowns this submission; stop scheduling retries then.
+              () => requestId >= lastResetIdRef.current
+            );
+            data = unwrapMutationResult(rawResult, isAPITarget);
+            break;
+          } catch (cause) {
+            if (currentOptions.networkMode === "online" && !isNavigatorOnline() && requestId >= lastResetIdRef.current) {
+              continue;
+            }
+            throw cause;
+          }
+        }
+        settleServerFnOptimisticUpdates(sharedSnapshots, "commit");
+        if (!isAPITarget && currentOptions.request?.invalidate) {
+          for (const key of resolveServerFnInvalidateTargets(currentOptions.request.invalidate)) {
+            notifyFarmCacheInvalidation(key);
+          }
+        }
         const isLatestRequest = requestId === requestIdRef.current;
         setMutationState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
           const pendingCount = Math.max(0, current.pendingCount - 1);
           if (!isLatestRequest) {
             return {
               ...current,
-              pendingCount,
-              status: pendingCount > 0 ? "pending" : current.status
+              pendingCount
             };
           }
           return {
             pendingCount,
+            pausedCount: current.pausedCount,
             status: "success",
             data,
             error: null,
@@ -89,24 +198,35 @@ function useMutation(target, options = {}) {
           };
         });
         if (isLatestRequest) {
-          currentOptions.onSuccess?.(data, variables);
-          currentOptions.onSettled?.(data, null, variables);
+          notifyClientObserver(currentOptions.onSuccess, [data, variables], "Mutation onSuccess");
+          if (requestId === requestIdRef.current) {
+            notifyClientObserver(
+              currentOptions.onSettled,
+              [data, null, variables],
+              "Mutation onSettled"
+            );
+          }
         }
         return data;
       } catch (cause) {
+        settleServerFnOptimisticUpdates(
+          sharedSnapshots,
+          sharedOptimistic?.rollbackOnError ? "rollback" : "invalidate"
+        );
         const error = normalizeMutationError(cause);
         const isLatestRequest = requestId === requestIdRef.current;
         setMutationState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
           const pendingCount = Math.max(0, current.pendingCount - 1);
           if (!isLatestRequest) {
             return {
               ...current,
-              pendingCount,
-              status: pendingCount > 0 ? "pending" : current.status
+              pendingCount
             };
           }
           return {
             pendingCount,
+            pausedCount: current.pausedCount,
             status: "error",
             data: hasOptimisticData && currentOptions.rollbackOnError ? previousData : currentOptions.resetOnMutate === false ? current.data : null,
             error,
@@ -114,13 +234,23 @@ function useMutation(target, options = {}) {
           };
         });
         if (isLatestRequest) {
-          currentOptions.onError?.(error, variables);
-          currentOptions.onSettled?.(null, error, variables);
+          notifyClientObserver(currentOptions.onError, [error, variables], "Mutation onError");
+          if (requestId === requestIdRef.current) {
+            notifyClientObserver(
+              currentOptions.onSettled,
+              [null, error, variables],
+              "Mutation onSettled"
+            );
+          }
         }
         throw error;
       }
     },
-    [setMutationState]
+    [setMutationState, waitForReconnect]
+  );
+  const mutateAsync = useCallback(
+    (variables) => mutatePreparedAsync(() => variables),
+    [mutatePreparedAsync]
   );
   const mutate = useCallback(
     (variables) => {
@@ -130,18 +260,23 @@ function useMutation(target, options = {}) {
     [mutateAsync]
   );
   const reset = useCallback(() => {
-    requestIdRef.current += 1;
+    lastResetIdRef.current = ++requestIdRef.current;
     setMutationState({
       pendingCount: 0,
+      pausedCount: 0,
       status: "idle",
       data: optionsRef.current.initialData ?? null,
       error: null,
       variables: void 0
     });
+    const wakers = Array.from(resetWakersRef.current);
+    resetWakersRef.current.clear();
+    for (const wake of wakers) wake();
   }, [setMutationState]);
-  return useMemo(
+  const mutation = useMemo(
     () => ({
       pending: state.pendingCount > 0,
+      paused: state.pausedCount > 0,
       status: state.status,
       data: state.data,
       error: state.error,
@@ -156,13 +291,15 @@ function useMutation(target, options = {}) {
       reset,
       state.data,
       state.error,
+      state.pausedCount,
       state.pendingCount,
       state.status,
       state.variables
     ]
   );
+  return { mutation, mutatePreparedAsync };
 }
-__name(useMutation, "useMutation");
+__name(useMutationLifecycle, "useMutationLifecycle");
 function unwrapMutationResult(result, apiRoute) {
   if (!apiRoute) return result;
   const apiResult = result;
@@ -188,13 +325,27 @@ import {
   useRef as useRef2,
   useState as useState2
 } from "react";
+var _FetcherInputError = class _FetcherInputError extends Error {
+  constructor(cause) {
+    super(
+      cause instanceof Error ? cause.message : typeof cause === "string" ? cause : "Could not prepare form input"
+    );
+    this.name = "FetcherInputError";
+    this.code = "input_error";
+    this.status = 0;
+    this.data = void 0;
+    this.cause = cause;
+  }
+};
+__name(_FetcherInputError, "FetcherInputError");
+var FetcherInputError = _FetcherInputError;
 var formDataContexts = /* @__PURE__ */ new WeakMap();
 function useFetcher(target, options = {}) {
   const targetRef = useRef2(target);
   const optionsRef = useRef2(options);
   const submissionIdRef = useRef2(0);
   const [formData, setFormData] = useState2(null);
-  const mutation = useMutation(target, options);
+  const { mutation, mutatePreparedAsync } = useMutationLifecycle(target, options);
   targetRef.current = target;
   optionsRef.current = options;
   const submitAsync = useCallback2(
@@ -203,15 +354,20 @@ function useFetcher(target, options = {}) {
       const submittedFormData = isFormData(input) ? input : null;
       setFormData(submittedFormData);
       try {
-        const variables = submittedFormData ? mapFetcherFormData(targetRef.current, submittedFormData, optionsRef.current) : input;
-        return await mutation.mutateAsync(variables);
+        return await mutatePreparedAsync(() => {
+          try {
+            return submittedFormData ? mapFetcherFormData(targetRef.current, submittedFormData, optionsRef.current) : input;
+          } catch (error) {
+            throw new FetcherInputError(error);
+          }
+        });
       } finally {
         if (submissionId === submissionIdRef.current) {
           setFormData(null);
         }
       }
     },
-    [mutation.mutateAsync]
+    [mutatePreparedAsync]
   );
   const submit = useCallback2(
     (input) => {
@@ -261,6 +417,7 @@ function useFetcher(target, options = {}) {
       state: mutation.pending ? "submitting" : "idle",
       status: mutation.status,
       pending: mutation.pending,
+      paused: mutation.paused,
       data: mutation.data,
       error: mutation.error,
       variables: mutation.variables,
@@ -275,6 +432,7 @@ function useFetcher(target, options = {}) {
       formData,
       mutation.data,
       mutation.error,
+      mutation.paused,
       mutation.pending,
       mutation.status,
       mutation.variables,
@@ -293,9 +451,18 @@ function mapFetcherFormData(target, formData, options) {
   if (!isAPIRouteRef(target)) {
     return formData;
   }
-  const values = formDataToObject(formData);
   const method = getAPIRouteRefMetadata(target)?.method;
-  return method === "GET" || method === "HEAD" ? { query: values } : { body: values };
+  const query = method === "GET" || method === "HEAD";
+  const encoding = context.submitter?.getAttribute("formenctype") ?? context.form?.enctype;
+  if (!query && (encoding?.toLowerCase() === "multipart/form-data" || Array.from(formData.values()).some((value) => typeof value !== "string"))) {
+    const body = new FormData();
+    for (const [key, value] of formData) {
+      if (!isUnsafeFormKey(key)) body.append(key, value);
+    }
+    return { body };
+  }
+  const values = formDataToObject(formData);
+  return query ? { query: values } : { body: values };
 }
 __name(mapFetcherFormData, "mapFetcherFormData");
 function resolveFetcherFormAction(target, metadata) {
@@ -307,7 +474,7 @@ __name(resolveFetcherFormAction, "resolveFetcherFormAction");
 function formDataToObject(formData) {
   const output = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of formData.entries()) {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (isUnsafeFormKey(key)) continue;
     const current = output[key];
     if (current === void 0) {
       output[key] = value;
@@ -320,6 +487,10 @@ function formDataToObject(formData) {
   return output;
 }
 __name(formDataToObject, "formDataToObject");
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+__name(isUnsafeFormKey, "isUnsafeFormKey");
 function createSubmitterFormData(form, submitter) {
   try {
     return new FormData(form, submitter);
@@ -349,6 +520,296 @@ function isFormData(value) {
 }
 __name(isFormData, "isFormData");
 
+// src/cache-invalidation-broadcast.ts
+var FARM_CACHE_INVALIDATION_CHANNEL = "farm:cache-invalidation";
+var activeBridge;
+function enableCrossTabCacheInvalidation(options = {}) {
+  if (typeof BroadcastChannel !== "function") return () => {
+  };
+  const channelName = options.channelName ?? FARM_CACHE_INVALIDATION_CHANNEL;
+  if (activeBridge) {
+    if (activeBridge.channelName !== channelName) {
+      throw new Error(
+        `Cross-tab cache invalidation is already enabled on channel "${activeBridge.channelName}".`
+      );
+    }
+    activeBridge.refCount += 1;
+  } else {
+    activeBridge = createBridge(channelName);
+  }
+  let disposed = false;
+  return () => {
+    if (disposed || !activeBridge) return;
+    disposed = true;
+    activeBridge.refCount -= 1;
+    if (activeBridge.refCount === 0) {
+      activeBridge.teardown();
+      activeBridge = void 0;
+    }
+  };
+}
+__name(enableCrossTabCacheInvalidation, "enableCrossTabCacheInvalidation");
+function createBridge(channelName) {
+  const channel = new BroadcastChannel(channelName);
+  let applyingRemote = false;
+  let pending = [];
+  let flushScheduled = false;
+  let closed = false;
+  const flush = /* @__PURE__ */ __name(() => {
+    flushScheduled = false;
+    if (closed || pending.length === 0) return;
+    const encoded = encodeFarmCacheInvalidations(pending);
+    pending = [];
+    if (encoded !== null) channel.postMessage(encoded);
+  }, "flush");
+  const unsubscribe = subscribeFarmCacheInvalidation((key) => {
+    if (applyingRemote || closed) return;
+    pending.push(key);
+    if (!flushScheduled) {
+      flushScheduled = true;
+      queueMicrotask(flush);
+    }
+  });
+  channel.onmessage = (event) => {
+    const keys = decodeFarmCacheInvalidations(
+      typeof event.data === "string" ? event.data : void 0
+    );
+    if (keys.length === 0) return;
+    applyingRemote = true;
+    try {
+      for (const key of keys) notifyFarmCacheInvalidation(key);
+    } finally {
+      applyingRemote = false;
+    }
+  };
+  return {
+    channelName,
+    refCount: 1,
+    teardown() {
+      closed = true;
+      pending = [];
+      unsubscribe();
+      channel.onmessage = null;
+      channel.close();
+    }
+  };
+}
+__name(createBridge, "createBridge");
+
+// src/client-cache-persistence.ts
+var FARM_CLIENT_CACHE_PERSIST_VERSION = "1";
+function defineClientCacheAdapter(adapter) {
+  for (const method of ["keys", "get", "set", "delete", "clear"]) {
+    if (typeof adapter?.[method] !== "function") {
+      throw new TypeError(
+        `defineClientCacheAdapter expects a "${method}" method. Implement keys/get/set/delete/clear over your storage.`
+      );
+    }
+  }
+  return adapter;
+}
+__name(defineClientCacheAdapter, "defineClientCacheAdapter");
+function storageClientCacheAdapter(storage, options = {}) {
+  if (!storage || typeof storage.getItem !== "function" || typeof storage.setItem !== "function" || typeof storage.removeItem !== "function") {
+    throw new TypeError("storageClientCacheAdapter expects a compatible key-value client.");
+  }
+  const base = options.base ?? "farm-client-cache";
+  const entryKey = /* @__PURE__ */ __name((key) => `${base}:${key}`, "entryKey");
+  const enumerate = storage.getKeys?.bind(storage) ?? storage.keys?.bind(storage);
+  return {
+    async keys() {
+      if (!enumerate) return [];
+      const keys = await enumerate(base);
+      const prefix = `${base}:`;
+      return keys.filter((key) => key.startsWith(prefix)).map((key) => key.slice(prefix.length));
+    },
+    async get(key) {
+      return await storage.getItem(entryKey(key)) ?? null;
+    },
+    async set(key, entry) {
+      await storage.setItem(entryKey(key), entry);
+    },
+    async delete(key) {
+      await storage.removeItem(entryKey(key));
+    },
+    async clear() {
+      if (storage.clear) {
+        await storage.clear(base);
+        return;
+      }
+      if (!enumerate) return;
+      const prefix = `${base}:`;
+      for (const key of await enumerate(base)) {
+        if (key.startsWith(prefix)) await storage.removeItem(key);
+      }
+    }
+  };
+}
+__name(storageClientCacheAdapter, "storageClientCacheAdapter");
+var activeEngine;
+function reportPersistenceFailure(error) {
+  const report = typeof reportError === "function" ? reportError : console.error;
+  if (error instanceof Error) {
+    report(error);
+    return;
+  }
+  const normalized = new Error("Client cache persistence failed");
+  normalized.cause = error;
+  report(normalized);
+}
+__name(reportPersistenceFailure, "reportPersistenceFailure");
+function disableEngine(engine, error) {
+  if (engine.disabled) return;
+  engine.disabled = true;
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  if (engine.flushTimer !== void 0) {
+    clearTimeout(engine.flushTimer);
+    engine.flushTimer = void 0;
+  }
+  reportPersistenceFailure(error);
+}
+__name(disableEngine, "disableEngine");
+function scheduleFlush(engine) {
+  if (engine.disabled || engine.flushTimer !== void 0) return;
+  const timer = setTimeout(() => {
+    engine.flushTimer = void 0;
+    void flushEngine(engine);
+  }, engine.flushDelayMs);
+  timer.unref?.();
+  engine.flushTimer = timer;
+}
+__name(scheduleFlush, "scheduleFlush");
+async function flushEngine(engine) {
+  if (engine.disabled) return;
+  const sets = Array.from(engine.pendingSets.entries());
+  const deletes = Array.from(engine.pendingDeletes);
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  try {
+    if (sets.length > 0) {
+      if (engine.adapter.setMany) await engine.adapter.setMany(sets);
+      else for (const [key, entry] of sets) await engine.adapter.set(key, entry);
+    }
+    for (const key of deletes) await engine.adapter.delete(key);
+  } catch (error) {
+    disableEngine(engine, error);
+  }
+}
+__name(flushEngine, "flushEngine");
+async function hydrateEngine(engine) {
+  const now = Date.now();
+  const keys = await engine.adapter.keys();
+  if (keys.length === 0) return;
+  const persisted = engine.adapter.getMany ? await engine.adapter.getMany(keys) : await Promise.all(keys.map((key) => engine.adapter.get(key)));
+  engine.hydrating = true;
+  try {
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      const entry = persisted[index];
+      if (engine.disabled) return;
+      if (!entry || entry.version !== engine.version || entry.gcAt !== void 0 && now >= entry.gcAt) {
+        engine.pendingDeletes.add(key);
+        continue;
+      }
+      if (engine.cache.get(key, now)) continue;
+      engine.cache.set(key, {
+        data: entry.data,
+        updatedAt: entry.updatedAt,
+        staleAt: 0,
+        gcAt: entry.gcAt,
+        status: "success",
+        error: null,
+        persist: true
+      });
+    }
+  } finally {
+    engine.hydrating = false;
+  }
+  if (engine.pendingDeletes.size > 0) scheduleFlush(engine);
+}
+__name(hydrateEngine, "hydrateEngine");
+function createSink(engine) {
+  return {
+    onSet(key, entry) {
+      if (engine.disabled || engine.hydrating) return;
+      if (!entry.persist || entry.fetching || entry.error || entry.status === "pending") return;
+      if (engine.persistKey && !engine.persistKey(key)) return;
+      engine.pendingDeletes.delete(key);
+      engine.pendingSets.set(key, {
+        data: entry.data,
+        updatedAt: entry.updatedAt,
+        staleAt: entry.staleAt,
+        gcAt: entry.gcAt,
+        version: engine.version
+      });
+      scheduleFlush(engine);
+    },
+    onDelete(key) {
+      if (engine.disabled) return;
+      engine.pendingSets.delete(key);
+      engine.pendingDeletes.add(key);
+      scheduleFlush(engine);
+    },
+    onClear() {
+      if (engine.disabled) return;
+      engine.pendingSets.clear();
+      engine.pendingDeletes.clear();
+      void engine.adapter.clear().catch((error) => disableEngine(engine, error));
+    }
+  };
+}
+__name(createSink, "createSink");
+function initPersistedClientCache(adapter, options = {}) {
+  defineClientCacheAdapter(adapter);
+  disposePersistedClientCache();
+  const engine = {
+    adapter,
+    cache: getFarmClientDataCache(),
+    version: options.version ? `${FARM_CLIENT_CACHE_PERSIST_VERSION}:${options.version}` : FARM_CLIENT_CACHE_PERSIST_VERSION,
+    persistKey: options.persistKey,
+    flushDelayMs: options.flushDelayMs ?? 300,
+    pendingSets: /* @__PURE__ */ new Map(),
+    pendingDeletes: /* @__PURE__ */ new Set(),
+    flushTimer: void 0,
+    hydrating: false,
+    disabled: false
+  };
+  activeEngine = engine;
+  engine.cache.attachPersistence(createSink(engine));
+  void hydrateEngine(engine).catch((error) => disableEngine(engine, error));
+  return () => {
+    if (activeEngine !== engine) return;
+    disposePersistedClientCache();
+  };
+}
+__name(initPersistedClientCache, "initPersistedClientCache");
+function disposePersistedClientCache() {
+  const engine = activeEngine;
+  if (!engine) return;
+  activeEngine = void 0;
+  engine.cache.attachPersistence(void 0);
+  if (engine.flushTimer !== void 0) {
+    clearTimeout(engine.flushTimer);
+    engine.flushTimer = void 0;
+  }
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+}
+__name(disposePersistedClientCache, "disposePersistedClientCache");
+async function clearPersistedCache() {
+  const engine = activeEngine;
+  if (!engine) return;
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  try {
+    await engine.adapter.clear();
+  } catch (error) {
+    disableEngine(engine, error);
+  }
+}
+__name(clearPersistedCache, "clearPersistedCache");
+
 // src/store.ts
 import { useSyncExternalStore } from "react";
 var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
@@ -371,11 +832,14 @@ function pickState(state, keys) {
   return slice;
 }
 __name(pickState, "pickState");
+function getEnumerableKeys(state) {
+  return Reflect.ownKeys(state).filter(
+    (key) => Object.prototype.propertyIsEnumerable.call(state, key)
+  );
+}
+__name(getEnumerableKeys, "getEnumerableKeys");
 function getChangedKeys(state, previousState) {
-  const keys = /* @__PURE__ */ new Set([
-    ...Object.keys(state),
-    ...Object.keys(previousState)
-  ]);
+  const keys = /* @__PURE__ */ new Set([...getEnumerableKeys(state), ...getEnumerableKeys(previousState)]);
   return [...keys].filter((key) => !Object.is(state[key], previousState[key]));
 }
 __name(getChangedKeys, "getChangedKeys");
@@ -396,7 +860,11 @@ function createStore(initialState, extend) {
   let state = cloneState(initialState);
   const subscriptions = /* @__PURE__ */ new Set();
   const addSubscription = /* @__PURE__ */ __name((keys, notify) => {
-    const subscription = { keys, notify };
+    const subscription = {
+      // Object property enumeration returns numeric keys as strings.
+      keys: keys?.map((key) => typeof key === "number" ? String(key) : key) ?? null,
+      notify
+    };
     subscriptions.add(subscription);
     return () => {
       subscriptions.delete(subscription);
@@ -488,7 +956,7 @@ function createStore(initialState, extend) {
         getSnapshot
       );
     }
-    if (typeof keyOrKeys === "string") {
+    if (isStoreKey(keyOrKeys)) {
       return useSyncExternalStore(
         (notify) => addSubscription([keyOrKeys], () => notify()),
         () => state[keyOrKeys],
@@ -509,7 +977,7 @@ function createStore(initialState, extend) {
     reset: /* @__PURE__ */ __name(() => replaceState2(cloneState(initialSnapshot)), "reset"),
     subscribe: subscribeState
   };
-  for (const key of Object.keys(initialSnapshot)) {
+  for (const key of getEnumerableKeys(initialSnapshot)) {
     if (RESERVED_STORE_KEYS.has(key)) {
       throw new Error(
         `createStore does not allow the reserved key "${String(key)}" in the initial state.`
@@ -903,8 +1371,16 @@ __name(matchManifestRoute, "matchManifestRoute");
 export {
   FarmProvider,
   useMutation,
+  FetcherInputError,
   useFetcher,
+  FARM_CACHE_INVALIDATION_CHANNEL,
+  enableCrossTabCacheInvalidation,
+  FARM_CLIENT_CACHE_PERSIST_VERSION,
+  defineClientCacheAdapter,
+  storageClientCacheAdapter,
+  initPersistedClientCache,
+  clearPersistedCache,
   createStore,
   Link
 };
-//# sourceMappingURL=chunk-KWCNQUH5.mjs.map
+//# sourceMappingURL=chunk-EPDIF432.mjs.map