@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-W2ZXMMHA.mjs

@@ -1,1462 +0,0 @@
-import {
-  invokeMutationWithRetry
-} from "./chunk-GL3ZDHKI.mjs";
-import {
-  applyServerFnOptimisticUpdates,
-  getAPIRouteRefMetadata,
-  isAPIRouteRef,
-  resolveServerFnInvalidateTargets,
-  settleServerFnOptimisticUpdates
-} from "./chunk-7H45IJWO.mjs";
-import {
-  notifyClientObserver
-} from "./chunk-IAPTECEB.mjs";
-import {
-  buildFarmRoutePath
-} from "./chunk-BPAXGCKX.mjs";
-import {
-  isFarmLocaleChangeHref,
-  localizeActiveFarmHref
-} from "./chunk-PTLXHRJZ.mjs";
-import {
-  isFarmBlockedNavigationURL,
-  isFarmScriptURL,
-  resolveFarmNavigationURL
-} from "./chunk-NCIAP562.mjs";
-import {
-  getFarmClientDataCache
-} from "./chunk-C64XOPBZ.mjs";
-import {
-  getFarmTrailingSlashPreference
-} from "./chunk-RFKTJTWZ.mjs";
-import {
-  applyFarmCacheInvalidations,
-  decodeFarmCacheInvalidations,
-  encodeFarmCacheInvalidations,
-  notifyFarmCacheInvalidation,
-  subscribeFarmCacheInvalidation
-} from "./chunk-AZQXXXDX.mjs";
-import {
-  applyFarmBasePath,
-  getFarmBasePath,
-  normalizeFarmBasePath
-} from "./chunk-SF3JB56B.mjs";
-
-// 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;
-}
-function subscribeOnline(listener) {
-  if (typeof window === "undefined") return () => {
-  };
-  window.addEventListener("online", listener);
-  return () => window.removeEventListener("online", listener);
-}
-
-// src/mutation-client.ts
-function useMutation(target, options = {}) {
-  return useMutationLifecycle(target, options).mutation;
-}
-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) => {
-      const next = typeof value === "function" ? value(stateRef.current) : value;
-      stateRef.current = next;
-      setState(next);
-    },
-    []
-  );
-  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 = () => {
-              unsubscribe();
-              resetWakersRef.current.delete(wake);
-              resolve();
-            };
-            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;
-      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) => {
-        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 {
-        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 && isConnectivityFailure(cause)) {
-              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
-            };
-          }
-          return {
-            pendingCount,
-            pausedCount: current.pausedCount,
-            status: "success",
-            data,
-            error: null,
-            variables
-          };
-        });
-        if (isLatestRequest) {
-          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
-            };
-          }
-          return {
-            pendingCount,
-            pausedCount: current.pausedCount,
-            status: "error",
-            data: hasOptimisticData && currentOptions.rollbackOnError ? previousData : currentOptions.resetOnMutate === false ? current.data : null,
-            error,
-            variables
-          };
-        });
-        if (isLatestRequest) {
-          notifyClientObserver(currentOptions.onError, [error, variables], "Mutation onError");
-          if (requestId === requestIdRef.current) {
-            notifyClientObserver(
-              currentOptions.onSettled,
-              [null, error, variables],
-              "Mutation onSettled"
-            );
-          }
-        }
-        throw error;
-      }
-    },
-    [setMutationState, waitForReconnect]
-  );
-  const mutateAsync = useCallback(
-    (variables) => mutatePreparedAsync(() => variables),
-    [mutatePreparedAsync]
-  );
-  const mutate = useCallback(
-    (variables) => {
-      void mutateAsync(variables).catch(() => {
-      });
-    },
-    [mutateAsync]
-  );
-  const reset = useCallback(() => {
-    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]);
-  const mutation = useMemo(
-    () => ({
-      pending: state.pendingCount > 0,
-      paused: state.pausedCount > 0,
-      status: state.status,
-      data: state.data,
-      error: state.error,
-      variables: state.variables,
-      mutate,
-      mutateAsync,
-      reset
-    }),
-    [
-      mutate,
-      mutateAsync,
-      reset,
-      state.data,
-      state.error,
-      state.pausedCount,
-      state.pendingCount,
-      state.status,
-      state.variables
-    ]
-  );
-  return { mutation, mutatePreparedAsync };
-}
-function isConnectivityFailure(error) {
-  if (error instanceof TypeError) return true;
-  const code = error?.code;
-  return code === "network_error" || code === "timeout";
-}
-function unwrapMutationResult(result, apiRoute) {
-  if (!apiRoute) return result;
-  const apiResult = result;
-  if (apiResult.error) {
-    throw apiResult.error;
-  }
-  return apiResult.data;
-}
-function normalizeMutationError(error) {
-  if (error instanceof Error) return error;
-  const normalized = new Error(typeof error === "string" ? error : "Mutation failed");
-  normalized.cause = error;
-  return normalized;
-}
-
-// src/fetcher-client.tsx
-import {
-  createElement,
-  useCallback as useCallback2,
-  useMemo as useMemo2,
-  useRef as useRef2,
-  useState as useState2
-} from "react";
-var FetcherInputError = class 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;
-  }
-};
-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, mutatePreparedAsync } = useMutationLifecycle(target, options);
-  targetRef.current = target;
-  optionsRef.current = options;
-  const submitAsync = useCallback2(
-    async (input) => {
-      const submissionId = ++submissionIdRef.current;
-      const submittedFormData = isFormData(input) ? input : null;
-      setFormData(submittedFormData);
-      try {
-        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);
-        }
-      }
-    },
-    [mutatePreparedAsync]
-  );
-  const submit = useCallback2(
-    (input) => {
-      void submitAsync(input).catch(() => {
-      });
-    },
-    [submitAsync]
-  );
-  const Form = useMemo2(() => {
-    const FetcherForm = ({ action, method, encType, onSubmit, ...props }) => {
-      const targetValue = targetRef.current;
-      const metadata = getAPIRouteRefMetadata(targetValue);
-      const nativeAction = action ?? resolveFetcherFormAction(targetValue, metadata);
-      const nativeMethod = method ?? (metadata && (metadata.method === "GET" || metadata.method === "POST") ? metadata.method.toLowerCase() : metadata ? "post" : void 0);
-      const functionAction = typeof nativeAction === "function";
-      const handleSubmit = (event) => {
-        onSubmit?.(event);
-        if (event.defaultPrevented) return;
-        event.preventDefault();
-        const submitter = getSubmitter(event);
-        const nextFormData = createSubmitterFormData(event.currentTarget, submitter);
-        formDataContexts.set(nextFormData, {
-          form: event.currentTarget,
-          submitter
-        });
-        void submitAsync(nextFormData).catch(() => {
-        });
-      };
-      return createElement("form", {
-        ...props,
-        action: nativeAction,
-        method: functionAction ? void 0 : nativeMethod,
-        encType: functionAction ? void 0 : encType,
-        onSubmit: handleSubmit
-      });
-    };
-    FetcherForm.displayName = "FetcherForm";
-    return FetcherForm;
-  }, [submitAsync]);
-  const reset = useCallback2(() => {
-    submissionIdRef.current += 1;
-    setFormData(null);
-    mutation.reset();
-  }, [mutation.reset]);
-  return useMemo2(
-    () => ({
-      state: mutation.pending ? "submitting" : "idle",
-      status: mutation.status,
-      pending: mutation.pending,
-      paused: mutation.paused,
-      data: mutation.data,
-      error: mutation.error,
-      variables: mutation.variables,
-      formData,
-      submit,
-      submitAsync,
-      Form,
-      reset
-    }),
-    [
-      Form,
-      formData,
-      mutation.data,
-      mutation.error,
-      mutation.paused,
-      mutation.pending,
-      mutation.status,
-      mutation.variables,
-      reset,
-      submit,
-      submitAsync
-    ]
-  );
-}
-function mapFetcherFormData(target, formData, options) {
-  const context = formDataContexts.get(formData) ?? { form: null, submitter: null };
-  if (options.mapFormData) {
-    return options.mapFormData(formData, context);
-  }
-  if (!isAPIRouteRef(target)) {
-    return formData;
-  }
-  const method = getAPIRouteRefMetadata(target)?.method;
-  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 };
-}
-function resolveFetcherFormAction(target, metadata) {
-  if (!metadata) return isProgressiveFormAction(target) ? target : void 0;
-  if (metadata.sameOrigin) return metadata.path;
-  return new URL(metadata.path, metadata.baseURL).href;
-}
-function formDataToObject(formData) {
-  const output = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of formData.entries()) {
-    if (isUnsafeFormKey(key)) continue;
-    const current = output[key];
-    if (current === void 0) {
-      output[key] = value;
-    } else if (Array.isArray(current)) {
-      current.push(value);
-    } else {
-      output[key] = [current, value];
-    }
-  }
-  return output;
-}
-function isUnsafeFormKey(key) {
-  return key === "__proto__" || key === "constructor" || key === "prototype";
-}
-function createSubmitterFormData(form, submitter) {
-  try {
-    return new FormData(form, submitter);
-  } catch {
-    const formData = new FormData(form);
-    const candidate = submitter;
-    if (candidate && !candidate.disabled && candidate.name) {
-      formData.append(candidate.name, candidate.value ?? "");
-    }
-    return formData;
-  }
-}
-function getSubmitter(event) {
-  const nativeEvent = event.nativeEvent;
-  return nativeEvent.submitter instanceof HTMLElement ? nativeEvent.submitter : null;
-}
-function isProgressiveFormAction(target) {
-  const candidate = target;
-  return candidate.__farmServerFn === true || typeof candidate.$$FORM_ACTION === "function" || candidate.$$typeof === /* @__PURE__ */ Symbol.for("react.server.reference");
-}
-function isFormData(value) {
-  if (!value || typeof value !== "object") return false;
-  return typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
-}
-
-// src/cache-invalidation-broadcast.ts
-var FARM_CACHE_INVALIDATION_CHANNEL = "farm:cache-invalidation";
-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;
-  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 "${existing.channelName}".`
-      );
-    }
-    existing.refCount += 1;
-    bridge = existing;
-  } else {
-    bridge = createBridge(channelName);
-    bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] = bridge;
-  }
-  let disposed = false;
-  return () => {
-    if (disposed) return;
-    disposed = true;
-    bridge.refCount -= 1;
-    if (bridge.refCount === 0) {
-      bridge.teardown();
-      if (bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] === bridge) {
-        bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] = void 0;
-      }
-    }
-  };
-}
-function createBridge(channelName) {
-  const channel = new BroadcastChannel(channelName);
-  let applyingRemote = false;
-  let pending = [];
-  let flushScheduled = false;
-  let closed = false;
-  const flush = () => {
-    flushScheduled = false;
-    if (closed || pending.length === 0) return;
-    const encoded = encodeFarmCacheInvalidations(pending);
-    pending = [];
-    if (encoded !== null) channel.postMessage(encoded);
-  };
-  const unsubscribe = subscribeFarmCacheInvalidation((key, source) => {
-    if (applyingRemote || source !== "local" || 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, "broadcast");
-    } finally {
-      applyingRemote = false;
-    }
-  };
-  return {
-    channelName,
-    refCount: 1,
-    teardown() {
-      closed = true;
-      pending = [];
-      unsubscribe();
-      channel.onmessage = null;
-      channel.close();
-    }
-  };
-}
-
-// src/cache-invalidation-event-source.ts
-var FARM_LIVE_CACHE_INVALIDATION_CONNECTIONS = /* @__PURE__ */ Symbol.for(
-  "farm.liveCacheInvalidationConnections"
-);
-var connectionGlobal = globalThis;
-function getConnections() {
-  return connectionGlobal[FARM_LIVE_CACHE_INVALIDATION_CONNECTIONS] ?? (connectionGlobal[FARM_LIVE_CACHE_INVALIDATION_CONNECTIONS] = /* @__PURE__ */ new Map());
-}
-function enableLiveCacheInvalidation(options) {
-  if (typeof EventSource !== "function") return () => {
-  };
-  const baseUrl = typeof location === "object" ? location.href : void 0;
-  const url = baseUrl ? new URL(String(options.url), baseUrl).href : String(options.url);
-  const key = `${url}\0${options.withCredentials === true ? "include" : "same-origin"}`;
-  const connections = getConnections();
-  let connection = connections.get(key);
-  if (connection) {
-    connection.refCount += 1;
-  } else {
-    const source = new EventSource(url, {
-      withCredentials: options.withCredentials === true
-    });
-    connection = { refCount: 1, source };
-    source.onmessage = (event) => {
-      const keys = decodeFarmCacheInvalidations(event.data);
-      applyFarmCacheInvalidations(keys, "live");
-    };
-    connections.set(key, connection);
-  }
-  const claimedConnection = connection;
-  let disposed = false;
-  return () => {
-    if (disposed) return;
-    disposed = true;
-    claimedConnection.refCount -= 1;
-    if (claimedConnection.refCount > 0) return;
-    claimedConnection.source.onmessage = null;
-    claimedConnection.source.close();
-    if (connections.get(key) === claimedConnection) connections.delete(key);
-  };
-}
-
-// 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;
-}
-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 = (key) => `${base}:${key}`;
-  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);
-      }
-    }
-  };
-}
-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);
-}
-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);
-}
-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;
-}
-async function flushEngine(engine) {
-  if (engine.flushing) return engine.flushing;
-  if (engine.disabled || engine.clearing) return;
-  if (engine.pendingSets.size === 0 && engine.pendingDeletes.size === 0) return;
-  const run = (async () => {
-    while (!engine.disabled && !engine.clearing && (engine.pendingSets.size > 0 || engine.pendingDeletes.size > 0)) {
-      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);
-        return;
-      }
-    }
-  })();
-  engine.flushing = run;
-  try {
-    await run;
-  } finally {
-    engine.flushing = void 0;
-  }
-}
-async function hydrateEngine(engine) {
-  const generation = engine.hydrationGeneration;
-  const now = Date.now();
-  const keys = await engine.adapter.keys();
-  if (engine.disabled || generation !== engine.hydrationGeneration) return;
-  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)));
-  if (engine.disabled || generation !== engine.hydrationGeneration) return;
-  engine.hydrating = true;
-  try {
-    for (let index = 0; index < keys.length; index += 1) {
-      const key = keys[index];
-      const entry = persisted[index];
-      if (engine.disabled || generation !== engine.hydrationGeneration) 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);
-}
-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 || engine.clearing) return;
-      engine.hydrationGeneration += 1;
-      engine.pendingSets.clear();
-      engine.pendingDeletes.clear();
-      void engine.adapter.clear().catch((error) => disableEngine(engine, error));
-    }
-  };
-}
-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,
-    hydrationGeneration: 0,
-    disabled: false,
-    clearing: false,
-    flushing: void 0
-  };
-  activeEngine = engine;
-  engine.cache.attachPersistence(createSink(engine));
-  void hydrateEngine(engine).catch((error) => disableEngine(engine, error));
-  return () => {
-    if (activeEngine !== engine) return;
-    disposePersistedClientCache();
-  };
-}
-function initConfiguredClientCachePersistence(adapterModule, options = {}) {
-  try {
-    const adapter = adapterModule?.default;
-    if (!adapter) {
-      throw new Error(
-        "cache.client.adapter must default-export an adapter. Export defineClientCacheAdapter({ keys, get, set, delete, clear }) as the module default."
-      );
-    }
-    initPersistedClientCache(adapter, options);
-  } catch (error) {
-    reportPersistenceFailure(error);
-  }
-}
-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);
-    engine.flushTimer = void 0;
-  }
-  engine.pendingSets.clear();
-  engine.pendingDeletes.clear();
-}
-async function clearPersistedCache() {
-  const engine = activeEngine;
-  if (!engine) {
-    getFarmClientDataCache().clear();
-    return;
-  }
-  engine.clearing = true;
-  engine.hydrationGeneration += 1;
-  try {
-    engine.pendingSets.clear();
-    engine.pendingDeletes.clear();
-    engine.cache.clear();
-    engine.pendingSets.clear();
-    engine.pendingDeletes.clear();
-    await engine.flushing;
-    engine.pendingSets.clear();
-    engine.pendingDeletes.clear();
-    await engine.adapter.clear();
-  } catch (error) {
-    disableEngine(engine, error);
-  } finally {
-    engine.clearing = false;
-  }
-}
-
-// src/store.ts
-import { useSyncExternalStore } from "react";
-var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
-  "use",
-  "get",
-  "set",
-  "replace",
-  "reset",
-  "subscribe"
-]);
-function cloneState(state) {
-  return { ...state };
-}
-function pickState(state, keys) {
-  const slice = {};
-  for (const key of keys) {
-    slice[key] = state[key];
-  }
-  return slice;
-}
-function getEnumerableKeys(state) {
-  return Reflect.ownKeys(state).filter(
-    (key) => Object.prototype.propertyIsEnumerable.call(state, key)
-  );
-}
-function getChangedKeys(state, previousState) {
-  const keys = /* @__PURE__ */ new Set([...getEnumerableKeys(state), ...getEnumerableKeys(previousState)]);
-  return [...keys].filter((key) => !Object.is(state[key], previousState[key]));
-}
-function normalizeKeys(keys) {
-  return Array.from(new Set(keys));
-}
-function resolveValue(value, previousValue) {
-  return typeof value === "function" ? value(previousValue) : value;
-}
-function isStoreKey(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
-}
-function createStore(initialState, extend) {
-  const initialSnapshot = cloneState(initialState);
-  let state = cloneState(initialState);
-  const subscriptions = /* @__PURE__ */ new Set();
-  const addSubscription = (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);
-    };
-  };
-  const emit = (nextState, previousState) => {
-    const changedKeys = getChangedKeys(nextState, previousState);
-    if (changedKeys.length === 0) {
-      return;
-    }
-    const changedKeySet = new Set(changedKeys);
-    for (const subscription of subscriptions) {
-      if (subscription.keys === null || subscription.keys.some((key) => changedKeySet.has(key))) {
-        subscription.notify(nextState, previousState);
-      }
-    }
-  };
-  const getState = (key) => {
-    return key === void 0 ? state : state[key];
-  };
-  const replaceState2 = (nextState) => {
-    const previousState = state;
-    const resolvedState = typeof nextState === "function" ? nextState(previousState) : nextState;
-    state = resolvedState;
-    emit(state, previousState);
-    return state;
-  };
-  const setState = (keyOrPatch, value) => {
-    const previousState = state;
-    let nextState;
-    if (isStoreKey(keyOrPatch)) {
-      const key = keyOrPatch;
-      const nextValue = resolveValue(value, previousState[key]);
-      if (Object.is(previousState[key], nextValue)) {
-        return nextValue;
-      }
-      nextState = {
-        ...previousState,
-        [key]: nextValue
-      };
-      state = nextState;
-      emit(nextState, previousState);
-      return nextValue;
-    }
-    const patch = typeof keyOrPatch === "function" ? keyOrPatch(previousState) : keyOrPatch;
-    nextState = {
-      ...previousState,
-      ...patch
-    };
-    state = nextState;
-    emit(nextState, previousState);
-    return nextState;
-  };
-  const subscribeState = (keyOrListener, listener) => {
-    if (typeof keyOrListener === "function") {
-      return addSubscription(null, (nextState, previousState) => {
-        keyOrListener(nextState, previousState);
-      });
-    }
-    if (Array.isArray(keyOrListener)) {
-      const keys = normalizeKeys(keyOrListener);
-      return addSubscription(keys, (nextState, previousState) => {
-        listener(
-          pickState(nextState, keys),
-          pickState(previousState, keys)
-        );
-      });
-    }
-    const key = keyOrListener;
-    return addSubscription([key], (nextState, previousState) => {
-      listener(nextState[key], previousState[key]);
-    });
-  };
-  const useStateValue = (keyOrKeys) => {
-    if (Array.isArray(keyOrKeys)) {
-      const keys = normalizeKeys(keyOrKeys);
-      let lastState = state;
-      let lastSlice = pickState(state, keys);
-      const getSnapshot = () => {
-        if (lastState !== state) {
-          lastState = state;
-          lastSlice = pickState(state, keys);
-        }
-        return lastSlice;
-      };
-      return useSyncExternalStore(
-        (notify) => addSubscription(keys, () => notify()),
-        getSnapshot,
-        getSnapshot
-      );
-    }
-    if (isStoreKey(keyOrKeys)) {
-      return useSyncExternalStore(
-        (notify) => addSubscription([keyOrKeys], () => notify()),
-        () => state[keyOrKeys],
-        () => state[keyOrKeys]
-      );
-    }
-    return useSyncExternalStore(
-      (notify) => addSubscription(null, () => notify()),
-      () => state,
-      () => state
-    );
-  };
-  const store = {
-    use: useStateValue,
-    get: getState,
-    set: setState,
-    replace: replaceState2,
-    reset: () => replaceState2(cloneState(initialSnapshot)),
-    subscribe: subscribeState
-  };
-  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.`
-      );
-    }
-    const field = (() => useStateValue(key));
-    field.get = () => state[key];
-    field.set = (value) => setState(key, value);
-    field.subscribe = (listener) => subscribeState(key, listener);
-    Object.defineProperty(store, key, {
-      configurable: false,
-      enumerable: true,
-      value: field,
-      writable: false
-    });
-  }
-  if (extend) {
-    const methods = extend(store);
-    for (const [name, method] of Object.entries(methods)) {
-      if (name in store) {
-        throw new Error(
-          `createStore cannot attach the method "${name}" because it already exists.`
-        );
-      }
-      Object.defineProperty(store, name, {
-        configurable: false,
-        enumerable: true,
-        value: method,
-        writable: false
-      });
-    }
-  }
-  return store;
-}
-
-// src/client/link.tsx
-import { forwardRef, useEffect, useRef as useRef3, useCallback as useCallback3 } from "react";
-
-// src/provider.tsx
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-var farmContext;
-function getFarmContext() {
-  return farmContext ?? (farmContext = createContext(null));
-}
-function FarmProvider({ children, config }) {
-  const value = {
-    config,
-    basePath: normalizeFarmBasePath(config.basePath)
-  };
-  const FarmContext = getFarmContext();
-  return /* @__PURE__ */ jsx(FarmContext.Provider, { value, children });
-}
-function useOptionalFarm() {
-  return useContext(getFarmContext());
-}
-
-// src/client/link.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-function isModifierEvent(e) {
-  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
-}
-function isExternalUrl(href) {
-  return href.startsWith("//") || /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href);
-}
-function getRouter() {
-  if (typeof window !== "undefined" && window.__FARM_SPA_ROUTER__) {
-    return window.__FARM_SPA_ROUTER__;
-  }
-  return null;
-}
-function normalizePrefetch(prefetch2) {
-  if (prefetch2 === false || prefetch2 === "none") {
-    return { intent: false, viewport: false, render: false };
-  }
-  if (prefetch2 === true) {
-    return { intent: true, viewport: true, render: false };
-  }
-  if (prefetch2 === "hover") {
-    return { intent: true, viewport: false, render: false };
-  }
-  if (prefetch2 === "intent") {
-    return { intent: true, viewport: false, render: false };
-  }
-  if (prefetch2 === "viewport") {
-    return { intent: false, viewport: true, render: false };
-  }
-  if (prefetch2 === "render") {
-    return { intent: false, viewport: false, render: true };
-  }
-  return { intent: false, viewport: false, render: false };
-}
-function LinkInner({
-  href,
-  params,
-  query,
-  hash,
-  trailingSlash,
-  prefetch: prefetch2 = true,
-  prefetchDelay = 50,
-  replace = false,
-  scroll = true,
-  viewTransition = false,
-  locale,
-  onClick,
-  target,
-  onMouseEnter,
-  onMouseLeave,
-  onFocus,
-  onBlur,
-  onTouchStart,
-  ...props
-}, ref) {
-  const elementRef = useRef3(null);
-  const intentTimeoutRef = useRef3(null);
-  const activePrefetch = useRef3(null);
-  const farm = useOptionalFarm();
-  const { intent, viewport, render } = normalizePrefetch(prefetch2);
-  const baseHref = resolveLinkHref(href, params, {
-    query,
-    hash,
-    trailingSlash: trailingSlash ?? getFarmTrailingSlashPreference()
-  });
-  const localizedHref = localizeActiveFarmHref(baseHref, locale);
-  const resolvedHref = isExternalUrl(localizedHref) ? localizedHref : applyFarmBasePath(localizedHref, farm?.basePath ?? getFarmBasePath());
-  const isExternal = isExternalUrl(resolvedHref);
-  const isScriptHref = isFarmScriptURL(resolvedHref);
-  const doPrefetch = useCallback3(() => {
-    if (isExternal || activePrefetch.current) return;
-    const router = getRouter();
-    if (!router) return;
-    const token = Symbol(resolvedHref);
-    activePrefetch.current = token;
-    const reset = () => {
-      if (activePrefetch.current === token) activePrefetch.current = null;
-    };
-    try {
-      void router.prefetch(resolvedHref).then(reset, reset);
-    } catch {
-      reset();
-    }
-  }, [resolvedHref, isExternal]);
-  useEffect(() => {
-    activePrefetch.current = null;
-  }, [resolvedHref]);
-  useEffect(() => {
-    const element = elementRef.current;
-    if (!element || isExternal) return;
-    const router = getRouter();
-    if (!router) return;
-    if (viewport) {
-      router.observeForPrefetch(element);
-      return () => router.unobserveForPrefetch(element);
-    }
-  }, [resolvedHref, viewport, isExternal]);
-  useEffect(() => {
-    if (!render || isExternal) return;
-    let cancelled = false;
-    let timeoutId = null;
-    const tryRenderPrefetch = () => {
-      if (cancelled || activePrefetch.current) return;
-      const router = getRouter();
-      if (!router) {
-        timeoutId = setTimeout(tryRenderPrefetch, 30);
-        return;
-      }
-      doPrefetch();
-    };
-    tryRenderPrefetch();
-    return () => {
-      cancelled = true;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    };
-  }, [render, isExternal, resolvedHref, doPrefetch]);
-  useEffect(() => {
-    return () => {
-      if (intentTimeoutRef.current) {
-        clearTimeout(intentTimeoutRef.current);
-        intentTimeoutRef.current = null;
-      }
-    };
-  }, []);
-  const cancelIntent = useCallback3(() => {
-    if (intentTimeoutRef.current) {
-      clearTimeout(intentTimeoutRef.current);
-      intentTimeoutRef.current = null;
-    }
-  }, []);
-  const scheduleIntentPrefetch = useCallback3(() => {
-    if (isExternal || !intent || activePrefetch.current) return;
-    cancelIntent();
-    intentTimeoutRef.current = setTimeout(() => {
-      intentTimeoutRef.current = null;
-      doPrefetch();
-    }, prefetchDelay);
-  }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
-  const handleMouseEnter = useCallback3(
-    (event) => {
-      onMouseEnter?.(event);
-      scheduleIntentPrefetch();
-    },
-    [onMouseEnter, scheduleIntentPrefetch]
-  );
-  const handleMouseLeave = useCallback3(
-    (event) => {
-      onMouseLeave?.(event);
-      cancelIntent();
-    },
-    [onMouseLeave, cancelIntent]
-  );
-  const handleTouchStart = useCallback3(
-    (event) => {
-      onTouchStart?.(event);
-      scheduleIntentPrefetch();
-    },
-    [onTouchStart, scheduleIntentPrefetch]
-  );
-  const handleFocus = useCallback3(
-    (event) => {
-      onFocus?.(event);
-      scheduleIntentPrefetch();
-    },
-    [onFocus, scheduleIntentPrefetch]
-  );
-  const handleBlur = useCallback3(
-    (event) => {
-      onBlur?.(event);
-      cancelIntent();
-    },
-    [onBlur, cancelIntent]
-  );
-  const handleClick = useCallback3(
-    (event) => {
-      onClick?.(event);
-      if (isScriptHref) {
-        event.preventDefault();
-        isFarmBlockedNavigationURL(resolveFarmNavigationURL(resolvedHref, window.location.href));
-        return;
-      }
-      if (event.defaultPrevented) return;
-      if (isExternal) return;
-      if (event.currentTarget.hasAttribute("download")) return;
-      if (target && target !== "_self") return;
-      if (isModifierEvent(event)) return;
-      if (event.button !== 0) return;
-      if (typeof window !== "undefined") {
-        event.preventDefault();
-        if (isFarmLocaleChangeHref(localizedHref)) {
-          window.location.assign(resolvedHref);
-          return;
-        }
-        const router = getRouter();
-        if (router) {
-          router.navigate(resolvedHref, { replace, scroll, viewTransition });
-        } else {
-          if (replace) window.location.replace(resolvedHref);
-          else window.location.href = resolvedHref;
-        }
-      }
-    },
-    [
-      localizedHref,
-      resolvedHref,
-      replace,
-      scroll,
-      viewTransition,
-      target,
-      isExternal,
-      isScriptHref,
-      onClick
-    ]
-  );
-  const setRefs = useCallback3(
-    (node) => {
-      elementRef.current = node;
-      if (typeof ref === "function") ref(node);
-      else if (ref) ref.current = node;
-    },
-    [ref]
-  );
-  return /* @__PURE__ */ jsx2(
-    "a",
-    {
-      ref: setRefs,
-      href: isScriptHref ? void 0 : resolvedHref,
-      target,
-      onClick: handleClick,
-      onMouseEnter: handleMouseEnter,
-      onMouseLeave: handleMouseLeave,
-      onFocus: handleFocus,
-      onBlur: handleBlur,
-      onTouchStart: handleTouchStart,
-      ...props,
-      "data-farm-link": "",
-      "data-replace": replace ? "" : void 0,
-      "data-no-scroll": !scroll ? "" : void 0,
-      "data-view-transition": viewTransition === "auto" ? "auto" : viewTransition ? "true" : void 0
-    }
-  );
-}
-var LinkWithRef = forwardRef(LinkInner);
-LinkWithRef.displayName = "Link";
-var Link = LinkWithRef;
-function resolveLinkHref(href, params, options) {
-  if (isExternalUrl(href)) return href;
-  if (href.startsWith("#") && !params && !options.query && options.hash === void 0) return href;
-  const { pathname, query, hash } = splitInternalHref(href);
-  const resolvedHref = buildFarmRoutePath(pathname, params, {
-    query: mergeQueryParams(query, options.query),
-    hash: options.hash ?? hash,
-    trailingSlash: options.trailingSlash
-  });
-  return applyPreservedSearchParams(resolvedHref);
-}
-function splitInternalHref(href) {
-  try {
-    const url = new URL(href, "http://farm.local");
-    return {
-      pathname: url.pathname || "/",
-      query: url.searchParams,
-      hash: url.hash ? url.hash.slice(1) : void 0
-    };
-  } catch {
-    const [withoutHash, rawHash] = href.split("#", 2);
-    const [pathname, rawQuery] = withoutHash.split("?", 2);
-    return {
-      pathname: pathname || "/",
-      query: new URLSearchParams(rawQuery || ""),
-      hash: rawHash
-    };
-  }
-}
-function mergeQueryParams(current, next) {
-  const merged = new URLSearchParams(current);
-  if (next instanceof URLSearchParams) {
-    for (const [key, value] of next.entries()) {
-      merged.append(key, value);
-    }
-  } else if (next) {
-    for (const [key, value] of Object.entries(next)) {
-      const values = Array.isArray(value) ? value : [value];
-      for (const item of values) {
-        if (item == null) continue;
-        merged.append(key, String(item));
-      }
-    }
-  }
-  return merged.toString() ? merged : void 0;
-}
-function applyPreservedSearchParams(href) {
-  if (typeof window === "undefined") return href;
-  const manifest = window.__FARM_MANIFEST__;
-  const routes = manifest?.routes && typeof manifest.routes === "object" ? Object.values(manifest.routes) : [];
-  if (routes.length === 0) return href;
-  const url = resolveFarmNavigationURL(href, window.location.href);
-  const route = routes.find((candidate) => matchManifestRoute(url.pathname, candidate));
-  const preserve = Array.isArray(route?.search?.preserve) ? route.search.preserve : [];
-  if (preserve.length === 0) return href;
-  const current = new URLSearchParams(window.location.search);
-  let changed = false;
-  for (const key of preserve) {
-    if (url.searchParams.has(key) || !current.has(key)) continue;
-    for (const value of current.getAll(key)) {
-      url.searchParams.append(key, value);
-      changed = true;
-    }
-  }
-  if (!changed) return href;
-  return `${url.pathname}${url.search}${url.hash}`;
-}
-function matchManifestRoute(pathname, route) {
-  if (!route || !Array.isArray(route.segments)) return false;
-  const routeSegments = route.segments;
-  const normalized = pathname === "/" ? "" : pathname.replace(/^\/+/, "").replace(/\/+$/, "");
-  const pathSegments = normalized ? normalized.split("/") : [];
-  const hasCatchAll = routeSegments.some((segment) => segment.isCatchAll);
-  if (!hasCatchAll && pathSegments.length !== routeSegments.length) {
-    return false;
-  }
-  for (let index = 0; index < routeSegments.length; index++) {
-    const routeSegment = routeSegments[index];
-    const pathSegment = pathSegments[index];
-    if (routeSegment.isCatchAll) {
-      return true;
-    }
-    if (pathSegment === void 0) {
-      if (routeSegment.isOptional) continue;
-      return false;
-    }
-    if (!routeSegment.isDynamic && routeSegment.segment !== pathSegment) {
-      return false;
-    }
-  }
-  return pathSegments.length === routeSegments.length || hasCatchAll;
-}
-
-export {
-  FarmProvider,
-  useMutation,
-  FetcherInputError,
-  useFetcher,
-  FARM_CACHE_INVALIDATION_CHANNEL,
-  enableCrossTabCacheInvalidation,
-  enableLiveCacheInvalidation,
-  FARM_CLIENT_CACHE_PERSIST_VERSION,
-  defineClientCacheAdapter,
-  storageClientCacheAdapter,
-  initPersistedClientCache,
-  initConfiguredClientCachePersistence,
-  clearPersistedCache,
-  createStore,
-  Link
-};