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

package/dist/{chunk-HHZAOTQD.mjs → chunk-GJ7W6LNK.mjs}

@@ -1,19 +1,19 @@
 import {
   _parseServerFnSchema,
   createServerFn
-} from "./chunk-RLGUZ3HS.mjs";
+} from "./chunk-I3OOUWO5.mjs";
 import {
   createFarmServerQueryResult
-} from "./chunk-SCFX4UTD.mjs";
+} from "./chunk-EHTUKVSW.mjs";
 import {
   getServerActionExecutionContext
-} from "./chunk-VV24CC42.mjs";
+} from "./chunk-35NPLKQJ.mjs";
 import {
   createFarmCacheKey,
   createRouteDataCacheKey,
   createRouteDataCacheTag,
   getFarmDataCache
-} from "./chunk-AXVJCMVF.mjs";
+} from "./chunk-2HDOV47R.mjs";
 import {
   __name
 } from "./chunk-CGILA3WO.mjs";
@@ -58,7 +58,8 @@ function createServerQuery(options) {
       return createFarmServerQueryResult(data, {
         key: clientKey,
         staleTime,
-        updatedAt
+        updatedAt,
+        ...options.persist === true ? { persist: true } : {}
       });
     }, "handler")
   });
@@ -139,4 +140,4 @@ export {
   FARM_SERVER_QUERY_SYMBOL,
   createServerQuery
 };
-//# sourceMappingURL=chunk-HHZAOTQD.mjs.map
+//# sourceMappingURL=chunk-GJ7W6LNK.mjs.map

