@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/chunk-W2CRQFF6.mjs

@@ -0,0 +1,1352 @@
+import {
+  getFarmClientDataCache,
+  normalizeFarmClientCacheKey
+} from "./chunk-TQAEEJB4.mjs";
+import {
+  isFarmAPIStream,
+  isJSONStreamResponse,
+  readJSONStream
+} from "./chunk-ALCLXXTY.mjs";
+import {
+  FARM_CACHE_INVALIDATION_HEADER,
+  applyFarmCacheInvalidations,
+  decodeFarmCacheInvalidations
+} from "./chunk-RBRLLZL5.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/integration-client.ts
+var _IntegrationClientError = class _IntegrationClientError extends Error {
+  constructor(message, response, data) {
+    super(message);
+    this.name = "IntegrationClientError";
+    this.status = response.status;
+    this.response = response;
+    this.data = data;
+  }
+};
+__name(_IntegrationClientError, "IntegrationClientError");
+var IntegrationClientError = _IntegrationClientError;
+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";
+}
+__name(isOperation, "isOperation");
+function tryResolveSourceAPI(source) {
+  if ("kind" in source && source.kind === "farm-integration") {
+    if (!source.api) {
+      return null;
+    }
+    return source.api;
+  }
+  return source;
+}
+__name(tryResolveSourceAPI, "tryResolveSourceAPI");
+function getIntegrationRuntimeRegistry() {
+  const globalState = globalThis;
+  return globalState[INTEGRATION_RUNTIME_REGISTRY_KEY] || /* @__PURE__ */ new Map();
+}
+__name(getIntegrationRuntimeRegistry, "getIntegrationRuntimeRegistry");
+function getRegisteredIntegrationRuntimeLocal(key) {
+  return getIntegrationRuntimeRegistry().get(key);
+}
+__name(getRegisteredIntegrationRuntimeLocal, "getRegisteredIntegrationRuntimeLocal");
+function getRegisteredIntegrationsLocal() {
+  return Object.fromEntries(
+    Array.from(getIntegrationRuntimeRegistry().entries()).map(([key, runtime]) => [
+      key,
+      runtime.integration
+    ])
+  );
+}
+__name(getRegisteredIntegrationsLocal, "getRegisteredIntegrationsLocal");
+function resolveCurrentRequestLocal() {
+  const globalState = globalThis;
+  return globalState[CURRENT_REQUEST_RESOLVER_KEY]?.();
+}
+__name(resolveCurrentRequestLocal, "resolveCurrentRequestLocal");
+function resolveIntegrationRequestDispatcherLocal() {
+  const globalState = globalThis;
+  return globalState[INTEGRATION_REQUEST_DISPATCHER_KEY];
+}
+__name(resolveIntegrationRequestDispatcherLocal, "resolveIntegrationRequestDispatcherLocal");
+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);
+}
+__name(isIntegrationClientData, "isIntegrationClientData");
+function isPlainIntegrationDataObject(value) {
+  if (!isIntegrationClientData(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainIntegrationDataObject, "isPlainIntegrationDataObject");
+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;
+}
+__name(sanitizeIntegrationClientDataValue, "sanitizeIntegrationClientDataValue");
+function normalizeIntegrationClientData(value) {
+  if (!isIntegrationClientData(value)) {
+    return void 0;
+  }
+  const sanitized = sanitizeIntegrationClientDataValue(value);
+  return isIntegrationClientData(sanitized) && Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+__name(normalizeIntegrationClientData, "normalizeIntegrationClientData");
+function getIntegrationDataHeaderByteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+__name(getIntegrationDataHeaderByteLength, "getIntegrationDataHeaderByteLength");
+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;
+}
+__name(mergeIntegrationClientData, "mergeIntegrationClientData");
+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;
+}
+__name(serializeIntegrationClientData, "serializeIntegrationClientData");
+function appendIntegrationClientDataHeader(headers, data) {
+  if (!data) {
+    return;
+  }
+  headers.set(INTEGRATION_DATA_HEADER, serializeIntegrationClientData(data));
+}
+__name(appendIntegrationClientDataHeader, "appendIntegrationClientDataHeader");
+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]);
+}
+__name(resolveAutomaticClientNamespaces, "resolveAutomaticClientNamespaces");
+function resolveAutomaticServerNamespaces() {
+  return Object.entries(getRegisteredIntegrationsLocal()).flatMap(([key, source]) => {
+    const api = tryResolveSourceAPI(source);
+    return api ? [[key, api, source]] : [];
+  });
+}
+__name(resolveAutomaticServerNamespaces, "resolveAutomaticServerNamespaces");
+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));
+  }
+}
+__name(appendQuery, "appendQuery");
+function appendHeaders(target, source) {
+  if (!source) {
+    return;
+  }
+  const headers = new Headers(source);
+  headers.forEach((value, key) => {
+    target.set(key, value);
+  });
+}
+__name(appendHeaders, "appendHeaders");
+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
+  };
+}
+__name(resolveRequestLike, "resolveRequestLike");
+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";
+}
+__name(resolveServerBaseURL, "resolveServerBaseURL");
+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;
+}
+__name(resolveForwardHeaders, "resolveForwardHeaders");
+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);
+}
+__name(createBody, "createBody");
+async function parseResponseData(response) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}
+__name(parseResponseData, "parseResponseData");
+async function safeParseResponseData(response) {
+  try {
+    return await parseResponseData(response);
+  } catch {
+    return void 0;
+  }
+}
+__name(safeParseResponseData, "safeParseResponseData");
+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);
+}
+__name(createResponseError, "createResponseError");
+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.");
+}
+__name(normalizeExecutionError, "normalizeExecutionError");
+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
+  };
+}
+__name(finalizeOperationResponse, "finalizeOperationResponse");
+async function executeClientOperation(operation, input, options, requestOptions) {
+  try {
+    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 = new URL(operation.path, baseURL);
+    appendQuery(url, input.query);
+    const headers = new Headers({
+      "x-farm-integration-client": "1",
+      ...options.headers,
+      ...operation.headers,
+      ...requestOptions?.headers
+    });
+    if (operation.responseFormat !== "response") {
+      headers.set("accept", "application/json");
+    }
+    appendIntegrationClientDataHeader(
+      headers,
+      mergeIntegrationClientData(options.data, requestOptions?.data)
+    );
+    const response = await fetch(url.toString(), {
+      method: operation.method,
+      headers,
+      body: createBody(operation.bodyFormat, input.body, headers),
+      credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
+      signal: requestOptions?.signal
+    });
+    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
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: normalizeExecutionError(error)
+    };
+  }
+}
+__name(executeClientOperation, "executeClientOperation");
+async function executeServerOperation(operation, input, options, requestOptions, integrationKey, source) {
+  try {
+    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 currentRequest = serverRequestOptions?.request instanceof Request ? serverRequestOptions.request : options.request instanceof Request ? options.request : resolveCurrentRequestLocal();
+    const request = resolveRequestLike(
+      serverRequestOptions?.request ?? options.request ?? currentRequest
+    );
+    const baseURL = resolveServerBaseURL(serverRequestOptions?.baseURL ?? options.baseURL, request);
+    const url = new URL(operation.path, baseURL);
+    appendQuery(url, input.query);
+    const headers = new Headers();
+    appendHeaders(
+      headers,
+      resolveForwardHeaders(
+        request,
+        serverRequestOptions?.forwardHeaders ?? options.forwardHeaders
+      )
+    );
+    appendHeaders(headers, options.headers);
+    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 directResponse = dispatchIntegrationRequest ? await dispatchIntegrationRequest(
+          runtime,
+          new Request(url.toString(), {
+            method: operation.method,
+            headers,
+            body: createBody(operation.bodyFormat, input.body, headers)
+          }),
+          {
+            currentRequest,
+            data,
+            internal: true
+          }
+        ) : null;
+        if (directResponse) {
+          return await finalizeOperationResponse(operation, directResponse);
+        }
+      }
+    }
+    appendIntegrationClientDataHeader(headers, data);
+    const response = await fetch(url.toString(), {
+      method: operation.method,
+      headers,
+      body: createBody(operation.bodyFormat, input.body, headers),
+      credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
+      signal: requestOptions?.signal
+    });
+    return await finalizeOperationResponse(operation, response);
+  } catch (error) {
+    return {
+      data: null,
+      error: normalizeExecutionError(error)
+    };
+  }
+}
+__name(executeServerOperation, "executeServerOperation");
+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;
+}
+__name(createIntegrationClient, "createIntegrationClient");
+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;
+}
+__name(createAutomaticIntegrationAliases, "createAutomaticIntegrationAliases");
+function integrationsClient(options = {}) {
+  return createAutomaticIntegrationAliases(
+    false,
+    options
+  );
+}
+__name(integrationsClient, "integrationsClient");
+function integrationsServer(options = {}) {
+  return createAutomaticIntegrationAliases(true, {
+    ...options,
+    isServer: true
+  });
+}
+__name(integrationsServer, "integrationsServer");
+function createIntegrationServerClient(sources, options = {}) {
+  return createIntegrationClient(sources, {
+    ...options,
+    isServer: true
+  });
+}
+__name(createIntegrationServerClient, "createIntegrationServerClient");
+function createIntegrationApi(sources, options = {}) {
+  const client = createIntegrationClient(sources, options);
+  return {
+    ...client,
+    server(serverOptions = {}) {
+      return createIntegrationServerClient(sources, {
+        ...options,
+        ...serverOptions
+      });
+    }
+  };
+}
+__name(createIntegrationApi, "createIntegrationApi");
+function isIntegrationClientOptionsInput(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && ("baseURL" in value || "headers" in value || "credentials" in value || "data" in value || "isServer" in value);
+}
+__name(isIntegrationClientOptionsInput, "isIntegrationClientOptionsInput");
+function resolveIntegrationServerOptions(clientOptions = {}, serverOptions = {}) {
+  const data = mergeIntegrationClientData(clientOptions.data, serverOptions.data);
+  return {
+    baseURL: clientOptions.baseURL,
+    headers: clientOptions.headers,
+    credentials: clientOptions.credentials,
+    ...serverOptions,
+    ...data ? { data } : {}
+  };
+}
+__name(resolveIntegrationServerOptions, "resolveIntegrationServerOptions");
+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
+    )
+  };
+}
+__name(createIntegrationClients, "createIntegrationClients");
+function createIntegrations(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0) {
+    return createIntegrationClients();
+  }
+  return createIntegrationClients(
+    sources,
+    clientOptions,
+    serverOptions
+  );
+}
+__name(createIntegrations, "createIntegrations");
+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);
+}
+__name(createClientSafeIntegrationAPI, "createClientSafeIntegrationAPI");
+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);
+}
+__name(getIntegrationAPIManifest, "getIntegrationAPIManifest");
+function integrationClients(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0) {
+    return createIntegrationClients();
+  }
+  return createIntegrationClients(
+    sources,
+    clientOptions,
+    serverOptions
+  );
+}
+__name(integrationClients, "integrationClients");
+function resolveSingleNamespaceOperation(api) {
+  const entries = Object.entries(api);
+  if (entries.length !== 1) {
+    return null;
+  }
+  const [, value] = entries[0];
+  return isOperation(value) ? value : null;
+}
+__name(resolveSingleNamespaceOperation, "resolveSingleNamespaceOperation");
+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);
+  };
+}
+__name(createClientOperationCaller, "createClientOperationCaller");
+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
+    );
+  };
+}
+__name(createServerOperationCaller, "createServerOperationCaller");
+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;
+    }
+  });
+}
+__name(createNamespaceProxy, "createNamespaceProxy");
+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;
+    }
+  });
+}
+__name(createServerNamespaceProxy, "createServerNamespaceProxy");
+
+// 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 _APIClientError extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "APIClientError";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+    this.response = options.response;
+  }
+};
+__name(_APIClientError, "APIClientError");
+var APIClientError = _APIClientError;
+function createAPIClient(options = {}) {
+  options ?? (options = {});
+  const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+  const integrationOptions = options.integrations === false ? false : {
+    baseURL: options.baseURL,
+    headers: options.headers,
+    credentials: options.credentials,
+    ...typeof options.integrations === "object" ? options.integrations : {}
+  };
+  const rootAliases = integrationOptions === false ? void 0 : {
+    integrations: integrationsClient(integrationOptions)
+  };
+  const cacheState = getFarmClientDataCache();
+  const inflightState = /* @__PURE__ */ new Map();
+  const routeMeta = /* @__PURE__ */ new WeakMap();
+  let requestCounter = 0;
+  const fetchClient = /* @__PURE__ */ __name(async (path, requestOptions = {}) => {
+    const url = new URL(path, baseURL);
+    if (requestOptions.query) {
+      Object.entries(requestOptions.query).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers,
+      ...requestOptions.headers
+    };
+    const fetchOptions = {
+      method: requestOptions.method || "GET",
+      headers
+    };
+    if (requestOptions.body !== void 0) {
+      if (isFormData(requestOptions.body)) {
+        deleteHeader(headers, "content-type");
+        fetchOptions.body = requestOptions.body;
+      } else {
+        fetchOptions.body = JSON.stringify(requestOptions.body);
+      }
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    applyFarmCacheInvalidations(
+      decodeFarmCacheInvalidations(response.headers?.get?.(FARM_CACHE_INVALIDATION_HEADER))
+    );
+    let data = void 0;
+    if (response.status !== 204 && response.status !== 205) {
+      data = isJSONStreamResponse(response) ? readJSONStream(response) : await response.json();
+    }
+    return { response, data };
+  }, "fetchClient");
+  const request = /* @__PURE__ */ __name(async (path, method, input = {}, clientOptions) => {
+    const methodUpper = method.toUpperCase();
+    const requestId = `${Date.now()}-${++requestCounter}`;
+    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)
+    );
+    const now = Date.now();
+    const emitStatus = /* @__PURE__ */ __name((phase, payload) => {
+      clientOptions?.onStatus?.({
+        phase,
+        requestId,
+        method: methodUpper,
+        key: cacheKey,
+        input,
+        timestamp: Date.now(),
+        ...payload
+      });
+    }, "emitStatus");
+    const entry = getValidCacheEntry(cacheState, cacheKey, now);
+    const policy = cacheOptions?.policy ?? (cacheOptions ? "cache-first" : "network-only");
+    const staleTime = cacheOptions?.staleTime ?? 0;
+    const isCacheEnabled = Boolean(cacheOptions) && methodUpper === "GET";
+    const isStale = entry ? isEntryStale(entry, now) : true;
+    const applyOptimisticUpdates = /* @__PURE__ */ __name(() => {
+      if (!clientOptions?.optimistic?.update?.length) return [];
+      const snapshots = [];
+      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);
+        if (!targetKey) continue;
+        const targetEntry = getValidCacheEntry(cacheState, targetKey, now);
+        const previousEntry = targetEntry ? { ...targetEntry } : void 0;
+        const previousData = targetEntry?.data;
+        const nextData = updater(previousData);
+        cacheState.set(targetKey, {
+          data: nextData,
+          updatedAt: now,
+          staleAt: targetEntry?.staleAt ?? now + (cacheOptions?.staleTime ?? options.cacheDefaults?.staleTime ?? 0),
+          gcAt: targetEntry?.gcAt ?? getGcAt(now, cacheOptions?.gcTime ?? options.cacheDefaults?.gcTime),
+          invalidatedAt: targetEntry?.invalidatedAt
+        });
+        snapshots.push({ key: targetKey, entry: previousEntry });
+      }
+      return snapshots;
+    }, "applyOptimisticUpdates");
+    const rollbackOptimisticUpdates = /* @__PURE__ */ __name((snapshots) => {
+      if (!clientOptions?.optimistic?.rollbackOnError) return;
+      for (const snapshot of snapshots) {
+        if (!snapshot.entry) {
+          cacheState.delete(snapshot.key);
+          continue;
+        }
+        cacheState.set(snapshot.key, { ...snapshot.entry });
+      }
+    }, "rollbackOptimisticUpdates");
+    const executeNetwork = /* @__PURE__ */ __name(async (opts) => {
+      const dedupeMs = cacheOptions?.dedupeMs ?? 0;
+      const inflight = inflightState.get(cacheKey);
+      const allowDedupe = isCacheEnabled && dedupeMs > 0;
+      if (allowDedupe && inflight && 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 });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onError?.(result2.error);
+          }
+        } else {
+          emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onSuccess?.(result2.data);
+          }
+        }
+        return result2;
+      }
+      emitStatus(opts?.isBackground ? "revalidating" : "pending", {
+        isBackground: opts?.isBackground
+      });
+      const promise = (async () => {
+        const maxRetries = Math.max(0, clientOptions?.retry?.count ?? 0);
+        let attempt = 0;
+        while (true) {
+          clientOptions?.onRequest?.({
+            requestId,
+            method: methodUpper,
+            key: cacheKey,
+            path,
+            input,
+            attempt,
+            timestamp: Date.now()
+          });
+          try {
+            const { response, data } = await fetchClient(path, {
+              ...input,
+              method: methodUpper
+            });
+            const error = response.ok ? null : createResponseError2(response, data);
+            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
+            };
+            clientOptions?.onResponse?.(response.ok ? data : void 0, error, responseEvent);
+            if (!error) {
+              return { data, error: null, key: cacheKey };
+            }
+            if (attempt >= maxRetries) {
+              return { data: void 0, error, key: cacheKey };
+            }
+          } catch (err) {
+            const error = normalizeError(err);
+            const responseEvent = {
+              requestId,
+              method: methodUpper,
+              key: cacheKey,
+              path,
+              input,
+              attempt,
+              timestamp: Date.now(),
+              error,
+              ok: false
+            };
+            clientOptions?.onResponse?.(void 0, error, responseEvent);
+            if (attempt >= maxRetries) {
+              return { data: void 0, error, key: cacheKey };
+            }
+          }
+          attempt += 1;
+          const delay = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
+          if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+      })();
+      inflightState.set(cacheKey, { promise, startedAt: now });
+      try {
+        const result2 = await promise;
+        if (!result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
+          const updatedAt = Date.now();
+          cacheState.set(cacheKey, {
+            data: result2.data,
+            updatedAt,
+            staleAt: updatedAt + staleTime,
+            gcAt: getGcAt(updatedAt, cacheOptions?.gcTime),
+            invalidatedAt: void 0
+          });
+        }
+        if (result2.error) {
+          emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onError?.(result2.error);
+          }
+        } else {
+          emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onSuccess?.(result2.data);
+          }
+        }
+        return result2;
+      } finally {
+        inflightState.delete(cacheKey);
+      }
+    }, "executeNetwork");
+    const invalidateTargets = /* @__PURE__ */ __name(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
+      };
+      for (const target of invalidateOptions.targets) {
+        const targetKey = resolveTargetKey(routeMeta, target, void 0, baseURL);
+        if (!targetKey) continue;
+        const existing = cacheState.get(targetKey);
+        if (existing) {
+          cacheState.set(targetKey, {
+            ...existing,
+            staleAt: 0,
+            invalidatedAt: Date.now()
+          });
+        }
+        emitStatus("invalidated", { key: targetKey });
+        if (invalidateOptions.refetch && existing && targetKey === cacheKey) {
+          void executeNetwork({ isBackground: true, callCallbacks: false });
+        }
+      }
+    }, "invalidateTargets");
+    const optimisticSnapshots = applyOptimisticUpdates();
+    if (isCacheEnabled) {
+      if (entry && !isStale && policy !== "network-only") {
+        emitStatus("success", { data: entry.data });
+        clientOptions?.onSuccess?.(entry.data);
+        clientOptions?.onSettled?.(entry.data, null);
+        return { data: entry.data, error: null, key: cacheKey };
+      }
+      if (entry && isStale && policy === "stale-while-revalidate") {
+        emitStatus("success", { data: entry.data });
+        clientOptions?.onSuccess?.(entry.data);
+        clientOptions?.onSettled?.(entry.data, null);
+        void executeNetwork({ isBackground: true, callCallbacks: false });
+        return { data: entry.data, error: null, key: cacheKey };
+      }
+    }
+    const result = await executeNetwork();
+    if (result.error) {
+      rollbackOptimisticUpdates(optimisticSnapshots);
+    }
+    await invalidateTargets();
+    clientOptions?.onSettled?.(result.data, result.error);
+    return result;
+  }, "request");
+  return createNestedProxy(
+    [],
+    request,
+    routeMeta,
+    baseURL,
+    options.baseURL === void 0,
+    rootAliases
+  );
+}
+__name(createAPIClient, "createAPIClient");
+function createNestedProxy(path, client, routeMeta, baseURL, sameOrigin, rootAliases) {
+  const target = /* @__PURE__ */ __name(() => {
+  }, "target");
+  const proxy = new Proxy(target, {
+    // When accessing a property (api.hello)
+    get(_target, prop) {
+      if (prop === FARM_API_ROUTE_REF_SYMBOL) {
+        return path.length > 0;
+      }
+      if (prop === FARM_API_ROUTE_META_SYMBOL) {
+        const metadata = resolveRouteMeta({ path, baseURL });
+        return Object.freeze({
+          path: metadata.routePath,
+          method: metadata.method,
+          baseURL,
+          sameOrigin
+        });
+      }
+      if (path.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
+        return rootAliases[prop];
+      }
+      if (typeof prop !== "string") {
+        return Reflect.get(_target, prop);
+      }
+      return createNestedProxy(
+        [...path, prop],
+        client,
+        routeMeta,
+        baseURL,
+        sameOrigin,
+        rootAliases
+      );
+    },
+    // When calling as a function
+    apply(_target, _thisArg, args) {
+      const lastPart = path[path.length - 1];
+      const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
+      if (httpMethods.includes(lastPart)) {
+        const routePath = "/api/" + path.slice(0, -1).join("/");
+        const method = lastPart.toUpperCase();
+        const [options, clientOptions] = args;
+        return client(routePath, method, options, clientOptions);
+      } else {
+        const routePath = "/api/" + path.join("/");
+        const [options, clientOptions] = args;
+        return client(routePath, options?.method || "GET", options, clientOptions);
+      }
+    }
+  });
+  routeMeta.set(proxy, { path: [...path], baseURL });
+  return proxy;
+}
+__name(createNestedProxy, "createNestedProxy");
+function isAPIRouteRef(value) {
+  return typeof value === "function" && value[FARM_API_ROUTE_REF_SYMBOL] === true;
+}
+__name(isAPIRouteRef, "isAPIRouteRef");
+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
+  };
+}
+__name(getAPIRouteRefMetadata, "getAPIRouteRefMetadata");
+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;
+}
+__name(createServerAPIClient, "createServerAPIClient");
+function buildCacheKey(method, path, input, baseURL) {
+  const keyInput = input && typeof input === "object" ? { query: input.query, body: input.body } : input;
+  const url = new URL(path, baseURL);
+  return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
+}
+__name(buildCacheKey, "buildCacheKey");
+function stableStringify(value) {
+  if (value === null || value === void 0) return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+__name(stableStringify, "stableStringify");
+function getGcAt(now, gcTime) {
+  if (gcTime === void 0) return void 0;
+  if (!Number.isFinite(gcTime) || gcTime <= 0) return now;
+  return now + gcTime;
+}
+__name(getGcAt, "getGcAt");
+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;
+}
+__name(getValidCacheEntry, "getValidCacheEntry");
+function isEntryStale(entry, now) {
+  if (entry.invalidatedAt !== void 0) return true;
+  return now >= entry.staleAt;
+}
+__name(isEntryStale, "isEntryStale");
+function resolveTargetKey(routeMeta, target, input, baseURL = "http://localhost:3000") {
+  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);
+    return buildCacheKey(method, routePath, input ?? {}, meta.baseURL);
+  }
+  if (Array.isArray(target)) {
+    const [route, routeInput] = target;
+    if (typeof route === "function") {
+      return resolveTargetKey(routeMeta, route, routeInput, baseURL);
+    }
+    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);
+  }
+  return null;
+}
+__name(resolveTargetKey, "resolveTargetKey");
+function resolveRouteMeta(meta) {
+  const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
+  const lastPart = meta.path[meta.path.length - 1];
+  if (lastPart && httpMethods.includes(lastPart)) {
+    return {
+      routePath: "/api/" + meta.path.slice(0, -1).join("/"),
+      method: lastPart.toUpperCase()
+    };
+  }
+  return {
+    routePath: "/api/" + meta.path.join("/"),
+    method: "GET"
+  };
+}
+__name(resolveRouteMeta, "resolveRouteMeta");
+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;
+}
+__name(normalizeError, "normalizeError");
+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");
+}
+__name(isFormData, "isFormData");
+function deleteHeader(headers, name) {
+  const normalized = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === normalized) delete headers[key];
+  }
+}
+__name(deleteHeader, "deleteHeader");
+function createResponseError2(response, data) {
+  const expected = readEndpointErrorEnvelope(data);
+  if (expected) {
+    return new APIClientError(expected.code, expected.data, {
+      status: response.status,
+      message: expected.message,
+      response
+    });
+  }
+  return new APIClientError("http_error", data, {
+    status: response.status,
+    message: `HTTP ${response.status}: ${response.statusText}`,
+    response
+  });
+}
+__name(createResponseError2, "createResponseError");
+function readEndpointErrorEnvelope(data) {
+  if (!data || typeof data !== "object") return null;
+  const error = data.error;
+  if (!error || typeof error !== "object") return null;
+  const code = error.code;
+  const message = error.message;
+  if (typeof code !== "string" || typeof message !== "string") return null;
+  return {
+    code,
+    message,
+    data: error.data
+  };
+}
+__name(readEndpointErrorEnvelope, "readEndpointErrorEnvelope");
+
+export {
+  IntegrationClientError,
+  createIntegrationClient,
+  integrationsClient,
+  integrationsServer,
+  createIntegrationServerClient,
+  createIntegrationApi,
+  createIntegrationClients,
+  createIntegrations,
+  getIntegrationAPIManifest,
+  integrationClients,
+  FARM_API_ROUTE_REF_SYMBOL,
+  FARM_API_ROUTE_META_SYMBOL,
+  APIClientError,
+  createAPIClient,
+  isAPIRouteRef,
+  getAPIRouteRefMetadata,
+  createServerAPIClient
+};
+//# sourceMappingURL=chunk-W2CRQFF6.mjs.map