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

package/dist/chunk-W2CRQFF6.mjs

@@ -1,1352 +0,0 @@
-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