package/dist/chunk-GJ7W6LNK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server-query.ts"],"sourcesContent":["import {\n  createFarmCacheKey,\n  createRouteDataCacheKey,\n  createRouteDataCacheTag,\n  getFarmDataCache,\n  type RouteDataCacheKey,\n} from \"./cache\";\nimport { getServerActionExecutionContext } from \"./server-action-security\";\nimport {\n  createServerFn,\n  type AnyServerFnMiddleware,\n  type InferServerFnSchemaInput,\n  type InferServerFnSchemaOutput,\n  type ServerFn,\n  type ServerFnContext,\n  type ServerFnHandler,\n  type ServerFnHandlerContext,\n  type ServerFnMiddlewareContext,\n  type ServerFnSchema,\n  _parseServerFnSchema,\n} from \"./server-fn\";\nimport { createFarmServerQueryResult, type FarmServerQueryResult } from \"./server-query-protocol\";\n\ntype MaybePromise<T> = T | Promise<T>;\n\nexport type ServerQueryStaleTime = number | false | `${number}${\"ms\" | \"s\" | \"m\" | \"h\"}`;\n\nexport type ServerQueryKey<TInput, TContext extends object = {}> = (\n  context: ServerFnContext<TInput, TContext>,\n) => MaybePromise<RouteDataCacheKey>;\n\nexport type ServerQueryOptions<\n  TSchema extends ServerFnSchema | undefined,\n  TResult,\n  TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [],\n> = {\n  input?: TSchema;\n  output?: undefined;\n  middleware?: TMiddlewares;\n  key: ServerQueryKey<\n    TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown,\n    ServerFnMiddlewareContext<TMiddlewares>\n  >;\n  /** Milliseconds, a duration string such as \"30s\", or false for no expiry. */\n  staleTime?: ServerQueryStaleTime;\n  /** Allow the configured client cache persistence adapter to store results on the device. */\n  persist?: boolean;\n  handler: ServerFnHandler<\n    TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown,\n    TResult,\n    ServerFnMiddlewareContext<TMiddlewares>\n  >;\n};\n\nexport type ServerQueryOutputOptions<\n  TInputSchema extends ServerFnSchema | undefined,\n  TOutputSchema extends ServerFnSchema,\n  TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [],\n> = {\n  input?: TInputSchema;\n  output: TOutputSchema;\n  middleware?: TMiddlewares;\n  key: ServerQueryKey<\n    TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown,\n    ServerFnMiddlewareContext<TMiddlewares>\n  >;\n  /** Milliseconds, a duration string such as \"30s\", or false for no expiry. */\n  staleTime?: ServerQueryStaleTime;\n  /** Allow the configured client cache persistence adapter to store results on the device. */\n  persist?: boolean;\n  handler: ServerFnHandler<\n    TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown,\n    unknown,\n    ServerFnMiddlewareContext<TMiddlewares>\n  >;\n};\n\nexport type ServerQuery<TInput, TResult> = ([unknown] extends [TInput]\n  ? (input?: TInput) => Promise<TResult>\n  : (input: TInput) => Promise<TResult>) & {\n  readonly __farmServerQuery: true;\n  readonly __farmServerQueryInput?: unknown;\n  readonly __farmServerQueryOutput?: unknown;\n};\n\nexport const FARM_SERVER_QUERY_SYMBOL = Symbol.for(\"farm.server-query\");\n\ntype AnyServerQueryOptions = {\n  input?: ServerFnSchema;\n  output?: ServerFnSchema;\n  middleware?: readonly AnyServerFnMiddleware[];\n  key: ServerQueryKey<any, any>;\n  staleTime?: ServerQueryStaleTime;\n  persist?: boolean;\n  handler: ServerFnHandler<any, any, any>;\n};\n\nconst requestInflight = new WeakMap<Request, Map<string, Promise<unknown>>>();\nconst detachedInflight = new Map<string, Promise<unknown>>();\n\nexport function createServerQuery<\n  TInputSchema extends ServerFnSchema,\n  TOutputSchema extends ServerFnSchema,\n  const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [],\n>(\n  options: ServerQueryOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>,\n): ServerQuery<\n  InferServerFnSchemaInput<TInputSchema>,\n  Awaited<InferServerFnSchemaOutput<TOutputSchema>>\n>;\nexport function createServerQuery<\n  TOutputSchema extends ServerFnSchema,\n  const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [],\n>(\n  options: ServerQueryOutputOptions<undefined, TOutputSchema, TMiddlewares>,\n): ServerQuery<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;\nexport function createServerQuery<\n  TSchema extends ServerFnSchema,\n  TResult,\n  const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [],\n>(\n  options: ServerQueryOptions<TSchema, TResult, TMiddlewares>,\n): ServerQuery<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;\nexport function createServerQuery<\n  TResult,\n  const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [],\n>(\n  options: ServerQueryOptions<undefined, TResult, TMiddlewares>,\n): ServerQuery<unknown, Awaited<TResult>>;\nexport function createServerQuery(options: AnyServerQueryOptions): ServerQuery<unknown, unknown> {\n  if (!options || typeof options.handler !== \"function\") {\n    throw new TypeError(\"createServerQuery requires a handler function\");\n  }\n  if (typeof options.key !== \"function\") {\n    throw new TypeError(\"createServerQuery requires a key function\");\n  }\n\n  const staleTime = normalizeServerQueryStaleTime(options.staleTime);\n  const execute = (\n    createServerFn as (options: any) => ServerFn<unknown, FarmServerQueryResult<any>>\n  )({\n    input: options.input,\n    middleware: options.middleware,\n    handler: async (context: ServerFnHandlerContext<any, any>) => {\n      const routeKey = await options.key(context);\n      assertServerQueryKey(routeKey);\n\n      const clientKey = createRouteDataCacheKey(routeKey);\n      const cacheKey = createFarmCacheKey([\"route-data\", routeKey]);\n      const producer = async () => {\n        const value = await options.handler(context);\n        return _parseServerFnSchema(options.output, value, \"output\", \"createServerQuery\");\n      };\n\n      let data: unknown;\n      let updatedAt: number;\n\n      if (staleTime === 0) {\n        data = await dedupeServerQueryRequest(cacheKey, context.request, producer);\n        updatedAt = Date.now();\n      } else {\n        const cache = getFarmDataCache();\n        data = await cache.getOrSet(cacheKey, producer, {\n          tags: [createRouteDataCacheTag(routeKey)],\n          revalidate: staleTime === false ? false : staleTime / 1000,\n        });\n        updatedAt =\n          (await cache.getEntryAsync(cacheKey, { allowStale: true }))?.createdAt ?? Date.now();\n      }\n\n      return createFarmServerQueryResult(data, {\n        key: clientKey,\n        staleTime,\n        updatedAt,\n        ...(options.persist === true ? { persist: true } : {}),\n      });\n    },\n  });\n\n  const query = async (input?: unknown) => {\n    const result = await execute(input);\n    return getServerActionExecutionContext() ? result : result.data;\n  };\n\n  Object.defineProperties(query, {\n    [FARM_SERVER_QUERY_SYMBOL]: {\n      value: true,\n      enumerable: false,\n    },\n    __farmServerQuery: {\n      value: true,\n      enumerable: false,\n    },\n    __farmServerQueryInput: {\n      value: options.input,\n      enumerable: false,\n    },\n    __farmServerQueryOutput: {\n      value: options.output,\n      enumerable: false,\n    },\n  });\n\n  return query as ServerQuery<unknown, unknown>;\n}\n\nasync function dedupeServerQueryRequest<TData>(\n  key: string,\n  request: Request | undefined,\n  producer: () => Promise<TData>,\n): Promise<TData> {\n  let inflight: Map<string, Promise<unknown>>;\n  if (request) {\n    inflight = requestInflight.get(request) ?? new Map();\n    requestInflight.set(request, inflight);\n  } else {\n    inflight = detachedInflight;\n  }\n\n  const existing = inflight.get(key) as Promise<TData> | undefined;\n  if (existing) return existing;\n\n  const promise = Promise.resolve().then(producer);\n  inflight.set(key, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflight.delete(key);\n  }\n}\n\nfunction normalizeServerQueryStaleTime(value: ServerQueryStaleTime | undefined): number | false {\n  if (value === false) return false;\n  if (value === undefined) return 0;\n\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value) || value < 0) {\n      throw new TypeError(\"createServerQuery staleTime must be a non-negative duration\");\n    }\n    return value;\n  }\n\n  const match = value.match(/^(\\d+(?:\\.\\d+)?)(ms|s|m|h)$/);\n  if (!match) {\n    throw new TypeError('createServerQuery staleTime must look like \"250ms\", \"30s\", \"5m\", or \"1h\"');\n  }\n\n  const amount = Number(match[1]);\n  const unit = match[2];\n  const multiplier = unit === \"ms\" ? 1 : unit === \"s\" ? 1000 : unit === \"m\" ? 60_000 : 3_600_000;\n  return amount * multiplier;\n}\n\nfunction assertServerQueryKey(key: unknown): asserts key is RouteDataCacheKey {\n  if (typeof key === \"string\") {\n    if (key.trim().length > 0) return;\n  } else if (Array.isArray(key)) {\n    return;\n  }\n\n  throw new TypeError(\"createServerQuery key must return a non-empty string or an array\");\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-RLGUZ3HS.mjs → chunk-I3OOUWO5.mjs}

