@farm.js/core 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/client.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/client.ts
 var client_exports = {};
 __export(client_exports, {
+  APIClientError: () => APIClientError,
   FarmClientPluginManager: () => FarmClientPluginManager,
   IntegrationClientError: () => IntegrationClientError,
   Link: () => Link,
@@ -63,6 +64,7 @@ __export(client_exports, {
   readPageState: () => readPageState,
   replaceState: () => replaceState,
   useBlocker: () => useBlocker,
+  useMutation: () => useMutation,
   useNavigation: () => useNavigation,
   usePageState: () => usePageState,
   useRouter: () => useRouter,
@@ -180,7 +182,7 @@ function mergeIntegrationClientData(...values) {
       continue;
     }
     merged = {
-      ...merged || {},
+      ...merged,
       ...data
     };
   }
@@ -981,6 +983,7 @@ function formatError(error) {
 __name(formatError, "formatError");
 
 // src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
 var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
 var globalState = globalThis;
 function getFarmCacheInvalidationState() {
@@ -989,6 +992,34 @@ function getFarmCacheInvalidationState() {
   });
 }
 __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function notifyFarmCacheInvalidation(key) {
+  if (typeof key !== "string" || key.length === 0) return;
+  for (const listener of getFarmCacheInvalidationState().listeners) {
+    listener(key);
+  }
+}
+__name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
+function applyFarmCacheInvalidations(keys) {
+  if (!Array.isArray(keys)) return;
+  for (const key of keys) {
+    if (typeof key === "string") {
+      notifyFarmCacheInvalidation(key);
+    }
+  }
+}
+__name(applyFarmCacheInvalidations, "applyFarmCacheInvalidations");
+function decodeFarmCacheInvalidations(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(decodeURIComponent(value));
+    return Array.isArray(parsed) ? Array.from(
+      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
+    ) : [];
+  } catch {
+    return [];
+  }
+}
+__name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
 function subscribeFarmCacheInvalidation(listener) {
   const state = getFarmCacheInvalidationState();
   state.listeners.add(listener);
@@ -1437,6 +1468,19 @@ function normalizeFarmClientCacheKey(key) {
 __name(normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
 
 // src/api/client.ts
+var FARM_API_ROUTE_REF_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-ref");
+var _APIClientError = class _APIClientError extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "APIClientError";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+    this.response = options.response;
+  }
+};
+__name(_APIClientError, "APIClientError");
+var APIClientError = _APIClientError;
 function createAPIClient(options = {}) {
   options ?? (options = {});
   const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
@@ -1474,6 +1518,9 @@ function createAPIClient(options = {}) {
       fetchOptions.body = JSON.stringify(requestOptions.body);
     }
     const response = await fetch(url.toString(), fetchOptions);
+    applyFarmCacheInvalidations(
+      decodeFarmCacheInvalidations(response.headers?.get?.(FARM_CACHE_INVALIDATION_HEADER))
+    );
     let data = void 0;
     if (response.status !== 204 && response.status !== 205) {
       data = await response.json();
@@ -1713,9 +1760,15 @@ function createNestedProxy(path, client, routeMeta, baseURL, rootAliases) {
   const proxy = new Proxy(target, {
     // When accessing a property (api.hello)
     get(_target, prop) {
+      if (prop === FARM_API_ROUTE_REF_SYMBOL) {
+        return path.length > 0;
+      }
       if (path.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
         return rootAliases[prop];
       }
+      if (typeof prop !== "string") {
+        return Reflect.get(_target, prop);
+      }
       return createNestedProxy([...path, prop], client, routeMeta, baseURL, rootAliases);
     },
     // When calling as a function
@@ -1738,6 +1791,10 @@ function createNestedProxy(path, client, routeMeta, baseURL, rootAliases) {
   return proxy;
 }
 __name(createNestedProxy, "createNestedProxy");
+function isAPIRouteRef(value) {
+  return typeof value === "function" && value[FARM_API_ROUTE_REF_SYMBOL] === true;
+}
+__name(isAPIRouteRef, "isAPIRouteRef");
 function createServerAPIClient(endpoints, options = {}) {
   if (options.integrations === false || Object.prototype.hasOwnProperty.call(endpoints, "integrations")) {
     return endpoints;
@@ -1804,7 +1861,10 @@ function resolveTargetKey(routeMeta, target, input, baseURL = "http://localhost:
   }
   if (Array.isArray(target)) {
     const [route2, routeInput] = target;
-    return resolveTargetKey(routeMeta, route2, routeInput, baseURL);
+    if (typeof route2 === "function") {
+      return resolveTargetKey(routeMeta, route2, routeInput, baseURL);
+    }
+    return normalizeFarmClientCacheKey(target);
   }
   if ("key" in target) return normalizeFarmClientCacheKey(target.key);
   if ("path" in target) {
@@ -1830,21 +1890,207 @@ function resolveRouteMeta(meta) {
 }
 __name(resolveRouteMeta, "resolveRouteMeta");
 function normalizeError(error) {
-  if (error instanceof Error) return error;
-  return new Error(typeof error === "string" ? error : "Unknown error");
+  if (error instanceof APIClientError) return error;
+  const normalized = new APIClientError("network_error", void 0, {
+    status: 0,
+    message: error instanceof Error ? error.message : typeof error === "string" ? error : "Network request failed"
+  });
+  normalized.cause = error;
+  return normalized;
 }
 __name(normalizeError, "normalizeError");
 function createResponseError2(response, data) {
-  const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
-  error.status = response.status;
-  error.response = response;
-  error.data = data;
-  return error;
+  const expected = readEndpointErrorEnvelope(data);
+  if (expected) {
+    return new APIClientError(expected.code, expected.data, {
+      status: response.status,
+      message: expected.message,
+      response
+    });
+  }
+  return new APIClientError("http_error", data, {
+    status: response.status,
+    message: `HTTP ${response.status}: ${response.statusText}`,
+    response
+  });
 }
 __name(createResponseError2, "createResponseError");
+function readEndpointErrorEnvelope(data) {
+  if (!data || typeof data !== "object") return null;
+  const error = data.error;
+  if (!error || typeof error !== "object") return null;
+  const code = error.code;
+  const message = error.message;
+  if (typeof code !== "string" || typeof message !== "string") return null;
+  return {
+    code,
+    message,
+    data: error.data
+  };
+}
+__name(readEndpointErrorEnvelope, "readEndpointErrorEnvelope");
 
-// src/server-query-client.ts
+// src/mutation-client.ts
 var import_react = require("react");
+function useMutation(target, options = {}) {
+  const initialData = options.initialData ?? null;
+  const optionsRef = (0, import_react.useRef)(options);
+  const targetRef = (0, import_react.useRef)(target);
+  const requestIdRef = (0, import_react.useRef)(0);
+  const initialState = {
+    pendingCount: 0,
+    status: "idle",
+    data: initialData,
+    error: null,
+    variables: void 0
+  };
+  const stateRef = (0, import_react.useRef)(initialState);
+  const [state, setState] = (0, import_react.useState)(initialState);
+  optionsRef.current = options;
+  targetRef.current = target;
+  const setMutationState = (0, import_react.useCallback)(
+    (value) => {
+      setState((current) => {
+        const next = typeof value === "function" ? value(current) : value;
+        stateRef.current = next;
+        return next;
+      });
+    },
+    []
+  );
+  const mutateAsync = (0, import_react.useCallback)(
+    async (variables) => {
+      const requestId = ++requestIdRef.current;
+      const currentOptions = optionsRef.current;
+      const previousData = stateRef.current.data;
+      const optimisticData = 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
+      }));
+      try {
+        const mutationTarget = targetRef.current;
+        const rawResult = isAPIRouteRef(mutationTarget) ? await mutationTarget(variables, currentOptions.request) : await mutationTarget(variables);
+        const data = unwrapMutationResult(rawResult, isAPIRouteRef(mutationTarget));
+        const isLatestRequest = requestId === requestIdRef.current;
+        setMutationState((current) => {
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount,
+              status: pendingCount > 0 ? "pending" : current.status
+            };
+          }
+          return {
+            pendingCount,
+            status: "success",
+            data,
+            error: null,
+            variables
+          };
+        });
+        if (isLatestRequest) {
+          currentOptions.onSuccess?.(data, variables);
+          currentOptions.onSettled?.(data, null, variables);
+        }
+        return data;
+      } catch (cause) {
+        const error = normalizeMutationError(cause);
+        const isLatestRequest = requestId === requestIdRef.current;
+        setMutationState((current) => {
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount,
+              status: pendingCount > 0 ? "pending" : current.status
+            };
+          }
+          return {
+            pendingCount,
+            status: "error",
+            data: hasOptimisticData && currentOptions.rollbackOnError ? previousData : currentOptions.resetOnMutate === false ? current.data : null,
+            error,
+            variables
+          };
+        });
+        if (isLatestRequest) {
+          currentOptions.onError?.(error, variables);
+          currentOptions.onSettled?.(null, error, variables);
+        }
+        throw error;
+      }
+    },
+    [setMutationState]
+  );
+  const mutate = (0, import_react.useCallback)(
+    (variables) => {
+      void mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  const reset = (0, import_react.useCallback)(() => {
+    requestIdRef.current += 1;
+    setMutationState({
+      pendingCount: 0,
+      status: "idle",
+      data: optionsRef.current.initialData ?? null,
+      error: null,
+      variables: void 0
+    });
+  }, [setMutationState]);
+  return (0, import_react.useMemo)(
+    () => ({
+      pending: state.pendingCount > 0,
+      status: state.status,
+      data: state.data,
+      error: state.error,
+      variables: state.variables,
+      mutate,
+      mutateAsync,
+      reset
+    }),
+    [
+      mutate,
+      mutateAsync,
+      reset,
+      state.data,
+      state.error,
+      state.pendingCount,
+      state.status,
+      state.variables
+    ]
+  );
+}
+__name(useMutation, "useMutation");
+function unwrapMutationResult(result, apiRoute) {
+  if (!apiRoute) return result;
+  const apiResult = result;
+  if (apiResult.error) {
+    throw apiResult.error;
+  }
+  return apiResult.data;
+}
+__name(unwrapMutationResult, "unwrapMutationResult");
+function normalizeMutationError(error) {
+  if (error instanceof Error) return error;
+  const normalized = new Error(typeof error === "string" ? error : "Mutation failed");
+  normalized.cause = error;
+  return normalized;
+}
+__name(normalizeMutationError, "normalizeMutationError");
+
+// src/server-query-client.ts
+var import_react2 = require("react");
 var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
 var serverQueryClientGlobal = globalThis;
 var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ?? (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
@@ -1876,25 +2122,25 @@ __name(prefetchServerQuery, "prefetchServerQuery");
 function useServerQuery(query, input, options = {}) {
   const cache = getFarmClientDataCache();
   const key = createServerQueryCallKey(query, input);
-  const inputRef = (0, import_react.useRef)(input);
-  const optionsRef = (0, import_react.useRef)(options);
-  const mountedKeyRef = (0, import_react.useRef)();
+  const inputRef = (0, import_react2.useRef)(input);
+  const optionsRef = (0, import_react2.useRef)(options);
+  const mountedKeyRef = (0, import_react2.useRef)();
   inputRef.current = input;
   optionsRef.current = options;
-  const subscribe = (0, import_react.useCallback)(
+  const subscribe = (0, import_react2.useCallback)(
     (listener) => cache.subscribe(key, 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)(
+  const getSnapshot = (0, import_react2.useCallback)(() => cache.get(key), [cache, key]);
+  const entry = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
+  const run = (0, import_react2.useCallback)(
     (force = false) => fetchServerQuery(query, inputRef.current, {
       ...optionsRef.current,
       force
     }),
     [query]
   );
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     if (options.enabled === false) return;
     const firstReadForKey = mountedKeyRef.current !== key;
     if (firstReadForKey) mountedKeyRef.current = key;
@@ -1902,7 +2148,7 @@ function useServerQuery(query, input, options = {}) {
       void run().catch(() => void 0);
     }
   }, [cache, entry, key, options.enabled, run]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     if (options.enabled === false || typeof window === "undefined") return;
     const refreshIfStale = /* @__PURE__ */ __name(() => {
       if (cache.isStale(key)) void run().catch(() => void 0);
@@ -2215,7 +2461,7 @@ var api = {
 var endpoint = api;
 
 // src/store.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
   "use",
   "get",
@@ -2347,20 +2593,20 @@ function createStore(initialState, extend) {
         }
         return lastSlice;
       }, "getSnapshot");
-      return (0, import_react2.useSyncExternalStore)(
+      return (0, import_react3.useSyncExternalStore)(
         (notify) => addSubscription(keys, () => notify()),
         getSnapshot,
         getSnapshot
       );
     }
     if (typeof keyOrKeys === "string") {
-      return (0, import_react2.useSyncExternalStore)(
+      return (0, import_react3.useSyncExternalStore)(
         (notify) => addSubscription([keyOrKeys], () => notify()),
         () => state[keyOrKeys],
         () => state[keyOrKeys]
       );
     }
-    return (0, import_react2.useSyncExternalStore)(
+    return (0, import_react3.useSyncExternalStore)(
       (notify) => addSubscription(null, () => notify()),
       () => state,
       () => state
@@ -2412,7 +2658,7 @@ function createStore(initialState, extend) {
 __name(createStore, "createStore");
 
 // src/client/link.tsx
-var import_react3 = require("react");
+var import_react4 = require("react");
 
 // src/router.ts
 function createFarmRouter(routes) {
@@ -2812,9 +3058,9 @@ function LinkInner({
   onTouchStart,
   ...props
 }, ref) {
-  const elementRef = (0, import_react3.useRef)(null);
-  const intentTimeoutRef = (0, import_react3.useRef)(null);
-  const hasPrefetched = (0, import_react3.useRef)(false);
+  const elementRef = (0, import_react4.useRef)(null);
+  const intentTimeoutRef = (0, import_react4.useRef)(null);
+  const hasPrefetched = (0, import_react4.useRef)(false);
   const { intent, viewport, render } = normalizePrefetch(prefetch2);
   const baseHref = resolveLinkHref(href, params, {
     query,
@@ -2823,17 +3069,17 @@ function LinkInner({
   });
   const resolvedHref = localizeActiveFarmHref(baseHref, locale);
   const isExternal = isExternalUrl(resolvedHref);
-  const doPrefetch = (0, import_react3.useCallback)(() => {
+  const doPrefetch = (0, import_react4.useCallback)(() => {
     if (isExternal || hasPrefetched.current) return;
     const router = getRouter();
     if (!router) return;
     hasPrefetched.current = true;
     router.prefetch(resolvedHref);
   }, [resolvedHref, isExternal]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     hasPrefetched.current = false;
   }, [resolvedHref]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     const element = elementRef.current;
     if (!element || isExternal) return;
     const router = getRouter();
@@ -2843,7 +3089,7 @@ function LinkInner({
       return () => router.unobserveForPrefetch(element);
     }
   }, [resolvedHref, viewport, isExternal]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (!render || isExternal) return;
     let cancelled = false;
     let timeoutId = null;
@@ -2865,7 +3111,7 @@ function LinkInner({
       }
     };
   }, [render, isExternal, resolvedHref]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     return () => {
       if (intentTimeoutRef.current) {
         clearTimeout(intentTimeoutRef.current);
@@ -2873,13 +3119,13 @@ function LinkInner({
       }
     };
   }, []);
-  const cancelIntent = (0, import_react3.useCallback)(() => {
+  const cancelIntent = (0, import_react4.useCallback)(() => {
     if (intentTimeoutRef.current) {
       clearTimeout(intentTimeoutRef.current);
       intentTimeoutRef.current = null;
     }
   }, []);
-  const scheduleIntentPrefetch = (0, import_react3.useCallback)(() => {
+  const scheduleIntentPrefetch = (0, import_react4.useCallback)(() => {
     if (isExternal || !intent || hasPrefetched.current) return;
     cancelIntent();
     intentTimeoutRef.current = setTimeout(() => {
@@ -2887,42 +3133,42 @@ function LinkInner({
       doPrefetch();
     }, prefetchDelay);
   }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
-  const handleMouseEnter = (0, import_react3.useCallback)(
+  const handleMouseEnter = (0, import_react4.useCallback)(
     (event) => {
       onMouseEnter?.(event);
       scheduleIntentPrefetch();
     },
     [onMouseEnter, scheduleIntentPrefetch]
   );
-  const handleMouseLeave = (0, import_react3.useCallback)(
+  const handleMouseLeave = (0, import_react4.useCallback)(
     (event) => {
       onMouseLeave?.(event);
       cancelIntent();
     },
     [onMouseLeave, cancelIntent]
   );
-  const handleTouchStart = (0, import_react3.useCallback)(
+  const handleTouchStart = (0, import_react4.useCallback)(
     (event) => {
       onTouchStart?.(event);
       scheduleIntentPrefetch();
     },
     [onTouchStart, scheduleIntentPrefetch]
   );
-  const handleFocus = (0, import_react3.useCallback)(
+  const handleFocus = (0, import_react4.useCallback)(
     (event) => {
       onFocus?.(event);
       scheduleIntentPrefetch();
     },
     [onFocus, scheduleIntentPrefetch]
   );
-  const handleBlur = (0, import_react3.useCallback)(
+  const handleBlur = (0, import_react4.useCallback)(
     (event) => {
       onBlur?.(event);
       cancelIntent();
     },
     [onBlur, cancelIntent]
   );
-  const handleClick = (0, import_react3.useCallback)(
+  const handleClick = (0, import_react4.useCallback)(
     (event) => {
       onClick?.(event);
       if (event.defaultPrevented) return;
@@ -2947,7 +3193,7 @@ function LinkInner({
     },
     [resolvedHref, replace, scroll, viewTransition, target, isExternal, onClick]
   );
-  const setRefs = (0, import_react3.useCallback)(
+  const setRefs = (0, import_react4.useCallback)(
     (node) => {
       elementRef.current = node;
       if (typeof ref === "function") ref(node);
@@ -2976,7 +3222,7 @@ function LinkInner({
   );
 }
 __name(LinkInner, "LinkInner");
-var LinkWithRef = (0, import_react3.forwardRef)(LinkInner);
+var LinkWithRef = (0, import_react4.forwardRef)(LinkInner);
 LinkWithRef.displayName = "Link";
 var Link = LinkWithRef;
 function resolveLinkHref(href, params, options) {
@@ -3077,7 +3323,7 @@ function matchManifestRoute(pathname, route2) {
 __name(matchManifestRoute, "matchManifestRoute");
 
 // src/client/router.ts
-var import_react4 = require("react");
+var import_react5 = require("react");
 
 // src/deferred.ts
 var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
@@ -3833,14 +4079,14 @@ function useRouter(options = {}) {
   const basePath = options.basePath || "";
   const routes = options.routes;
   const routeKey = routes?.map((route2) => typeof route2 === "string" ? route2 : route2.path).join("\n") || "";
-  const routeMatcher = (0, import_react4.useMemo)(
+  const routeMatcher = (0, import_react5.useMemo)(
     () => routeKey ? createFarmRouter(routeKey.split("\n")) : null,
     [routeKey]
   );
-  const [state, setState] = (0, import_react4.useState)(() => {
+  const [state, setState] = (0, import_react5.useState)(() => {
     return readRouterState(basePath, routeMatcher);
   });
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (typeof window === "undefined") return;
     const handlePopState = /* @__PURE__ */ __name(() => {
       setState(readRouterState(basePath, routeMatcher));
@@ -3891,8 +4137,8 @@ function useRouter(options = {}) {
 }
 __name(useRouter, "useRouter");
 function usePageState() {
-  const [state, setState] = (0, import_react4.useState)(() => readPageState());
-  (0, import_react4.useEffect)(() => {
+  const [state, setState] = (0, import_react5.useState)(() => readPageState());
+  (0, import_react5.useEffect)(() => {
     if (typeof window === "undefined") return;
     const handlePopState = /* @__PURE__ */ __name(() => {
       setState(readPageState());
@@ -3905,10 +4151,10 @@ function usePageState() {
 }
 __name(usePageState, "usePageState");
 function useNavigation() {
-  const [state, setState] = (0, import_react4.useState)(
+  const [state, setState] = (0, import_react5.useState)(
     () => getRouter2().getNavigationState()
   );
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (typeof window === "undefined") return;
     return getRouter2().subscribeNavigation(setState);
   }, []);
@@ -3916,10 +4162,10 @@ function useNavigation() {
 }
 __name(useNavigation, "useNavigation");
 function useBlocker(options) {
-  const optionsRef = (0, import_react4.useRef)(options);
+  const optionsRef = (0, import_react5.useRef)(options);
   optionsRef.current = options;
   const active = Boolean(options.when);
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (typeof window === "undefined" || !active) {
       return;
     }
@@ -3940,8 +4186,8 @@ function useBlocker(options) {
 }
 __name(useBlocker, "useBlocker");
 function useScrollRestoration(key) {
-  const ref = (0, import_react4.useRef)(null);
-  (0, import_react4.useEffect)(() => {
+  const ref = (0, import_react5.useRef)(null);
+  (0, import_react5.useEffect)(() => {
     const element = ref.current;
     if (!element) return;
     return getRouter2().registerScrollElement(key, element);
@@ -4530,6 +4776,7 @@ function isObject(value) {
 __name(isObject, "isObject");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APIClientError,
   FarmClientPluginManager,
   IntegrationClientError,
   Link,
@@ -4562,6 +4809,7 @@ __name(isObject, "isObject");
   readPageState,
   replaceState,
   useBlocker,
+  useMutation,
   useNavigation,
   usePageState,
   useRouter,