@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-7H45IJWO.mjs

@@ -0,0 +1,2250 @@
+import {
+  notifyClientObserver,
+  resolveClientRetryCount,
+  resolveClientRetryDelay
+} from "./chunk-IAPTECEB.mjs";
+import {
+  FarmClientDataCache,
+  getFarmClientDataCache,
+  normalizeFarmClientCacheKey
+} from "./chunk-C64XOPBZ.mjs";
+import {
+  createClientCancellation
+} from "./chunk-H227LYHT.mjs";
+import {
+  resolveAPIRequestRuntime
+} from "./chunk-5Y4GYKKH.mjs";
+import {
+  isFarmAPIStream,
+  isJSONStreamResponse,
+  readJSONStream
+} from "./chunk-YT3SLLZK.mjs";
+import {
+  matchAPIRoute,
+  parseDynamicSegment
+} from "./chunk-GUZC226X.mjs";
+import {
+  getFarmAPIBaseURL,
+  resolveFarmAPIRequestURL
+} from "./chunk-W6QLRQ3V.mjs";
+import {
+  FARM_CACHE_INVALIDATION_HEADER,
+  applyFarmCacheInvalidations,
+  decodeFarmCacheInvalidations
+} from "./chunk-AZQXXXDX.mjs";
+import {
+  _resolveCurrentRequest
+} from "./chunk-VIXTAVEA.mjs";
+
+// src/client-headers.ts
+function resolveClientHeaders(source) {
+  const value = typeof source === "function" ? source() : source;
+  if (value && typeof value.then === "function") {
+    return Promise.resolve(value).then((headers) => new Headers(headers));
+  }
+  return new Headers(value);
+}
+
+// src/integration-client.ts
+var IntegrationClientError = class extends Error {
+  constructor(message, response, data) {
+    super(message);
+    this.name = "IntegrationClientError";
+    this.status = response.status;
+    this.response = response;
+    this.data = data;
+  }
+};
+var INTEGRATION_RUNTIME_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRuntimeRegistry");
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+var INTEGRATION_REQUEST_DISPATCHER_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRequestDispatcher");
+function isOperation(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
+}
+function tryResolveSourceAPI(source) {
+  if ("kind" in source && source.kind === "farm-integration") {
+    if (!source.api) {
+      return null;
+    }
+    return source.api;
+  }
+  return source;
+}
+function getIntegrationRuntimeRegistry() {
+  const globalState = globalThis;
+  return globalState[INTEGRATION_RUNTIME_REGISTRY_KEY] || /* @__PURE__ */ new Map();
+}
+function getRegisteredIntegrationRuntimeLocal(key) {
+  return getIntegrationRuntimeRegistry().get(key);
+}
+function getRegisteredIntegrationsLocal() {
+  return Object.fromEntries(
+    Array.from(getIntegrationRuntimeRegistry().entries()).map(([key, runtime]) => [
+      key,
+      runtime.integration
+    ])
+  );
+}
+function resolveCurrentRequestLocal() {
+  const globalState = globalThis;
+  return globalState[CURRENT_REQUEST_RESOLVER_KEY]?.();
+}
+function resolveIntegrationRequestDispatcherLocal() {
+  const globalState = globalThis;
+  return globalState[INTEGRATION_REQUEST_DISPATCHER_KEY];
+}
+var INTEGRATION_DATA_HEADER = "x-farm-integration-data";
+var INTEGRATION_DATA_HEADER_MAX_LENGTH = 16 * 1024;
+var BLOCKED_INTEGRATION_DATA_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isIntegrationClientData(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainIntegrationDataObject(value) {
+  if (!isIntegrationClientData(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function sanitizeIntegrationClientDataValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeIntegrationClientDataValue(item));
+  }
+  if (!isPlainIntegrationDataObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (BLOCKED_INTEGRATION_DATA_KEYS.has(key)) {
+      continue;
+    }
+    sanitized[key] = sanitizeIntegrationClientDataValue(item);
+  }
+  return sanitized;
+}
+function normalizeIntegrationClientData(value) {
+  if (!isIntegrationClientData(value)) {
+    return void 0;
+  }
+  const sanitized = sanitizeIntegrationClientDataValue(value);
+  return isIntegrationClientData(sanitized) && Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+function getIntegrationDataHeaderByteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function mergeIntegrationClientData(...values) {
+  let merged;
+  for (const value of values) {
+    const data = normalizeIntegrationClientData(value);
+    if (!data) {
+      continue;
+    }
+    merged = {
+      ...merged,
+      ...data
+    };
+  }
+  return merged && Object.keys(merged).length > 0 ? merged : void 0;
+}
+function serializeIntegrationClientData(data) {
+  const serialized = JSON.stringify(data);
+  if (getIntegrationDataHeaderByteLength(serialized) > INTEGRATION_DATA_HEADER_MAX_LENGTH) {
+    throw new Error(
+      `Integration client data must be smaller than ${INTEGRATION_DATA_HEADER_MAX_LENGTH} bytes when sent over HTTP headers.`
+    );
+  }
+  return serialized;
+}
+function appendIntegrationClientDataHeader(headers, data) {
+  if (!data) {
+    return;
+  }
+  headers.set(INTEGRATION_DATA_HEADER, serializeIntegrationClientData(data));
+}
+function resolveAutomaticClientNamespaces() {
+  const globalState = globalThis;
+  const manifest = globalState.window?.__FARM_INTEGRATION_API_MANIFEST__ || globalState.__FARM_INTEGRATION_API_MANIFEST__ || {};
+  return Object.entries(manifest).map(([key, api]) => [key, api, api]);
+}
+function resolveAutomaticServerNamespaces() {
+  return Object.entries(getRegisteredIntegrationsLocal()).flatMap(([key, source]) => {
+    const api = tryResolveSourceAPI(source);
+    return api ? [[key, api, source]] : [];
+  });
+}
+function appendQuery(url, query) {
+  if (!query) {
+    return;
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item != null) {
+          url.searchParams.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+}
+function appendHeaders(target, source) {
+  if (!source) {
+    return;
+  }
+  const headers = new Headers(source);
+  headers.forEach((value, key) => {
+    target.set(key, value);
+  });
+}
+var DEFAULT_FORWARDED_HEADERS = [
+  "authorization",
+  "cookie",
+  "x-client-ip",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-real-ip"
+];
+function resolveRequestLike(request) {
+  if (!request) {
+    return void 0;
+  }
+  if (request instanceof Request) {
+    return {
+      url: request.url,
+      headers: request.headers
+    };
+  }
+  return {
+    url: request.url,
+    headers: request.headers ? new Headers(request.headers) : void 0
+  };
+}
+function resolveServerBaseURL(explicitBaseURL, request) {
+  if (explicitBaseURL) {
+    return explicitBaseURL;
+  }
+  if (request?.url) {
+    try {
+      return new URL(request.url).origin;
+    } catch {
+    }
+  }
+  const headers = request?.headers;
+  const host = headers?.get("x-forwarded-host") || headers?.get("host");
+  if (host) {
+    const proto = headers?.get("x-forwarded-proto") || "http";
+    return `${proto}://${host}`;
+  }
+  return "http://localhost:3000";
+}
+function resolveForwardHeaders(request, forwardHeaders) {
+  if (!request?.headers || forwardHeaders === false) {
+    return new Headers();
+  }
+  const allowed = Array.isArray(forwardHeaders) && forwardHeaders.length > 0 ? new Set(forwardHeaders.map((item) => item.toLowerCase())) : new Set(DEFAULT_FORWARDED_HEADERS);
+  const headers = new Headers();
+  request.headers.forEach((value, key) => {
+    if (allowed.has(key.toLowerCase())) {
+      headers.set(key, value);
+    }
+  });
+  return headers;
+}
+function createBody(format, body, headers) {
+  if (body == null || format === "none") {
+    return void 0;
+  }
+  if (format === "form") {
+    if (body instanceof FormData || body instanceof URLSearchParams) {
+      return body;
+    }
+    const form = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value == null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item != null) {
+            form.append(key, String(item));
+          }
+        }
+        continue;
+      }
+      form.set(key, String(value));
+    }
+    headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+    return form;
+  }
+  headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+function createOperationBody(operation, body, headers) {
+  const requestBody = createBody(operation.bodyFormat, body, headers);
+  if (operation.method === "QUERY" && requestBody === void 0 && !headers.has("content-type")) {
+    headers.set(
+      "content-type",
+      operation.bodyFormat === "form" ? "application/x-www-form-urlencoded;charset=UTF-8" : "application/json"
+    );
+  }
+  return requestBody;
+}
+async function parseResponseData(response) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (isJSONMediaType(contentType)) {
+    return await response.json();
+  }
+  return await response.text();
+}
+function isJSONMediaType(contentType) {
+  const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+  return mediaType === "application/json" || mediaType.endsWith("+json");
+}
+async function safeParseResponseData(response) {
+  try {
+    return await parseResponseData(response);
+  } catch {
+    return void 0;
+  }
+}
+function createResponseError(response, errorData) {
+  const message = typeof errorData === "string" ? errorData : typeof errorData === "object" && errorData ? String(
+    errorData.error || errorData.message || response.statusText
+  ) : response.statusText || "Integration request failed.";
+  return new IntegrationClientError(message, response, errorData);
+}
+function normalizeExecutionError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return new Error(error);
+  }
+  return new Error("Integration request failed.");
+}
+async function finalizeOperationResponse(operation, response) {
+  if (!response.ok) {
+    const errorData = await safeParseResponseData(response);
+    return {
+      data: null,
+      error: createResponseError(response, errorData)
+    };
+  }
+  if (operation.responseFormat === "response") {
+    return {
+      data: response,
+      error: null
+    };
+  }
+  return {
+    data: await parseResponseData(response),
+    error: null
+  };
+}
+var integrationRequestCounter = 0;
+var noIntegrationObservers = {
+  response(_response) {
+  },
+  finish(result) {
+    return result;
+  }
+};
+function createIntegrationObservers(operation, options, requestOptions) {
+  if (!options.onRequest && !options.onResponse && !options.onError && !requestOptions?.onRequest && !requestOptions?.onResponse && !requestOptions?.onError) {
+    return noIntegrationObservers;
+  }
+  const requestEvent = {
+    requestId: `integration-${Date.now()}-${++integrationRequestCounter}`,
+    method: operation.method,
+    path: operation.path ?? "",
+    attempt: 0,
+    timestamp: Date.now()
+  };
+  let response;
+  notifyClientObserver(options.onRequest, [requestEvent]);
+  notifyClientObserver(requestOptions?.onRequest, [requestEvent]);
+  return {
+    response(value) {
+      response = value;
+    },
+    finish(result) {
+      const data = result.error ? void 0 : result.data;
+      const event = {
+        ...requestEvent,
+        timestamp: Date.now(),
+        response,
+        data,
+        error: result.error ?? void 0,
+        ok: !result.error,
+        status: response?.status
+      };
+      notifyClientObserver(options.onResponse, [data, result.error, event]);
+      notifyClientObserver(requestOptions?.onResponse, [data, result.error, event]);
+      if (result.error) {
+        notifyClientObserver(options.onError, [result.error]);
+        notifyClientObserver(requestOptions?.onError, [result.error]);
+      }
+      return result;
+    }
+  };
+}
+async function executeClientOperation(operation, input, options, requestOptions) {
+  const cancellation = createClientCancellation(
+    requestOptions?.signal,
+    requestOptions?.timeoutMs ?? options.timeoutMs
+  );
+  const observers = createIntegrationObservers(operation, options, requestOptions);
+  try {
+    const result = await cancellation.run(async () => {
+      if (!operation.path) {
+        return {
+          data: null,
+          error: new Error(
+            "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
+          )
+        };
+      }
+      const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+      const url = resolveFarmAPIRequestURL(operation.path, baseURL);
+      appendQuery(url, input.query);
+      const resolved = resolveClientHeaders(options.headers);
+      const headers = resolved instanceof Headers ? resolved : await resolved;
+      cancellation.check();
+      appendHeaders(headers, operation.headers);
+      appendHeaders(headers, requestOptions?.headers);
+      headers.set("x-farm-integration-client", "1");
+      if (operation.responseFormat !== "response") {
+        headers.set("accept", "application/json");
+      }
+      appendIntegrationClientDataHeader(
+        headers,
+        mergeIntegrationClientData(options.data, requestOptions?.data)
+      );
+      const body = createOperationBody(operation, input.body, headers);
+      const response = await (options.fetch ?? fetch)(url.toString(), {
+        method: operation.method,
+        headers,
+        body,
+        credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
+        signal: cancellation.signal
+      });
+      cancellation.check();
+      observers.response(response);
+      if (!response.ok) {
+        const errorData = await safeParseResponseData(response);
+        return {
+          data: null,
+          error: createResponseError(response, errorData)
+        };
+      }
+      if (operation.responseFormat === "response") {
+        return {
+          data: response,
+          error: null
+        };
+      }
+      return {
+        data: await parseResponseData(response),
+        error: null
+      };
+    });
+    return observers.finish(result);
+  } catch (error) {
+    return observers.finish({
+      data: null,
+      error: normalizeExecutionError(error)
+    });
+  } finally {
+    cancellation.dispose();
+  }
+}
+async function executeServerOperation(operation, input, options, requestOptions, integrationKey, source) {
+  const currentRequest = requestOptions?.request instanceof Request ? requestOptions.request : options.request instanceof Request ? options.request : resolveCurrentRequestLocal();
+  const cancellation = createClientCancellation(
+    requestOptions?.signal,
+    requestOptions?.timeoutMs ?? options.timeoutMs,
+    currentRequest?.signal
+  );
+  const observers = createIntegrationObservers(operation, options, requestOptions);
+  try {
+    const result = await cancellation.run(async () => {
+      if (!operation.path) {
+        return {
+          data: null,
+          error: new Error(
+            "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
+          )
+        };
+      }
+      const serverRequestOptions = requestOptions && ("request" in requestOptions || "baseURL" in requestOptions || "forwardHeaders" in requestOptions) ? requestOptions : void 0;
+      const request = resolveRequestLike(
+        serverRequestOptions?.request ?? options.request ?? currentRequest
+      );
+      const baseURL = resolveServerBaseURL(
+        serverRequestOptions?.baseURL ?? options.baseURL,
+        request
+      );
+      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(
+        headers,
+        resolveForwardHeaders(
+          request,
+          serverRequestOptions?.forwardHeaders ?? options.forwardHeaders
+        )
+      );
+      const resolved = resolveClientHeaders(options.headers);
+      appendHeaders(headers, resolved instanceof Headers ? resolved : await resolved);
+      cancellation.check();
+      appendHeaders(headers, operation.headers);
+      appendHeaders(headers, requestOptions?.headers);
+      headers.set("x-farm-integration-client", "1");
+      if (operation.responseFormat !== "response") {
+        headers.set("accept", "application/json");
+      }
+      const data = mergeIntegrationClientData(options.data, requestOptions?.data);
+      if (integrationKey) {
+        const runtime = "kind" in (source || {}) && source.kind === "farm-integration" ? getRegisteredIntegrationRuntimeLocal(integrationKey) || {
+          integration: source,
+          config: {},
+          isDev: process.env.NODE_ENV !== "production",
+          isProd: process.env.NODE_ENV === "production"
+        } : getRegisteredIntegrationRuntimeLocal(integrationKey);
+        if (runtime) {
+          const dispatchIntegrationRequest = resolveIntegrationRequestDispatcherLocal();
+          const body2 = createOperationBody(operation, input.body, headers);
+          const directResponse = dispatchIntegrationRequest ? await dispatchIntegrationRequest(
+            runtime,
+            new Request(url.toString(), {
+              method: operation.method,
+              headers,
+              body: body2,
+              signal: cancellation.signal
+            }),
+            {
+              currentRequest,
+              data,
+              internal: true
+            }
+          ) : null;
+          cancellation.check();
+          if (directResponse) {
+            observers.response(directResponse);
+            return await finalizeOperationResponse(operation, directResponse);
+          }
+        }
+      }
+      appendIntegrationClientDataHeader(headers, data);
+      const body = createOperationBody(operation, input.body, headers);
+      const httpURL = resolveFarmAPIRequestURL(operation.path, baseURL, origin);
+      appendQuery(httpURL, input.query);
+      const response = await (options.fetch ?? fetch)(httpURL.toString(), {
+        method: operation.method,
+        headers,
+        body,
+        credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
+        signal: cancellation.signal
+      });
+      cancellation.check();
+      observers.response(response);
+      return await finalizeOperationResponse(operation, response);
+    });
+    return observers.finish(result);
+  } catch (error) {
+    return observers.finish({
+      data: null,
+      error: normalizeExecutionError(error)
+    });
+  } finally {
+    cancellation.dispose();
+  }
+}
+function createIntegrationClient(sources, options = {}) {
+  const rawSources = "integrations" in sources ? sources.integrations : sources;
+  const isServer = options.isServer === true;
+  const namespaces = Object.entries(rawSources).map(([key, source]) => {
+    const api = tryResolveSourceAPI(source);
+    if (!api) {
+      return null;
+    }
+    return [key, api, source];
+  }).filter(
+    (value) => value !== null
+  );
+  const cache = /* @__PURE__ */ new Map();
+  const integrationNamespaces = new Proxy(
+    {},
+    {
+      get(target, property) {
+        if (typeof property !== "string") {
+          return void 0;
+        }
+        if (Reflect.has(target, property)) {
+          return Reflect.get(target, property);
+        }
+        if (cache.has(property)) {
+          return cache.get(property);
+        }
+        const match = namespaces.find(([key]) => key === property);
+        if (!match) {
+          return void 0;
+        }
+        const namespace = isServer ? createServerNamespaceProxy(
+          match[0],
+          match[2],
+          match[1],
+          options
+        ) : createNamespaceProxy(match[1], options);
+        cache.set(property, namespace);
+        return namespace;
+      }
+    }
+  );
+  if ("integrations" in sources) {
+    Object.defineProperty(integrationNamespaces, "integrations", {
+      value: integrationNamespaces,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    return integrationNamespaces;
+  }
+  return integrationNamespaces;
+}
+function createAutomaticIntegrationAliases(isServer, options = {}) {
+  const cache = isServer ? /* @__PURE__ */ new Map() : null;
+  const integrationNamespaces = new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property !== "string") {
+          return void 0;
+        }
+        if (property === "integrations") {
+          return integrationNamespaces;
+        }
+        if (cache?.has(property)) {
+          return cache.get(property);
+        }
+        const namespaces = isServer ? resolveAutomaticServerNamespaces() : resolveAutomaticClientNamespaces();
+        const match = namespaces.find(([key]) => key === property);
+        if (!match) {
+          return void 0;
+        }
+        const namespace = isServer ? createServerNamespaceProxy(
+          match[0],
+          match[2],
+          match[1],
+          options
+        ) : createNamespaceProxy(match[1], options);
+        cache?.set(property, namespace);
+        return namespace;
+      }
+    }
+  );
+  Object.defineProperty(integrationNamespaces, "integrations", {
+    value: integrationNamespaces,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return integrationNamespaces;
+}
+function integrationsClient(options = {}) {
+  return createAutomaticIntegrationAliases(
+    false,
+    options
+  );
+}
+function integrationsServer(options = {}) {
+  return createAutomaticIntegrationAliases(true, {
+    ...options,
+    isServer: true
+  });
+}
+function createIntegrationServerClient(sources, options = {}) {
+  return createIntegrationClient(sources, {
+    ...options,
+    isServer: true
+  });
+}
+function createIntegrationApi(sources, options = {}) {
+  const client = createIntegrationClient(sources, options);
+  return {
+    ...client,
+    server(serverOptions = {}) {
+      return createIntegrationServerClient(sources, {
+        ...options,
+        ...serverOptions
+      });
+    }
+  };
+}
+function isIntegrationClientOptionsInput(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && ("baseURL" in value || "headers" in value || "credentials" in value || "timeoutMs" in value || "fetch" in value || "onRequest" in value || "onResponse" in value || "onError" in value || "data" in value || "isServer" in value);
+}
+function resolveIntegrationServerOptions(clientOptions = {}, serverOptions = {}) {
+  const data = mergeIntegrationClientData(clientOptions.data, serverOptions.data);
+  return {
+    baseURL: clientOptions.baseURL,
+    headers: clientOptions.headers,
+    credentials: clientOptions.credentials,
+    timeoutMs: clientOptions.timeoutMs,
+    fetch: clientOptions.fetch,
+    onRequest: clientOptions.onRequest,
+    onResponse: clientOptions.onResponse,
+    onError: clientOptions.onError,
+    ...serverOptions,
+    ...data ? { data } : {}
+  };
+}
+function createIntegrationClients(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0 || isIntegrationClientOptionsInput(sources)) {
+    const automaticClientOptions = isIntegrationClientOptionsInput(sources) ? sources : {};
+    const automaticServerOptions = arguments.length > 1 ? clientOptions : void 0;
+    return {
+      api: integrationsServer(
+        resolveIntegrationServerOptions(
+          automaticClientOptions,
+          automaticServerOptions
+        )
+      ),
+      apiClient: integrationsClient(automaticClientOptions)
+    };
+  }
+  const explicitSources = sources && "integrations" in sources ? sources.integrations : sources;
+  return {
+    api: createIntegrationServerClient(
+      {
+        integrations: explicitSources
+      },
+      resolveIntegrationServerOptions(clientOptions, serverOptions)
+    ),
+    apiClient: createIntegrationClient(
+      {
+        integrations: explicitSources
+      },
+      clientOptions
+    )
+  };
+}
+function createIntegrations(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0) {
+    return createIntegrationClients();
+  }
+  return createIntegrationClients(
+    sources,
+    clientOptions,
+    serverOptions
+  );
+}
+function createClientSafeIntegrationAPI(api) {
+  if (!api) {
+    return void 0;
+  }
+  const entries = Object.entries(api).map(([key, value]) => {
+    if (isOperation(value)) {
+      return [
+        key,
+        {
+          kind: value.kind,
+          path: value.path,
+          method: value.method,
+          bodyFormat: value.bodyFormat,
+          responseFormat: value.responseFormat,
+          credentials: value.credentials,
+          isServer: value.isServer,
+          __pathless: value.__pathless
+        }
+      ];
+    }
+    if (value && typeof value === "object") {
+      return [key, createClientSafeIntegrationAPI(value)];
+    }
+    return [key, value];
+  });
+  return Object.fromEntries(entries);
+}
+function getIntegrationAPIManifest() {
+  const manifestEntries = Object.entries(getRegisteredIntegrationsLocal()).map(([key, integration]) => {
+    const api = createClientSafeIntegrationAPI(integration.api);
+    return api ? [key, api] : null;
+  }).filter((value) => value !== null);
+  return Object.fromEntries(manifestEntries);
+}
+function integrationClients(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0) {
+    return createIntegrationClients();
+  }
+  return createIntegrationClients(
+    sources,
+    clientOptions,
+    serverOptions
+  );
+}
+function resolveSingleNamespaceOperation(api) {
+  const entries = Object.entries(api);
+  if (entries.length !== 1) {
+    return null;
+  }
+  const [, value] = entries[0];
+  return isOperation(value) ? value : null;
+}
+function createClientOperationCaller(operation, property, options) {
+  if (operation.isServer === true) {
+    return async () => {
+      throw new Error(
+        `Integration method "${property}" is registered with isServer: true and is only available from a server integration client.`
+      );
+    };
+  }
+  return async (input = {}, requestOptions) => {
+    if (typeof window === "undefined") {
+      throw new Error(
+        "Client integration API cannot be called on the server. Pass { isServer: true } to createIntegrationClient(...) during server rendering, or provide { isServer: true, request } outside it."
+      );
+    }
+    return executeClientOperation(operation, input, options, requestOptions);
+  };
+}
+function createServerOperationCaller(operation, options, integrationKey, source) {
+  return async (input = {}, requestOptions) => {
+    if (typeof window !== "undefined") {
+      throw new Error(
+        "Server integration API cannot be called in the browser. Remove { isServer: true } and create a client integration API instead."
+      );
+    }
+    return executeServerOperation(
+      operation,
+      input,
+      options,
+      requestOptions,
+      integrationKey,
+      source
+    );
+  };
+}
+function createNamespaceProxy(api, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const directOperation = resolveSingleNamespaceOperation(api);
+  const target = directOperation ? createClientOperationCaller(directOperation, directOperation.method.toLowerCase(), options) : {};
+  return new Proxy(target, {
+    get(targetObject, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (cache.has(property)) {
+        return cache.get(property);
+      }
+      const value = api[property];
+      if (!value) {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (isOperation(value)) {
+        const caller = createClientOperationCaller(value, property, options);
+        cache.set(property, caller);
+        return caller;
+      }
+      const namespace = createNamespaceProxy(value, options);
+      cache.set(property, namespace);
+      return namespace;
+    }
+  });
+}
+function createServerNamespaceProxy(integrationKey, source, api, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const directOperation = resolveSingleNamespaceOperation(api);
+  const target = directOperation ? createServerOperationCaller(directOperation, options, integrationKey, source) : {};
+  return new Proxy(target, {
+    get(targetObject, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (cache.has(property)) {
+        return cache.get(property);
+      }
+      const value = api[property];
+      if (!value) {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (isOperation(value)) {
+        const caller = createServerOperationCaller(value, options, integrationKey, source);
+        cache.set(property, caller);
+        return caller;
+      }
+      const namespace = createServerNamespaceProxy(
+        integrationKey,
+        source,
+        value,
+        options
+      );
+      cache.set(property, namespace);
+      return namespace;
+    }
+  });
+}
+
+// src/api/client-routes.ts
+var ClientRouteManifest = class {
+  constructor(routes) {
+    this.candidates = /* @__PURE__ */ new Map();
+    this.nextSegments = /* @__PURE__ */ new Map();
+    this.routes = new Map(
+      routes.map((route) => [
+        route.path.replace(/\/$/, ""),
+        {
+          path: route.path.replace(/\/$/, ""),
+          methods: [...route.methods]
+        }
+      ])
+    );
+    const addCandidate = (path, route) => {
+      let candidates = this.candidates.get(path);
+      if (!candidates) this.candidates.set(path, candidates = []);
+      candidates.push(route);
+    };
+    for (const route of this.routes.values()) {
+      addCandidate(route.path, route);
+      const segments = route.path.split("/");
+      let parent = "";
+      for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (i > 0 && parseDynamicSegment(segment)) {
+          let next = this.nextSegments.get(parent);
+          if (!next) this.nextSegments.set(parent, next = /* @__PURE__ */ new Set());
+          next.add(segment);
+          if (i === segments.length - 1) addCandidate(parent, route);
+        }
+        parent = i === 0 ? segment : `${parent}/${segment}`;
+      }
+    }
+  }
+  bind(path, input) {
+    const params = readParams(input);
+    const normalized = path.replace(/\/$/, "");
+    const candidates = new Set(
+      [...this.nextSegments.get(normalized) ?? []].filter((segment2) => {
+        const dynamic2 = parseDynamicSegment(segment2);
+        return dynamic2 && Object.keys(params).every((key) => key === dynamic2.name) && (Object.prototype.hasOwnProperty.call(params, dynamic2.name) || dynamic2.optional);
+      })
+    );
+    if (candidates.size !== 1)
+      throw new TypeError(
+        `Cannot bind route params at ${path}: supply exactly the next dynamic segment's parameter.`
+      );
+    const segment = [...candidates][0];
+    const dynamic = parseDynamicSegment(segment);
+    encodeParameter(dynamic, params[dynamic.name]);
+    return {
+      segment,
+      params: Object.freeze(
+        Object.fromEntries(
+          Object.entries(params).map(([key, value]) => [
+            key,
+            Array.isArray(value) ? Object.freeze([...value]) : value
+          ])
+        )
+      )
+    };
+  }
+  resolve(path, method, bound, input) {
+    const normalized = path.replace(/\/$/, "");
+    const supplied = readParams(input?.params);
+    const candidates = (this.candidates.get(normalized) ?? []).filter((route2) => {
+      if (route2.path === normalized) return true;
+      if (!route2.path.startsWith(`${normalized}/`)) return false;
+      const tail = route2.path.slice(normalized.length + 1);
+      return !tail.includes("/") && Boolean(parseDynamicSegment(tail)) && input?.params !== void 0;
+    });
+    const selected = candidates.filter((route2) => {
+      const unbound = route2.path.split("/").map(parseDynamicSegment).filter((part) => part && !Object.prototype.hasOwnProperty.call(bound, part.name));
+      return Object.keys(supplied).every((key) => unbound.some((part) => part.name === key)) && unbound.every(
+        (part) => part.optional || Object.prototype.hasOwnProperty.call(supplied, part.name)
+      );
+    });
+    if (selected.length !== 1)
+      throw new TypeError(
+        `Cannot resolve ${method} ${normalized}: missing, unexpected, or ambiguous route params.`
+      );
+    const route = selected[0];
+    if (!route.methods.includes(method) && !(method === "HEAD" && route.methods.includes("GET"))) {
+      throw new TypeError(`${method} is not registered for ${route.path}.`);
+    }
+    const params = { ...bound, ...supplied };
+    const resolved = route.path.split("/").map((segment) => {
+      const dynamic = parseDynamicSegment(segment);
+      return dynamic ? encodeParameter(dynamic, params[dynamic.name]) : segment;
+    }).filter(Boolean).join("/");
+    const pathname = `/${resolved}`;
+    const winner = matchAPIRoute(this.routes, pathname);
+    if (winner?.route.path !== route.path) {
+      throw new TypeError(
+        `Route ${route.path} resolves to ${pathname}, which is shadowed by ${winner?.route.path ?? "another route"}.`
+      );
+    }
+    return pathname;
+  }
+};
+function readParams(input) {
+  if (input === void 0) return {};
+  if (!input || typeof input !== "object" || Array.isArray(input) || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) {
+    throw new TypeError("Route params must be a plain object.");
+  }
+  for (const key of Object.keys(input)) {
+    if (["__proto__", "constructor", "prototype"].includes(key))
+      throw new TypeError(`Unsafe route parameter ${key}.`);
+  }
+  return input;
+}
+function encodeParameter(parameter, value) {
+  if (parameter.optional && value === void 0) return "";
+  const parts = parameter.catchAll ? value : [value];
+  if (!Array.isArray(parts) || !parts.length && !parameter.optional) {
+    throw new TypeError(
+      `Route parameter ${parameter.name} must be ${parameter.catchAll ? "a non-empty array of strings" : "a string"}.`
+    );
+  }
+  return Array.from(parts, (part) => {
+    if (typeof part !== "string" || !part || part === "." || part === ".." || Array.from(part).some(
+      (character) => character.charCodeAt(0) <= 31 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159
+    )) {
+      throw new TypeError(`Invalid value for route parameter ${parameter.name}.`);
+    }
+    return encodeURIComponent(part);
+  }).join("/");
+}
+
+// src/api/client.ts
+var FARM_API_ROUTE_REF_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-ref");
+var FARM_API_ROUTE_META_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-meta");
+var APIClientError = class 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;
+  }
+};
+var FARM_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "QUERY"]);
+var FARM_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 425, 429]);
+function isFarmRetryableFailure(context) {
+  if (!FARM_IDEMPOTENT_METHODS.has(context.method)) return false;
+  if (context.status === void 0) return true;
+  return context.status >= 500 || FARM_RETRYABLE_STATUSES.has(context.status);
+}
+function createApiClients(options = {}) {
+  const localScopes = /* @__PURE__ */ new WeakMap();
+  const routeMeta = /* @__PURE__ */ new WeakMap();
+  const api = createNestedProxy(
+    [],
+    async (path, method, input, clientOptions) => {
+      if (typeof window !== "undefined") {
+        throw new Error(
+          "api is server-only. Use apiClient from createApiClients() in the browser."
+        );
+      }
+      const currentRequest = _resolveCurrentRequest();
+      const runtime = resolveAPIRequestRuntime();
+      if (!currentRequest || !runtime) {
+        throw new Error(
+          "api requires an active Farm server request. Call it from a server page, query, action, or API handler; use apiClient with an absolute baseURL for standalone HTTP calls."
+        );
+      }
+      let localClients = localScopes.get(runtime);
+      if (!localClients) {
+        localClients = /* @__PURE__ */ new WeakMap();
+        localScopes.set(runtime, localClients);
+      }
+      let local = localClients.get(currentRequest);
+      if (!local) {
+        const origin = new URL(currentRequest.url).origin;
+        const headers = new Headers();
+        for (const name of ["cookie", "authorization", "accept-language"]) {
+          const value = currentRequest.headers.get(name);
+          if (value !== null) headers.set(name, value);
+        }
+        local = createAPIClientRuntime(
+          {
+            ...options,
+            integrations: false,
+            baseURL: new URL(runtime.basePath, origin).toString()
+          },
+          {
+            headers,
+            signal: currentRequest.signal,
+            cache: new FarmClientDataCache({ subscribeToInvalidation: false }),
+            routeMeta,
+            fetch: (url, init) => {
+              if (new URL(url).origin !== origin) {
+                throw new Error(
+                  "api can only dispatch to this Farm app. Use apiClient for HTTP calls."
+                );
+              }
+              currentRequest.signal.throwIfAborted();
+              return runtime.dispatch(new Request(url, init));
+            }
+          }
+        );
+        localClients.set(currentRequest, local);
+      }
+      return local.request(path, method, input, clientOptions);
+    },
+    routeMeta,
+    "/api",
+    true,
+    options.integrations === false ? void 0 : {
+      integrations: integrationsServer({
+        baseURL: options.baseURL,
+        headers: options.headers,
+        credentials: options.credentials,
+        timeoutMs: options.timeoutMs,
+        fetch: options.fetch,
+        onRequest: options.onRequest,
+        onResponse: options.onResponse,
+        onError: options.onError,
+        ...options.integrations
+      })
+    },
+    options.routes ? new ClientRouteManifest(options.routes) : void 0
+  );
+  return {
+    api,
+    apiClient: createAPIClient(options)
+  };
+}
+function createAPIClient(options = {}) {
+  return createAPIClientRuntime(options).client;
+}
+function createAPIClientRuntime(options = {}, transport) {
+  options ?? (options = {});
+  const baseURL = options.baseURL || getFarmAPIBaseURL();
+  const httpFetch = options.fetch;
+  const integrationOptions = options.integrations === false ? false : {
+    baseURL: options.baseURL,
+    headers: options.headers,
+    credentials: options.credentials,
+    timeoutMs: options.timeoutMs,
+    fetch: httpFetch,
+    onRequest: options.onRequest,
+    onResponse: options.onResponse,
+    onError: options.onError,
+    ...typeof options.integrations === "object" ? options.integrations : {}
+  };
+  const rootAliases = integrationOptions === false ? void 0 : {
+    integrations: integrationsClient(integrationOptions)
+  };
+  const sharedCacheState = transport?.cache ?? getFarmClientDataCache();
+  const localCaches = transport ? /* @__PURE__ */ new Set([sharedCacheState]) : void 0;
+  const sharedInflightState = /* @__PURE__ */ new Map();
+  let scopedRequestState;
+  const routeMeta = transport?.routeMeta ?? /* @__PURE__ */ new WeakMap();
+  let requestCounter = 0;
+  const fetchClient = async (path, requestOptions, defaultHeaders, cancellation) => {
+    const url = resolveFarmAPIRequestURL(path, baseURL);
+    const method = String(requestOptions.method || "GET").toUpperCase();
+    if (requestOptions.query) {
+      appendAPIQuery(url.searchParams, requestOptions.query);
+    }
+    const headers = new Headers(defaultHeaders);
+    new Headers(requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    const fetchOptions = {
+      method,
+      headers,
+      credentials: options.credentials,
+      signal: cancellation.signal
+    };
+    if (method === "QUERY" && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    if (requestOptions.body !== void 0) {
+      if (isFormData(requestOptions.body)) {
+        headers.delete("content-type");
+        fetchOptions.body = requestOptions.body;
+      } else {
+        if (!headers.has("content-type")) headers.set("content-type", "application/json");
+        fetchOptions.body = JSON.stringify(requestOptions.body);
+      }
+    }
+    cancellation.check();
+    const response = await (transport?.fetch ?? httpFetch ?? fetch)(url.toString(), fetchOptions);
+    cancellation.check();
+    const invalidations = decodeFarmCacheInvalidations(
+      response.headers?.get?.(FARM_CACHE_INVALIDATION_HEADER)
+    );
+    if (transport) {
+      for (const cache of localCaches) {
+        for (const key of invalidations) cache.invalidate(key);
+      }
+    } else {
+      applyFarmCacheInvalidations(invalidations);
+    }
+    let data;
+    try {
+      data = await readAPIResponseData(response, method);
+      cancellation.check();
+    } catch (decodeError) {
+      if (!(decodeError instanceof APIResponseDecodeError)) throw decodeError;
+      if (response.ok) throw decodeError.cause;
+      return { response, data: void 0, decodeError: decodeError.cause };
+    }
+    return { response, data };
+  };
+  const request = async (path, method, input = {}, clientOptions) => {
+    const maxRetries = resolveClientRetryCount(clientOptions?.retry?.count);
+    if (typeof clientOptions?.retry?.delay !== "function") {
+      resolveClientRetryDelay(clientOptions?.retry?.delay);
+    }
+    const cancellation = createClientCancellation(
+      clientOptions?.signal,
+      clientOptions?.timeoutMs ?? options.timeoutMs,
+      transport?.signal
+    );
+    const normalizeCallError = (error) => {
+      if (!cancellation.signal?.aborted) return normalizeError(error);
+      const normalized = new APIClientError(
+        cancellation.timedOut ? "timeout" : "aborted",
+        void 0,
+        {
+          status: 0,
+          message: cancellation.timedOut ? "Client request timed out" : "Client request aborted"
+        }
+      );
+      normalized.cause = cancellation.signal.reason;
+      return normalized;
+    };
+    try {
+      const methodUpper = method.toUpperCase();
+      const requestId = `${Date.now()}-${++requestCounter}`;
+      const defaultHeaders = new Headers(transport?.headers);
+      let requestContextError;
+      try {
+        cancellation.check();
+        const resolved = resolveClientHeaders(options.headers);
+        const headers = resolved instanceof Headers ? resolved : await cancellation.run(() => resolved);
+        cancellation.check();
+        headers.forEach((value, name) => defaultHeaders.set(name, value));
+      } catch (error) {
+        requestContextError = normalizeCallError(error);
+      }
+      const cacheOptions = clientOptions?.cache ? {
+        ...options.cacheDefaults,
+        ...clientOptions.cache
+      } : void 0;
+      const configuredCacheKey = clientOptions?.key ?? cacheOptions?.key;
+      const cacheKey = normalizeFarmClientCacheKey(
+        configuredCacheKey ?? buildCacheKey(methodUpper, path, input, baseURL, defaultHeaders)
+      );
+      const now = Date.now();
+      const emitStatus = (phase, payload) => {
+        notifyClientObserver(
+          clientOptions?.onStatus,
+          [
+            {
+              phase,
+              requestId,
+              method: methodUpper,
+              key: cacheKey,
+              input,
+              timestamp: Date.now(),
+              ...payload
+            }
+          ],
+          "API client onStatus"
+        );
+      };
+      const policy = cacheOptions?.policy ?? (cacheOptions ? "cache-first" : "network-only");
+      const staleTime = cacheOptions?.staleTime ?? 0;
+      const hasReliableDefaultCacheKey = methodUpper !== "QUERY" || !isFormData(input?.body) || configuredCacheKey !== void 0;
+      const isCacheEnabled = Boolean(cacheOptions) && (methodUpper === "GET" || methodUpper === "QUERY") && hasReliableDefaultCacheKey;
+      const needsCacheState = isCacheEnabled || Boolean(clientOptions?.optimistic?.update?.length) || Boolean(clientOptions?.invalidate);
+      let requestCacheContext = void 0;
+      if (needsCacheState && !requestContextError) {
+        try {
+          requestCacheContext = getRequestCacheContext(
+            { headers: defaultHeaders, credentials: options.credentials },
+            input,
+            // Custom transports can inject an identity outside visible headers.
+            // Never share their cached data with other client instances.
+            httpFetch ? "client" : cacheOptions?.scope
+          );
+        } catch (error) {
+          requestContextError = normalizeError(error);
+        }
+      }
+      let cacheState = sharedCacheState;
+      let inflightState = sharedInflightState;
+      let requestScopedState;
+      if (requestCacheContext !== void 0) {
+        if (scopedRequestState && scopedRequestState.context !== requestCacheContext) {
+          scopedRequestState.retired = true;
+          if (scopedRequestState.inflight.size === 0) scopedRequestState.cache.dispose();
+          scopedRequestState = void 0;
+        }
+        scopedRequestState ?? (scopedRequestState = {
+          context: requestCacheContext,
+          cache: new FarmClientDataCache({ subscribeToInvalidation: !transport }),
+          inflight: /* @__PURE__ */ new Map(),
+          retired: false
+        });
+        requestScopedState = scopedRequestState;
+        cacheState = requestScopedState.cache;
+        localCaches?.add(cacheState);
+        inflightState = requestScopedState.inflight;
+      }
+      const optimisticState = getOptimisticState(cacheState);
+      const entry = getValidCacheEntry(cacheState, cacheKey, now);
+      const isStale = entry ? isEntryStale(entry, now) : true;
+      const applyOptimisticUpdates = () => {
+        if (!clientOptions?.optimistic?.update?.length) return [];
+        const snapshots = /* @__PURE__ */ new Map();
+        for (const update of clientOptions.optimistic.update) {
+          const [target, targetInput, updater] = update.length === 2 ? [update[0], void 0, update[1]] : [update[0], update[1], update[2]];
+          const targetKey = resolveTargetKey(
+            routeMeta,
+            target,
+            targetInput,
+            baseURL,
+            defaultHeaders,
+            transport ? baseURL : void 0
+          );
+          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,
+              staleAt: targetEntry?.staleAt ?? now + (cacheOptions?.staleTime ?? options.cacheDefaults?.staleTime ?? 0),
+              gcAt: targetEntry?.gcAt ?? getGcAt(now, cacheOptions?.gcTime ?? options.cacheDefaults?.gcTime)
+            };
+            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());
+      };
+      const rollbackOptimisticUpdates = (snapshots) => {
+        if (!clientOptions?.optimistic?.rollbackOnError) return;
+        settleOptimisticUpdates(cacheState, optimisticState, snapshots, "rollback");
+      };
+      const invalidateUncommittedOptimisticUpdates = (snapshots) => {
+        if (clientOptions?.optimistic?.rollbackOnError) return;
+        for (const key of settleOptimisticUpdates(
+          cacheState,
+          optimisticState,
+          snapshots,
+          "invalidate"
+        )) {
+          emitStatus("invalidated", { key });
+        }
+      };
+      const executeNetwork = 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);
+          const allowDedupe = isCacheEnabled && dedupeMs > 0 && !cancellation.signal && !requestContextError;
+          if (allowDedupe && inflight && !inflight.cancellable && now - inflight.startedAt < dedupeMs) {
+            emitStatus("pending", { isBackground: opts?.isBackground, data: entry?.data });
+            const result2 = await inflight.promise;
+            if (result2.error) {
+              emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
+              notifyClientObserver(options.onError, [result2.error]);
+              if (opts?.callCallbacks !== false) {
+                notifyClientObserver(clientOptions?.onError, [result2.error], "API client onError");
+              }
+            } else {
+              emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+              if (opts?.callCallbacks !== false) {
+                notifyClientObserver(
+                  clientOptions?.onSuccess,
+                  [result2.data],
+                  "API client onSuccess"
+                );
+              }
+            }
+            return result2;
+          }
+          let invalidatedDuringRequest = false;
+          if (isCacheEnabled) {
+            readOwners = getCacheReadOwners(cacheState);
+            readOwner = {};
+            readOwners.set(resolvedCacheKey, readOwner);
+            unsubscribeInvalidation = cacheState.subscribe(cacheKey, (event) => {
+              if (event === "invalidate") invalidatedDuringRequest = true;
+            });
+          }
+          emitStatus(opts?.isBackground ? "revalidating" : "pending", {
+            isBackground: opts?.isBackground
+          });
+          const promise = (async () => {
+            const shouldRetryFailure = clientOptions?.retry?.shouldRetry ?? isFarmRetryableFailure;
+            let attempt = 0;
+            while (true) {
+              if (options.onRequest || clientOptions?.onRequest) {
+                const requestEvent = {
+                  requestId,
+                  method: methodUpper,
+                  key: cacheKey,
+                  path,
+                  input,
+                  attempt,
+                  timestamp: Date.now()
+                };
+                notifyClientObserver(options.onRequest, [requestEvent]);
+                notifyClientObserver(
+                  clientOptions?.onRequest,
+                  [requestEvent],
+                  "API client onRequest"
+                );
+              }
+              try {
+                if (requestContextError) throw requestContextError;
+                const { response, data, decodeError } = await cancellation.run(
+                  () => fetchClient(
+                    path,
+                    {
+                      ...input,
+                      method: methodUpper
+                    },
+                    defaultHeaders,
+                    cancellation
+                  )
+                );
+                const error = response.ok ? null : createResponseError2(response, data, decodeError);
+                const responseEvent = {
+                  requestId,
+                  method: methodUpper,
+                  key: cacheKey,
+                  path,
+                  input,
+                  attempt,
+                  timestamp: Date.now(),
+                  response,
+                  data: response.ok ? data : void 0,
+                  error: error ?? void 0,
+                  ok: response.ok,
+                  status: response.status
+                };
+                notifyClientObserver(options.onResponse, [
+                  response.ok ? data : void 0,
+                  error,
+                  responseEvent
+                ]);
+                notifyResponseObserver(
+                  clientOptions?.onResponse,
+                  response.ok ? data : void 0,
+                  error,
+                  responseEvent
+                );
+                if (!error) {
+                  return { data, error: null, key: cacheKey };
+                }
+                if (attempt >= maxRetries || !shouldRetryFailure({
+                  attempt,
+                  method: methodUpper,
+                  status: response.status,
+                  error
+                })) {
+                  return { data: void 0, error, key: cacheKey };
+                }
+              } catch (err) {
+                const error = normalizeCallError(err);
+                const responseEvent = {
+                  requestId,
+                  method: methodUpper,
+                  key: cacheKey,
+                  path,
+                  input,
+                  attempt,
+                  timestamp: Date.now(),
+                  error,
+                  ok: false
+                };
+                notifyClientObserver(options.onResponse, [void 0, error, responseEvent]);
+                notifyResponseObserver(clientOptions?.onResponse, void 0, error, responseEvent);
+                if (attempt >= maxRetries || requestContextError || cancellation.signal?.aborted || !shouldRetryFailure({ attempt, method: methodUpper, error })) {
+                  return { data: void 0, error, key: cacheKey };
+                }
+              }
+              attempt += 1;
+              const delay = resolveClientRetryDelay(
+                typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay
+              );
+              if (delay > 0) {
+                try {
+                  await cancellation.delay(delay);
+                } catch (error) {
+                  return { data: void 0, error: normalizeCallError(error), key: cacheKey };
+                }
+              }
+            }
+          })();
+          const inflightEntry = {
+            promise,
+            startedAt: now,
+            cancellable: !!cancellation.signal || !!requestContextError
+          };
+          inflightState.set(cacheKey, inflightEntry);
+          try {
+            const result2 = await promise;
+            if (inflightState.get(cacheKey) === inflightEntry && readOwners?.get(resolvedCacheKey) === readOwner && !invalidatedDuringRequest && !result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
+              const updatedAt = Date.now();
+              const cached = {
+                data: result2.data,
+                updatedAt,
+                staleAt: updatedAt + staleTime,
+                gcAt: getGcAt(updatedAt, cacheOptions?.gcTime),
+                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 });
+              notifyClientObserver(options.onError, [result2.error]);
+              if (opts?.callCallbacks !== false) {
+                notifyClientObserver(clientOptions?.onError, [result2.error], "API client onError");
+              }
+            } else {
+              emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+              if (opts?.callCallbacks !== false) {
+                notifyClientObserver(
+                  clientOptions?.onSuccess,
+                  [result2.data],
+                  "API client onSuccess"
+                );
+              }
+            }
+            return result2;
+          } finally {
+            if (inflightState.get(cacheKey) === inflightEntry) {
+              inflightState.delete(cacheKey);
+            }
+            if (requestContextError && requestScopedState) {
+              requestScopedState.retired = true;
+              if (scopedRequestState === requestScopedState) scopedRequestState = void 0;
+            }
+            if (requestScopedState?.retired && requestScopedState.inflight.size === 0) {
+              requestScopedState.cache.dispose();
+            }
+          }
+        } finally {
+          if (readOwner && readOwners?.get(resolvedCacheKey) === readOwner) {
+            readOwners.delete(resolvedCacheKey);
+          }
+          unsubscribeInvalidation?.();
+          release();
+        }
+      };
+      const invalidateTargets = async () => {
+        if (!clientOptions?.invalidate) return;
+        const invalidateOptions = Array.isArray(clientOptions.invalidate) ? { targets: clientOptions.invalidate, refetch: false } : {
+          targets: clientOptions.invalidate.targets,
+          refetch: clientOptions.invalidate.refetch ?? false
+        };
+        const refetches = /* @__PURE__ */ new Set();
+        for (const target of invalidateOptions.targets) {
+          const targetKey = resolveTargetKey(
+            routeMeta,
+            target,
+            void 0,
+            baseURL,
+            defaultHeaders,
+            transport ? baseURL : void 0
+          );
+          if (!targetKey) continue;
+          const existing = cacheState.get(targetKey);
+          const invalidatedAt = Date.now();
+          cacheState.invalidate(targetKey, invalidatedAt);
+          if (existing) {
+            const stack = optimisticState.get(targetKey);
+            if (stack?.renderedEntry === existing) {
+              stack.invalidatedAt = invalidatedAt;
+              stack.renderedEntry = cacheState.get(targetKey);
+            }
+          }
+          emitStatus("invalidated", { key: targetKey });
+          const refetch = existing?.[API_CACHE_REFETCH];
+          if (invalidateOptions.refetch && refetch) {
+            refetches.add(refetch);
+          }
+        }
+        for (const refetch of refetches) refetch();
+      };
+      const optimisticSnapshots = requestContextError ? [] : applyOptimisticUpdates();
+      if (isCacheEnabled && !requestContextError && !cancellation.signal?.aborted) {
+        if (entry && !isStale && policy !== "network-only") {
+          emitStatus("success", { data: entry.data });
+          notifyClientObserver(clientOptions?.onSuccess, [entry.data], "API client onSuccess");
+          notifyClientObserver(
+            clientOptions?.onSettled,
+            [entry.data, null],
+            "API client onSettled"
+          );
+          return { data: entry.data, error: null, key: cacheKey };
+        }
+        if (entry && isStale && policy === "stale-while-revalidate") {
+          emitStatus("success", { data: entry.data });
+          notifyClientObserver(clientOptions?.onSuccess, [entry.data], "API client onSuccess");
+          notifyClientObserver(
+            clientOptions?.onSettled,
+            [entry.data, null],
+            "API client onSettled"
+          );
+          void executeNetwork({ isBackground: true, callCallbacks: false });
+          return { data: entry.data, error: null, key: cacheKey };
+        }
+      }
+      const result = await executeNetwork();
+      if (result.error) {
+        if (cancellation.signal?.aborted) {
+          settleOptimisticUpdates(cacheState, optimisticState, optimisticSnapshots, "rollback");
+        } else {
+          rollbackOptimisticUpdates(optimisticSnapshots);
+          invalidateUncommittedOptimisticUpdates(optimisticSnapshots);
+        }
+      } else {
+        settleOptimisticUpdates(cacheState, optimisticState, optimisticSnapshots, "commit");
+        await invalidateTargets();
+      }
+      notifyClientObserver(
+        clientOptions?.onSettled,
+        [result.data, result.error],
+        "API client onSettled"
+      );
+      return result;
+    } finally {
+      cancellation.dispose();
+    }
+  };
+  const client = createNestedProxy(
+    [],
+    request,
+    routeMeta,
+    baseURL,
+    isSameOriginAPIBaseURL(baseURL),
+    rootAliases,
+    options.routes ? new ClientRouteManifest(options.routes) : void 0
+  );
+  return { client, request };
+}
+async function readAPIResponseData(response, method) {
+  if (method === "HEAD" || response.status === 204 || response.status === 205 || response.status === 304) {
+    return void 0;
+  }
+  if (!response.headers?.get && typeof response.json === "function") {
+    return readResponseJSON(response);
+  }
+  if (response.body === null) return void 0;
+  if (isJSONStreamResponse(response)) {
+    return readJSONStream(response);
+  }
+  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (typeof response.arrayBuffer === "function") {
+    const data = await response.arrayBuffer();
+    if (data.byteLength === 0) return void 0;
+    if (!contentType || contentType === "application/json" || contentType.endsWith("+json")) {
+      return parseResponseJSON(new TextDecoder().decode(data));
+    }
+    if (contentType.startsWith("text/") || contentType === "application/xml" || contentType === "application/xhtml+xml" || contentType === "application/graphql") {
+      return new TextDecoder().decode(data);
+    }
+    return data;
+  }
+  if ((!contentType || contentType === "application/json" || contentType.endsWith("+json")) && typeof response.json === "function") {
+    return readResponseJSON(response);
+  }
+  if ((contentType?.startsWith("text/") || contentType === "application/xml" || contentType === "application/xhtml+xml" || contentType === "application/graphql") && typeof response.text === "function") {
+    return response.text();
+  }
+  if (typeof response.json === "function") {
+    return readResponseJSON(response);
+  }
+  return void 0;
+}
+var APIResponseDecodeError = class extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : "Failed to decode JSON response");
+    this.name = "APIResponseDecodeError";
+    this.cause = cause;
+  }
+};
+function parseResponseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new APIResponseDecodeError(error);
+  }
+}
+async function readResponseJSON(response) {
+  try {
+    return await response.json();
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new APIResponseDecodeError(error);
+    throw error;
+  }
+}
+function createNestedProxy(path, client, routeMeta, baseURL, sameOrigin, rootAliases, manifest, bound = {}) {
+  const target = () => {
+  };
+  const proxy = new Proxy(target, {
+    // When accessing a property (api.hello)
+    get(_target, prop) {
+      if (prop === "then") return void 0;
+      if (prop === "$params") {
+        return (params) => {
+          if (!manifest)
+            throw new TypeError(
+              "$params requires createAPIClient({ routes: apiRoutes }) from the generated API manifest."
+            );
+          const scope = manifest.bind(buildProxyRoutePath(path), params);
+          return createNestedProxy(
+            [...path, scope.segment],
+            client,
+            routeMeta,
+            baseURL,
+            sameOrigin,
+            rootAliases,
+            manifest,
+            Object.freeze({ ...bound, ...scope.params })
+          );
+        };
+      }
+      if (prop === FARM_API_ROUTE_REF_SYMBOL) {
+        return path.length > 0;
+      }
+      if (prop === FARM_API_ROUTE_META_SYMBOL) {
+        let metadata;
+        try {
+          metadata = resolveRouteMeta({ path, baseURL, manifest, bound });
+        } catch {
+          return null;
+        }
+        const requestURL = resolveFarmAPIRequestURL(metadata.routePath, baseURL);
+        return Object.freeze({
+          path: `${requestURL.pathname}${requestURL.search}${requestURL.hash}`,
+          method: metadata.method,
+          baseURL: requestURL.origin,
+          sameOrigin
+        });
+      }
+      if (path.length === 0 && typeof prop === "string" && rootAliases && Object.prototype.hasOwnProperty.call(rootAliases, prop)) {
+        return rootAliases[prop];
+      }
+      if (typeof prop !== "string") {
+        return Reflect.get(_target, prop);
+      }
+      return createNestedProxy(
+        [...path, prop],
+        client,
+        routeMeta,
+        baseURL,
+        sameOrigin,
+        rootAliases,
+        manifest,
+        bound
+      );
+    },
+    // When calling as a function
+    apply(_target, _thisArg, args) {
+      const lastPart = path[path.length - 1];
+      const httpMethods = ["get", "head", "query", "post", "put", "delete", "patch", "options"];
+      if (httpMethods.includes(lastPart)) {
+        const routePath = buildProxyRoutePath(path.slice(0, -1));
+        const method = lastPart.toUpperCase();
+        const [options, clientOptions] = args;
+        const resolved = manifest ? manifest.resolve(routePath, method, bound, options) : routePath;
+        if (!manifest && options?.params)
+          throw new TypeError("Dynamic params require the generated routes manifest.");
+        return client(resolved, method, options, clientOptions);
+      } else {
+        const routePath = buildProxyRoutePath(path);
+        const [options, clientOptions] = args;
+        const method = options?.method || "GET";
+        const resolved = manifest ? manifest.resolve(routePath, method, bound, options) : routePath;
+        return client(resolved, method, options, clientOptions);
+      }
+    }
+  });
+  routeMeta.set(proxy, { path: [...path], baseURL, manifest, bound });
+  return proxy;
+}
+function buildProxyRoutePath(path) {
+  return "/api/" + path.join("/").replace(/^\/+/, "");
+}
+function isAPIRouteRef(value) {
+  return typeof value === "function" && value[FARM_API_ROUTE_REF_SYMBOL] === true;
+}
+function getAPIRouteRefMetadata(value) {
+  if (!isAPIRouteRef(value)) return null;
+  const metadata = value[FARM_API_ROUTE_META_SYMBOL];
+  if (!metadata || typeof metadata !== "object") return null;
+  const candidate = metadata;
+  if (typeof candidate.path !== "string" || typeof candidate.method !== "string" || typeof candidate.baseURL !== "string" || typeof candidate.sameOrigin !== "boolean") {
+    return null;
+  }
+  return {
+    path: candidate.path,
+    method: candidate.method,
+    baseURL: candidate.baseURL,
+    sameOrigin: candidate.sameOrigin
+  };
+}
+function createServerAPIClient(endpoints, options = {}) {
+  if (options.integrations === false || Object.prototype.hasOwnProperty.call(endpoints, "integrations")) {
+    return endpoints;
+  }
+  Object.defineProperty(endpoints, "integrations", {
+    get() {
+      return integrationsServer(
+        typeof options.integrations === "object" ? options.integrations : {}
+      );
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return endpoints;
+}
+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)]);
+    });
+  };
+}
+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;
+}
+function getOptimisticState(cache) {
+  let state = optimisticStates.get(cache);
+  if (!state) {
+    state = /* @__PURE__ */ new Map();
+    optimisticStates.set(cache, state);
+  }
+  return state;
+}
+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]
+  };
+}
+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);
+}
+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;
+}
+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);
+}
+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;
+}
+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());
+}
+function settleServerFnOptimisticUpdates(snapshots, outcome) {
+  if (snapshots.length === 0) return;
+  const cacheState = getFarmClientDataCache();
+  settleOptimisticUpdates(cacheState, getOptimisticState(cacheState), snapshots, outcome);
+}
+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;
+}
+function buildCacheKey(method, path, input, baseURL, defaultHeaders) {
+  const keyInput = input && typeof input === "object" ? {
+    query: input.query,
+    body: input.body,
+    ...method === "QUERY" ? {
+      contentType: getHeader(input.headers, "content-type") ?? getHeader(defaultHeaders, "content-type") ?? "application/json",
+      contentEncoding: getHeader(input.headers, "content-encoding") ?? getHeader(defaultHeaders, "content-encoding")
+    } : {}
+  } : input;
+  const url = resolveFarmAPIRequestURL(path, baseURL);
+  return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
+}
+function isSameOriginAPIBaseURL(baseURL) {
+  if (typeof window === "undefined" || !window.location) return baseURL.startsWith("/");
+  return resolveFarmAPIRequestURL("/api", baseURL).origin === window.location.origin;
+}
+function stableStringify(value) {
+  if (value === null || value === void 0) return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "bigint") return `bigint:${value.toString()}`;
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (value instanceof URLSearchParams) {
+    return `urlsearchparams:${stableStringify(Array.from(value.entries()))}`;
+  }
+  const keys = Object.keys(value).sort();
+  const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+function getHeader(headers, name) {
+  if (!headers || typeof headers !== "object") return void 0;
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    return headers.get(name) ?? void 0;
+  }
+  const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+  return entry?.[1] === void 0 ? void 0 : String(entry[1]);
+}
+function getRequestCacheContext(options, input, scope) {
+  const credentials = options.credentials ?? "same-origin";
+  const headers = new Headers(options.headers);
+  const requestHeaders = input && typeof input === "object" && "headers" in input ? input.headers : void 0;
+  if (requestHeaders) {
+    new Headers(requestHeaders).forEach((value, key) => headers.set(key, value));
+  }
+  const carriesBrowserIdentity = credentials !== "omit" || [...headers].length > 0;
+  if (scope !== "client" && !carriesBrowserIdentity) return void 0;
+  return stableStringify({
+    credentials,
+    headers: [...headers].sort(([left], [right]) => left.localeCompare(right))
+  });
+}
+function getGcAt(now, gcTime) {
+  if (gcTime === void 0) return void 0;
+  if (!Number.isFinite(gcTime) || gcTime <= 0) return now;
+  return now + gcTime;
+}
+function getValidCacheEntry(cacheState, key, now) {
+  const entry = cacheState.get(key);
+  if (!entry) return void 0;
+  if (entry.gcAt !== void 0 && now >= entry.gcAt) {
+    cacheState.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+function isEntryStale(entry, now) {
+  if (entry.invalidatedAt !== void 0) return true;
+  return now >= entry.staleAt;
+}
+function resolveTargetKey(routeMeta, target, input, baseURL = "http://localhost:3000", defaultHeaders, localBaseURL) {
+  if (!target) return null;
+  if (typeof target === "string") return target;
+  if (typeof target === "function") {
+    const meta = routeMeta.get(target);
+    if (!meta) return null;
+    const { method, routePath } = resolveRouteMeta(meta, input);
+    return buildCacheKey(
+      method,
+      routePath,
+      input ?? {},
+      localBaseURL ?? meta.baseURL,
+      defaultHeaders
+    );
+  }
+  if (Array.isArray(target)) {
+    const [route, routeInput] = target;
+    if (typeof route === "function") {
+      return resolveTargetKey(routeMeta, route, routeInput, baseURL, defaultHeaders, localBaseURL);
+    }
+    return normalizeFarmClientCacheKey(target);
+  }
+  if ("key" in target) return normalizeFarmClientCacheKey(target.key);
+  if ("path" in target) {
+    const method = target.method ?? "GET";
+    return buildCacheKey(method, target.path, target.input ?? {}, baseURL, defaultHeaders);
+  }
+  return null;
+}
+function resolveRouteMeta(meta, input) {
+  const httpMethods = ["get", "head", "query", "post", "put", "delete", "patch", "options"];
+  const lastPart = meta.path[meta.path.length - 1];
+  if (lastPart && httpMethods.includes(lastPart)) {
+    return {
+      routePath: meta.manifest ? meta.manifest.resolve(
+        buildProxyRoutePath(meta.path.slice(0, -1)),
+        lastPart.toUpperCase(),
+        meta.bound ?? {},
+        input
+      ) : buildProxyRoutePath(meta.path.slice(0, -1)),
+      method: lastPart.toUpperCase()
+    };
+  }
+  return {
+    routePath: meta.manifest ? meta.manifest.resolve(buildProxyRoutePath(meta.path), "GET", meta.bound ?? {}, input) : buildProxyRoutePath(meta.path),
+    method: "GET"
+  };
+}
+function normalizeError(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;
+}
+function notifyResponseObserver(observer, data, error, event) {
+  notifyClientObserver(observer, [data, error, event], "API client onResponse");
+}
+function isFormData(value) {
+  return typeof value === "object" && value !== null && (typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function");
+}
+function appendAPIQuery(searchParams, query) {
+  if (query instanceof URLSearchParams) {
+    const keys = new Set(query.keys());
+    for (const key of keys) searchParams.delete(key);
+    query.forEach((value, key) => searchParams.append(key, value));
+    return;
+  }
+  if (!query || typeof query !== "object" || Array.isArray(query)) {
+    throw new TypeError("API query input must be an object or URLSearchParams.");
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    searchParams.delete(key);
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item === void 0 || item === null) continue;
+      if (!isAPIQueryPrimitive(item)) {
+        throw new TypeError(
+          `API query parameter "${key}" must be a string, number, boolean, bigint, or an array of those values.`
+        );
+      }
+      searchParams.append(key, String(item));
+    }
+  }
+}
+function isAPIQueryPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
+function createResponseError2(response, data, cause) {
+  const expected = readEndpointErrorEnvelope(data);
+  if (expected) {
+    return new APIClientError(expected.code, expected.data, {
+      status: response.status,
+      message: expected.message,
+      response
+    });
+  }
+  const error = new APIClientError("http_error", data, {
+    status: response.status,
+    message: `HTTP ${response.status}: ${response.statusText}`,
+    response
+  });
+  if (cause !== void 0) error.cause = cause;
+  return error;
+}
+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
+  };
+}
+
+export {
+  IntegrationClientError,
+  createIntegrationClient,
+  integrationsClient,
+  integrationsServer,
+  createIntegrationServerClient,
+  createIntegrationApi,
+  createIntegrationClients,
+  createIntegrations,
+  getIntegrationAPIManifest,
+  integrationClients,
+  FARM_API_ROUTE_REF_SYMBOL,
+  FARM_API_ROUTE_META_SYMBOL,
+  APIClientError,
+  createApiClients,
+  createAPIClient,
+  isAPIRouteRef,
+  getAPIRouteRefMetadata,
+  createServerAPIClient,
+  applyServerFnOptimisticUpdates,
+  settleServerFnOptimisticUpdates,
+  resolveServerFnInvalidateTargets
+};