@@ -2,10 +2,10 @@ import {
   ServerFnFailure,
   getServerActionExecutionContext,
   getServerActionSignal
-} from "./chunk-VV24CC42.mjs";
+} from "./chunk-35NPLKQJ.mjs";
 import {
   applyFarmCacheInvalidationTargets
-} from "./chunk-AXVJCMVF.mjs";
+} from "./chunk-2HDOV47R.mjs";
 import {
   _resolveCurrentRequest
 } from "./chunk-LM2YNO4U.mjs";
@@ -300,4 +300,4 @@ export {
   createServerFn,
   _parseServerFnSchema
 };
-//# sourceMappingURL=chunk-RLGUZ3HS.mjs.map
+//# sourceMappingURL=chunk-I3OOUWO5.mjs.map

package/dist/{chunk-75CGAL6E.mjs → chunk-IZBX2TEU.mjs}

@@ -1,8 +1,11 @@
+import {
+  notifyClientObserver
+} from "./chunk-DU3PKDVQ.mjs";
 import {
   FarmClientDataCache,
   getFarmClientDataCache,
   normalizeFarmClientCacheKey
-} from "./chunk-DLBUAJTK.mjs";
+} from "./chunk-WMJGA32P.mjs";
 import {
   resolveAPIRequestRuntime
 } from "./chunk-YECMFULZ.mjs";
