@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-2NHOYYUT.mjs

@@ -1,2250 +0,0 @@
-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-BLD5GVCG.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") 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
-};