@@ -12,7 +15,7 @@ import {
   matchAPIRoute,
   parseDynamicSegment,
   readJSONStream
-} from "./chunk-XTLLHCWU.mjs";
+} from "./chunk-V4VRLVLW.mjs";
 import {
   getFarmAPIBaseURL,
   resolveFarmAPIRequestURL
@@ -21,7 +24,7 @@ import {
   FARM_CACHE_INVALIDATION_HEADER,
   applyFarmCacheInvalidations,
   decodeFarmCacheInvalidations
-} from "./chunk-RBRLLZL5.mjs";
+} from "./chunk-34IAPZBG.mjs";
 import {
   _resolveCurrentRequest
 } from "./chunk-LM2YNO4U.mjs";
@@ -125,33 +128,6 @@ function createClientCancellation(signal, timeoutMs = 0, parent) {
 }
 __name(createClientCancellation, "createClientCancellation");
 
-// src/client-observers.ts
-function notifyClientObserver(observer, args, label = "Client lifecycle") {
-  if (!observer) return;
-  const report = /* @__PURE__ */ __name((error) => {
-    const reportError = globalThis.reportError;
-    if (typeof reportError === "function") {
-      try {
-        reportError.call(globalThis, error);
-        return;
-      } catch {
-      }
-    }
-    try {
-      console.error(`[Farm.js] ${label} callback failed:`, error);
-    } catch {
-    }
-  }, "report");
-  try {
-    const result = observer(...args);
-    if (result && typeof result.then === "function")
-      void Promise.resolve(result).catch(report);
-  } catch (error) {
-    report(error);
-  }
-}
-__name(notifyClientObserver, "notifyClientObserver");
-
 // src/integration-client.ts
 var _IntegrationClientError = class _IntegrationClientError extends Error {
   constructor(message, response, data) {
@@ -633,7 +609,8 @@ async function executeServerOperation(operation, input, options, requestOptions,
         serverRequestOptions?.baseURL ?? options.baseURL,
         request
       );
-      const url = new URL(operation.path, baseURL);
+      const origin = resolveServerBaseURL(void 0, request);
+      const url = new URL(operation.path, new URL(baseURL, origin));
       appendQuery(url, input.query);
       const headers = new Headers();
       appendHeaders(
@@ -686,7 +663,9 @@ async function executeServerOperation(operation, input, options, requestOptions,
       }
       appendIntegrationClientDataHeader(headers, data);
       const body = createOperationBody(operation, input.body, headers);
-      const response = await (options.fetch ?? fetch)(url.toString(), {
+      const httpURL = resolveFarmAPIRequestURL(operation.path, baseURL, origin);
+      appendQuery(httpURL, input.query);
+      const response = await (options.fetch ?? fetch)(httpURL.toString(), {
         method: operation.method,
         headers,
         body,
@@ -1287,69 +1266,6 @@ function createAPIClientRuntime(options = {}, transport) {
   let scopedRequestState;
   const routeMeta = transport?.routeMeta ?? /* @__PURE__ */ new WeakMap();
   let requestCounter = 0;
-  const applyOptimisticLayer = /* @__PURE__ */ __name((entry, layer) => {
-    let data = entry?.data;
-    for (const updater of layer.updaters) data = updater(data);
-    return {
-      data,
-      updatedAt: layer.updatedAt,
-      staleAt: entry?.staleAt ?? layer.staleAt,
-      gcAt: entry?.gcAt ?? layer.gcAt,
-      invalidatedAt: entry?.invalidatedAt
-    };
-  }, "applyOptimisticLayer");
-  const storeOptimisticEntry = /* @__PURE__ */ __name((cacheState, key, stack, entry) => {
-    if (!entry) {
-      cacheState.delete(key);
-      stack.renderedEntry = void 0;
-      return;
-    }
-    cacheState.set(key, entry);
-    if (stack.invalidatedAt !== void 0) {
-      cacheState.invalidate(key, stack.invalidatedAt);
-    }
-    stack.renderedEntry = cacheState.get(key);
-  }, "storeOptimisticEntry");
-  const reconcileOptimisticInvalidation = /* @__PURE__ */ __name((cacheState, key, stack) => {
-    const current = cacheState.get(key);
-    const rendered = stack.renderedEntry;
-    if (current === rendered) return true;
-    if (!current || !rendered || current.data !== rendered.data || current.updatedAt !== rendered.updatedAt || current.gcAt !== rendered.gcAt || current.status !== rendered.status || current.error !== rendered.error || current.fetching !== rendered.fetching || current.staleAt !== 0 || current.invalidatedAt === void 0) {
-      return false;
-    }
-    stack.invalidatedAt = current.invalidatedAt;
-    stack.renderedEntry = current;
-    return true;
-  }, "reconcileOptimisticInvalidation");
-  const renderOptimisticStack = /* @__PURE__ */ __name((cacheState, key, stack) => {
-    let entry = stack.entry ? { ...stack.entry } : void 0;
-    for (const layer of stack.layers) entry = applyOptimisticLayer(entry, layer);
-    storeOptimisticEntry(cacheState, key, stack, entry);
-  }, "renderOptimisticStack");
-  const settleOptimisticUpdates = /* @__PURE__ */ __name((cacheState, optimisticState, snapshots, outcome) => {
-    const settledKeys = [];
-    for (const snapshot of snapshots) {
-      const stack = optimisticState.get(snapshot.key);
-      if (stack !== snapshot.stack) continue;
-      if (!reconcileOptimisticInvalidation(cacheState, snapshot.key, stack)) {
-        optimisticState.delete(snapshot.key);
-        continue;
-      }
-      if (outcome === "rollback") {
-        stack.layers = stack.layers.filter((layer) => layer !== snapshot.layer);
-      } else {
-        snapshot.layer.committed = true;
-        if (outcome === "invalidate") stack.invalidatedAt = Date.now();
-      }
-      while (stack.layers[0]?.committed) {
-        stack.entry = applyOptimisticLayer(stack.entry, stack.layers.shift());
-      }
-      renderOptimisticStack(cacheState, snapshot.key, stack);
-      if (stack.layers.length === 0) optimisticState.delete(snapshot.key);
-      settledKeys.push(snapshot.key);
-    }
-    return settledKeys;
-  }, "settleOptimisticUpdates");
   const fetchClient = /* @__PURE__ */ __name(async (path, requestOptions, defaultHeaders, cancellation) => {
     const url = resolveFarmAPIRequestURL(path, baseURL);
     const method = String(requestOptions.method || "GET").toUpperCase();
@@ -1582,6 +1498,9 @@ function createAPIClientRuntime(options = {}, transport) {
       const executeNetwork = /* @__PURE__ */ __name(async (opts) => {
         const release = cancellation.hold();
         let unsubscribeInvalidation;
+        let readOwners;
+        let readOwner;
+        const resolvedCacheKey = cacheState.resolveKey(cacheKey);
         try {
           const dedupeMs = cacheOptions?.dedupeMs ?? 0;
           const inflight = inflightState.get(cacheKey);
@@ -1605,6 +1524,9 @@ function createAPIClientRuntime(options = {}, transport) {
           }
           let invalidatedDuringRequest = false;
           if (isCacheEnabled) {
+            readOwners = getCacheReadOwners(cacheState);
+            readOwner = {};
+            readOwners.set(resolvedCacheKey, readOwner);
             unsubscribeInvalidation = cacheState.subscribe(cacheKey, (event) => {
               if (event === "invalidate") invalidatedDuringRequest = true;
             });
@@ -1712,15 +1634,27 @@ function createAPIClientRuntime(options = {}, transport) {
           inflightState.set(cacheKey, inflightEntry);
           try {
             const result2 = await promise;
-            if (inflightState.get(cacheKey) === inflightEntry && !invalidatedDuringRequest && !result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
+            if (inflightState.get(cacheKey) === inflightEntry && readOwners?.get(resolvedCacheKey) === readOwner && !invalidatedDuringRequest && !result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
               const updatedAt = Date.now();
-              cacheState.set(cacheKey, {
+              const cached = {
                 data: result2.data,
                 updatedAt,
                 staleAt: updatedAt + staleTime,
                 gcAt: getGcAt(updatedAt, cacheOptions?.gcTime),
-                invalidatedAt: void 0
-              });
+                invalidatedAt: void 0,
+                persist: cacheOptions?.persist === true ? true : void 0,
+                [API_CACHE_REFETCH]: createCacheRefetch(
+                  request,
+                  path,
+                  method,
+                  input,
+                  cacheKey,
+                  cacheOptions,
+                  clientOptions,
+                  options.onError
+                )
+              };
+              cacheState.set(cacheKey, cached);
             }
             if (result2.error) {
               emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
@@ -1748,6 +1682,9 @@ function createAPIClientRuntime(options = {}, transport) {
             }
           }
         } finally {
+          if (readOwner && readOwners?.get(resolvedCacheKey) === readOwner) {
+            readOwners.delete(resolvedCacheKey);
+          }
           unsubscribeInvalidation?.();
           release();
         }
@@ -1758,6 +1695,7 @@ function createAPIClientRuntime(options = {}, transport) {
           targets: clientOptions.invalidate.targets,
           refetch: clientOptions.invalidate.refetch ?? false
         };
+        const refetches = /* @__PURE__ */ new Set();
         for (const target of invalidateOptions.targets) {
           const targetKey = resolveTargetKey(
             routeMeta,
@@ -1769,20 +1707,22 @@ function createAPIClientRuntime(options = {}, transport) {
           );
           if (!targetKey) continue;
           const existing = cacheState.get(targetKey);
+          const invalidatedAt = Date.now();
+          cacheState.invalidate(targetKey, invalidatedAt);
           if (existing) {
-            const invalidatedAt = Date.now();
             const stack = optimisticState.get(targetKey);
-            cacheState.invalidate(targetKey, invalidatedAt);
             if (stack?.renderedEntry === existing) {
               stack.invalidatedAt = invalidatedAt;
               stack.renderedEntry = cacheState.get(targetKey);
             }
           }
           emitStatus("invalidated", { key: targetKey });
-          if (invalidateOptions.refetch && existing && targetKey === cacheKey) {
-            void executeNetwork({ isBackground: true, callCallbacks: false });
+          const refetch = existing?.[API_CACHE_REFETCH];
+          if (invalidateOptions.refetch && refetch) {
+            refetches.add(refetch);
           }
         }
+        for (const refetch of refetches) refetch();
       }, "invalidateTargets");
       const optimisticSnapshots = requestContextError ? [] : applyOptimisticUpdates();
       if (isCacheEnabled && !requestContextError && !cancellation.signal?.aborted) {
@@ -2016,7 +1956,31 @@ function createServerAPIClient(endpoints, options = {}) {
   return endpoints;
 }
 __name(createServerAPIClient, "createServerAPIClient");
+var API_CACHE_REFETCH = /* @__PURE__ */ Symbol.for("farm.api.cache-refetch");
+function createCacheRefetch(request, path, method, input, key, cache, options, onError) {
+  const readOptions = {
+    cache: { ...cache, key, policy: "network-only", dedupeMs: 0 },
+    retry: options?.retry,
+    timeoutMs: options?.timeoutMs
+  };
+  return () => {
+    void request(path, method, input, readOptions).catch((error) => {
+      notifyClientObserver(onError, [normalizeError(error)]);
+    });
+  };
+}
+__name(createCacheRefetch, "createCacheRefetch");
 var optimisticStates = /* @__PURE__ */ new WeakMap();
+var cacheReadOwners = /* @__PURE__ */ new WeakMap();
+function getCacheReadOwners(cache) {
+  let owners = cacheReadOwners.get(cache);
+  if (!owners) {
+    owners = /* @__PURE__ */ new Map();
+    cacheReadOwners.set(cache, owners);
+  }
+  return owners;
+}
+__name(getCacheReadOwners, "getCacheReadOwners");
 function getOptimisticState(cache) {
   let state = optimisticStates.get(cache);
   if (!state) {
@@ -2026,6 +1990,151 @@ function getOptimisticState(cache) {
   return state;
 }
 __name(getOptimisticState, "getOptimisticState");
+function applyOptimisticLayer(entry, layer) {
+  let data = entry?.data;
+  for (const updater of layer.updaters) data = updater(data);
+  return {
+    data,
+    updatedAt: layer.updatedAt,
+    staleAt: entry?.staleAt ?? layer.staleAt,
+    gcAt: entry?.gcAt ?? layer.gcAt,
+    invalidatedAt: entry?.invalidatedAt,
+    [API_CACHE_REFETCH]: entry?.[API_CACHE_REFETCH]
+  };
+}
+__name(applyOptimisticLayer, "applyOptimisticLayer");
+function storeOptimisticEntry(cacheState, key, stack, entry) {
+  if (!entry) {
+    cacheState.delete(key);
+    stack.renderedEntry = void 0;
+    return;
+  }
+  cacheState.set(key, entry);
+  if (stack.invalidatedAt !== void 0) {
+    cacheState.invalidate(key, stack.invalidatedAt);
+  }
+  stack.renderedEntry = cacheState.get(key);
+}
+__name(storeOptimisticEntry, "storeOptimisticEntry");
+function reconcileOptimisticInvalidation(cacheState, key, stack) {
+  const current = cacheState.get(key);
+  const rendered = stack.renderedEntry;
+  if (current === rendered) return true;
+  if (!current || !rendered || current.data !== rendered.data || current.updatedAt !== rendered.updatedAt || current.gcAt !== rendered.gcAt || current.status !== rendered.status || current.error !== rendered.error || current.fetching !== rendered.fetching || current.staleAt !== 0 || current.invalidatedAt === void 0) {
+    return false;
+  }
+  stack.invalidatedAt = current.invalidatedAt;
+  stack.renderedEntry = current;
+  return true;
+}
+__name(reconcileOptimisticInvalidation, "reconcileOptimisticInvalidation");
+function renderOptimisticStack(cacheState, key, stack) {
+  let entry = stack.entry ? { ...stack.entry } : void 0;
+  for (const layer of stack.layers) entry = applyOptimisticLayer(entry, layer);
+  storeOptimisticEntry(cacheState, key, stack, entry);
+}
+__name(renderOptimisticStack, "renderOptimisticStack");
+function settleOptimisticUpdates(cacheState, optimisticState, snapshots, outcome) {
+  const settledKeys = [];
+  for (const snapshot of snapshots) {
+    const stack = optimisticState.get(snapshot.key);
+    if (stack !== snapshot.stack) continue;
+    if (!reconcileOptimisticInvalidation(cacheState, snapshot.key, stack)) {
+      optimisticState.delete(snapshot.key);
+      continue;
+    }
+    if (outcome === "rollback") {
+      stack.layers = stack.layers.filter((layer) => layer !== snapshot.layer);
+    } else {
+      snapshot.layer.committed = true;
+      if (outcome === "invalidate") stack.invalidatedAt = Date.now();
+    }
+    while (stack.layers[0]?.committed) {
+      stack.entry = applyOptimisticLayer(stack.entry, stack.layers.shift());
+    }
+    renderOptimisticStack(cacheState, snapshot.key, stack);
+    if (stack.layers.length === 0) optimisticState.delete(snapshot.key);
+    settledKeys.push(snapshot.key);
+  }
+  return settledKeys;
+}
+__name(settleOptimisticUpdates, "settleOptimisticUpdates");
+function applyServerFnOptimisticUpdates(updates, now = Date.now()) {
+  const cacheState = getFarmClientDataCache();
+  const optimisticState = getOptimisticState(cacheState);
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    if (update.length !== 2) continue;
+    const [target, updater] = update;
+    if (typeof updater !== "function") continue;
+    const targetKey = typeof target === "string" || Array.isArray(target) ? normalizeFarmClientCacheKey(target) : null;
+    if (!targetKey) continue;
+    const targetEntry = getValidCacheEntry(cacheState, targetKey, now);
+    const currentEntry = cacheState.get(targetKey);
+    let stack = optimisticState.get(targetKey);
+    if (stack && !reconcileOptimisticInvalidation(cacheState, targetKey, stack)) {
+      stack = void 0;
+    }
+    if (!stack) {
+      stack = {
+        entry: targetEntry ? { ...targetEntry } : void 0,
+        layers: [],
+        renderedEntry: currentEntry
+      };
+      optimisticState.set(targetKey, stack);
+    }
+    let snapshot = snapshots.get(targetKey);
+    if (!snapshot) {
+      const previousEntry = stack.layers.length === 0 ? stack.entry : stack.renderedEntry;
+      const layer = {
+        updaters: [],
+        updatedAt: now,
+        // A server function has no cache policy of its own; preserve the
+        // target read's freshness metadata when it exists.
+        staleAt: targetEntry?.staleAt ?? now,
+        gcAt: targetEntry?.gcAt
+      };
+      stack.layers.push(layer);
+      snapshot = { key: targetKey, stack, layer };
+      snapshots.set(targetKey, snapshot);
+      snapshot.layer.updaters.push(updater);
+      const nextEntry2 = applyOptimisticLayer(previousEntry, {
+        ...snapshot.layer,
+        updaters: [updater]
+      });
+      storeOptimisticEntry(cacheState, targetKey, stack, nextEntry2);
+      continue;
+    }
+    snapshot.layer.updaters.push(updater);
+    const nextEntry = applyOptimisticLayer(stack.renderedEntry, {
+      ...snapshot.layer,
+      updaters: [updater]
+    });
+    storeOptimisticEntry(cacheState, targetKey, stack, nextEntry);
+  }
+  return Array.from(snapshots.values());
+}
+__name(applyServerFnOptimisticUpdates, "applyServerFnOptimisticUpdates");
+function settleServerFnOptimisticUpdates(snapshots, outcome) {
+  if (snapshots.length === 0) return;
+  const cacheState = getFarmClientDataCache();
+  settleOptimisticUpdates(cacheState, getOptimisticState(cacheState), snapshots, outcome);
+}
+__name(settleServerFnOptimisticUpdates, "settleServerFnOptimisticUpdates");
+function resolveServerFnInvalidateTargets(invalidate) {
+  const targets = Array.isArray(invalidate) ? invalidate : invalidate.targets;
+  const keys = [];
+  for (const target of targets) {
+    if (typeof target === "string" || Array.isArray(target)) {
+      if (Array.isArray(target) && typeof target[0] === "function") continue;
+      keys.push(normalizeFarmClientCacheKey(target));
+    } else if (target && typeof target === "object" && "key" in target) {
+      keys.push(normalizeFarmClientCacheKey(target.key));
+    }
+  }
+  return keys;
+}
+__name(resolveServerFnInvalidateTargets, "resolveServerFnInvalidateTargets");
 function buildCacheKey(method, path, input, baseURL, defaultHeaders) {
   const keyInput = input && typeof input === "object" ? {
     query: input.query,
@@ -2220,6 +2329,9 @@ export {
   createAPIClient,
   isAPIRouteRef,
   getAPIRouteRefMetadata,
-  createServerAPIClient
+  createServerAPIClient,
+  applyServerFnOptimisticUpdates,
+  settleServerFnOptimisticUpdates,
+  resolveServerFnInvalidateTargets
 };
-//# sourceMappingURL=chunk-75CGAL6E.mjs.map
+//# sourceMappingURL=chunk-IZBX2TEU.mjs.map