@farm.js/core 0.1.16 → 0.1.18

package/dist/api/client.cjs

@@ -1,4035 +1,26 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/api-client.ts
-var api_client_exports = {};
-__export(api_client_exports, {
-  APIClientError: () => APIClientError,
-  createAPIClient: () => createAPIClient,
-  createApiClients: () => createApiClients,
-  createServerAPIClient: () => createServerAPIClient
-});
-module.exports = __toCommonJS(api_client_exports);
 
-// src/api/config.ts
-var DEFAULT_FARM_API_BASE_PATH = "/api";
-function getFarmAPIBaseURL() {
-  if (typeof __FARM_API_BASE_URL__ !== "undefined" && __FARM_API_BASE_URL__) {
-    return __FARM_API_BASE_URL__;
-  }
-  return DEFAULT_FARM_API_BASE_PATH;
-}
-__name(getFarmAPIBaseURL, "getFarmAPIBaseURL");
-function resolveFarmAPIRequestURL(routePath, baseURL = getFarmAPIBaseURL(), fallbackOrigin = getDefaultOrigin()) {
-  const base = new URL(baseURL, fallbackOrigin);
-  if (base.pathname === "/") {
-    return new URL(routePath, base);
-  }
-  const route = new URL(routePath, fallbackOrigin);
-  const suffix = stripCanonicalAPIBasePath(route.pathname);
-  const joinedPath = joinURLPath(base.pathname, suffix);
-  base.pathname = joinedPath;
-  base.search = route.search;
-  base.hash = route.hash;
-  return base;
-}
-__name(resolveFarmAPIRequestURL, "resolveFarmAPIRequestURL");
-function stripCanonicalAPIBasePath(pathname) {
-  if (pathname === DEFAULT_FARM_API_BASE_PATH) return "";
-  if (pathname.startsWith(`${DEFAULT_FARM_API_BASE_PATH}/`)) {
-    return pathname.slice(DEFAULT_FARM_API_BASE_PATH.length + 1);
-  }
-  return pathname.replace(/^\/+/, "");
-}
-__name(stripCanonicalAPIBasePath, "stripCanonicalAPIBasePath");
-function joinURLPath(basePath, suffix) {
-  const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/+$/, "");
-  const normalizedSuffix = suffix.replace(/^\/+/, "");
-  if (!normalizedSuffix) return normalizedBase || "/";
-  return `${normalizedBase}/${normalizedSuffix}`;
-}
-__name(joinURLPath, "joinURLPath");
-function getDefaultOrigin() {
-  return typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
-}
-__name(getDefaultOrigin, "getDefaultOrigin");
 
-// src/client-headers.ts
-function resolveClientHeaders(source) {
-  const value = typeof source === "function" ? source() : source;
-  if (value && typeof value.then === "function") {
-    return Promise.resolve(value).then((headers) => new Headers(headers));
-  }
-  return new Headers(value);
-}
-__name(resolveClientHeaders, "resolveClientHeaders");
 
-// src/client-cancellation.ts
-function createClientCancellation(signal, timeoutMs = 0, parent) {
-  let timer;
-  let invalid;
-  let timeoutReason;
-  const signals = [signal, parent].filter((value) => !!value);
-  if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647) {
-    invalid = new RangeError(
-      "timeoutMs must be an integer between 0 and 2147483647 (0 disables the deadline)."
-    );
-  } else if (timeoutMs > 0) {
-    const controller = new AbortController();
-    signals.push(controller.signal);
-    timer = setTimeout(() => {
-      timeoutReason = new DOMException("Client request timed out", "TimeoutError");
-      controller.abort(timeoutReason);
-    }, timeoutMs);
-  }
-  const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
-  let active = 0;
-  let closed = false;
-  const cleanup = /* @__PURE__ */ __name(() => {
-    if (closed && active === 0 && timer !== void 0) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-  }, "cleanup");
-  const check = /* @__PURE__ */ __name(() => {
-    if (invalid) throw invalid;
-    combined?.throwIfAborted();
-  }, "check");
-  return {
-    signal: combined,
-    get timedOut() {
-      return timeoutReason !== void 0 && combined?.reason === timeoutReason;
-    },
-    check,
-    hold() {
-      active++;
-      return () => {
-        active--;
-        cleanup();
-      };
-    },
-    // A race also bounds cooperative local dispatch and custom HTTP implementations.
-    // Late completion is consumed, but cannot turn a cancelled result into success.
-    async run(work) {
-      check();
-      active++;
-      let abort;
-      try {
-        if (!combined) return await work();
-        return await new Promise((resolve, reject) => {
-          abort = /* @__PURE__ */ __name(() => reject(combined.reason), "abort");
-          combined.addEventListener("abort", abort, { once: true });
-          Promise.resolve().then(() => {
-            check();
-            return work();
-          }).then(resolve, reject);
-        });
-      } finally {
-        if (abort) combined?.removeEventListener("abort", abort);
-        active--;
-        cleanup();
-      }
-    },
-    async delay(ms) {
-      let retryTimer;
-      try {
-        await this.run(
-          () => new Promise((resolve) => {
-            retryTimer = setTimeout(resolve, ms);
-          })
-        );
-      } finally {
-        if (retryTimer !== void 0) clearTimeout(retryTimer);
-      }
-    },
-    dispose() {
-      closed = true;
-      cleanup();
-    }
-  };
-}
-__name(createClientCancellation, "createClientCancellation");
+var _chunkIXTFU4PLcjs = require('../chunk-IXTFU4PL.cjs');
+require('../chunk-LTNGXMQ6.cjs');
+require('../chunk-I7PUUDGY.cjs');
+require('../chunk-J7FSKED3.cjs');
+require('../chunk-72ADZ6GQ.cjs');
+require('../chunk-G7HXGLEC.cjs');
+require('../chunk-ARJWXNQL.cjs');
+require('../chunk-S3A45T7F.cjs');
+require('../chunk-H6G5INWM.cjs');
+require('../chunk-ZEG3OPIB.cjs');
+require('../chunk-LIUGYUX3.cjs');
+require('../chunk-E3UK5IIB.cjs');
+require('../chunk-U4KT7QP3.cjs');
+require('../chunk-NO3WWW3N.cjs');
+require('../chunk-S3JO3N4H.cjs');
 
-// src/client-observers.ts
-function notifyClientObserver(observer, args, label = "Client lifecycle") {
-  if (!observer) return;
-  const report = /* @__PURE__ */ __name((error) => {
-    const reportError = globalThis.reportError;
-    if (typeof reportError === "function") {
-      try {
-        reportError.call(globalThis, error);
-        return;
-      } catch {
-      }
-    }
-    try {
-      console.error(`[Farm.js] ${label} callback failed:`, error);
-    } catch {
-    }
-  }, "report");
-  try {
-    const result = observer(...args);
-    if (result && typeof result.then === "function")
-      void Promise.resolve(result).catch(report);
-  } catch (error) {
-    report(error);
-  }
-}
-__name(notifyClientObserver, "notifyClientObserver");
 
-// src/integration-client.ts
-var _IntegrationClientError = class _IntegrationClientError extends Error {
-  constructor(message, response, data) {
-    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 globalState2 = globalThis;
-  return globalState2[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, runtime3]) => [
-      key,
-      runtime3.integration
-    ])
-  );
-}
-__name(getRegisteredIntegrationsLocal, "getRegisteredIntegrationsLocal");
-function resolveCurrentRequestLocal() {
-  const globalState2 = globalThis;
-  return globalState2[CURRENT_REQUEST_RESOLVER_KEY]?.();
-}
-__name(resolveCurrentRequestLocal, "resolveCurrentRequestLocal");
-function resolveIntegrationRequestDispatcherLocal() {
-  const globalState2 = globalThis;
-  return globalState2[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 globalState2 = globalThis;
-  const manifest = globalState2.window?.__FARM_INTEGRATION_API_MANIFEST__ || globalState2.__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");
-function createOperationBody(operation, body, headers) {
-  const requestBody = createBody(operation.bodyFormat, body, headers);
-  if (operation.method === "QUERY" && requestBody === void 0 && !headers.has("content-type")) {
-    headers.set(
-      "content-type",
-      operation.bodyFormat === "form" ? "application/x-www-form-urlencoded;charset=UTF-8" : "application/json"
-    );
-  }
-  return requestBody;
-}
-__name(createOperationBody, "createOperationBody");
-async function parseResponseData(response) {
-  if (response.status === 204 || response.status === 205) {
-    return void 0;
-  }
-  const contentType = response.headers.get("content-type") || "";
-  if (isJSONMediaType(contentType)) {
-    return await response.json();
-  }
-  return await response.text();
-}
-__name(parseResponseData, "parseResponseData");
-function isJSONMediaType(contentType) {
-  const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
-  return mediaType === "application/json" || mediaType.endsWith("+json");
-}
-__name(isJSONMediaType, "isJSONMediaType");
-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");
-var integrationRequestCounter = 0;
-var noIntegrationObservers = {
-  response(_response) {
-  },
-  finish(result) {
-    return result;
-  }
-};
-function createIntegrationObservers(operation, options, requestOptions) {
-  if (!options.onRequest && !options.onResponse && !options.onError && !requestOptions?.onRequest && !requestOptions?.onResponse && !requestOptions?.onError) {
-    return noIntegrationObservers;
-  }
-  const requestEvent = {
-    requestId: `integration-${Date.now()}-${++integrationRequestCounter}`,
-    method: operation.method,
-    path: operation.path ?? "",
-    attempt: 0,
-    timestamp: Date.now()
-  };
-  let response;
-  notifyClientObserver(options.onRequest, [requestEvent]);
-  notifyClientObserver(requestOptions?.onRequest, [requestEvent]);
-  return {
-    response(value) {
-      response = value;
-    },
-    finish(result) {
-      const data = result.error ? void 0 : result.data;
-      const event = {
-        ...requestEvent,
-        timestamp: Date.now(),
-        response,
-        data,
-        error: result.error ?? void 0,
-        ok: !result.error,
-        status: response?.status
-      };
-      notifyClientObserver(options.onResponse, [data, result.error, event]);
-      notifyClientObserver(requestOptions?.onResponse, [data, result.error, event]);
-      if (result.error) {
-        notifyClientObserver(options.onError, [result.error]);
-        notifyClientObserver(requestOptions?.onError, [result.error]);
-      }
-      return result;
-    }
-  };
-}
-__name(createIntegrationObservers, "createIntegrationObservers");
-async function executeClientOperation(operation, input, options, requestOptions) {
-  const cancellation = createClientCancellation(
-    requestOptions?.signal,
-    requestOptions?.timeoutMs ?? options.timeoutMs
-  );
-  const observers = createIntegrationObservers(operation, options, requestOptions);
-  try {
-    const result = await cancellation.run(async () => {
-      if (!operation.path) {
-        return {
-          data: null,
-          error: new Error(
-            "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
-          )
-        };
-      }
-      const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
-      const url = resolveFarmAPIRequestURL(operation.path, baseURL);
-      appendQuery(url, input.query);
-      const resolved = resolveClientHeaders(options.headers);
-      const headers = resolved instanceof Headers ? resolved : await resolved;
-      cancellation.check();
-      appendHeaders(headers, operation.headers);
-      appendHeaders(headers, requestOptions?.headers);
-      headers.set("x-farm-integration-client", "1");
-      if (operation.responseFormat !== "response") {
-        headers.set("accept", "application/json");
-      }
-      appendIntegrationClientDataHeader(
-        headers,
-        mergeIntegrationClientData(options.data, requestOptions?.data)
-      );
-      const body = createOperationBody(operation, input.body, headers);
-      const response = await (options.fetch ?? fetch)(url.toString(), {
-        method: operation.method,
-        headers,
-        body,
-        credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
-        signal: cancellation.signal
-      });
-      cancellation.check();
-      observers.response(response);
-      if (!response.ok) {
-        const errorData = await safeParseResponseData(response);
-        return {
-          data: null,
-          error: createResponseError(response, errorData)
-        };
-      }
-      if (operation.responseFormat === "response") {
-        return {
-          data: response,
-          error: null
-        };
-      }
-      return {
-        data: await parseResponseData(response),
-        error: null
-      };
-    });
-    return observers.finish(result);
-  } catch (error) {
-    return observers.finish({
-      data: null,
-      error: normalizeExecutionError(error)
-    });
-  } finally {
-    cancellation.dispose();
-  }
-}
-__name(executeClientOperation, "executeClientOperation");
-async function executeServerOperation(operation, input, options, requestOptions, integrationKey, source) {
-  const currentRequest = requestOptions?.request instanceof Request ? requestOptions.request : options.request instanceof Request ? options.request : resolveCurrentRequestLocal();
-  const cancellation = createClientCancellation(
-    requestOptions?.signal,
-    requestOptions?.timeoutMs ?? options.timeoutMs,
-    currentRequest?.signal
-  );
-  const observers = createIntegrationObservers(operation, options, requestOptions);
-  try {
-    const result = await cancellation.run(async () => {
-      if (!operation.path) {
-        return {
-          data: null,
-          error: new Error(
-            "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
-          )
-        };
-      }
-      const serverRequestOptions = requestOptions && ("request" in requestOptions || "baseURL" in requestOptions || "forwardHeaders" in requestOptions) ? requestOptions : void 0;
-      const request = resolveRequestLike(
-        serverRequestOptions?.request ?? options.request ?? currentRequest
-      );
-      const baseURL = resolveServerBaseURL(
-        serverRequestOptions?.baseURL ?? options.baseURL,
-        request
-      );
-      const origin = resolveServerBaseURL(void 0, request);
-      const url = new URL(operation.path, new URL(baseURL, origin));
-      appendQuery(url, input.query);
-      const headers = new Headers();
-      appendHeaders(
-        headers,
-        resolveForwardHeaders(
-          request,
-          serverRequestOptions?.forwardHeaders ?? options.forwardHeaders
-        )
-      );
-      const resolved = resolveClientHeaders(options.headers);
-      appendHeaders(headers, resolved instanceof Headers ? resolved : await resolved);
-      cancellation.check();
-      appendHeaders(headers, operation.headers);
-      appendHeaders(headers, requestOptions?.headers);
-      headers.set("x-farm-integration-client", "1");
-      if (operation.responseFormat !== "response") {
-        headers.set("accept", "application/json");
-      }
-      const data = mergeIntegrationClientData(options.data, requestOptions?.data);
-      if (integrationKey) {
-        const runtime3 = "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 (runtime3) {
-          const dispatchIntegrationRequest = resolveIntegrationRequestDispatcherLocal();
-          const body2 = createOperationBody(operation, input.body, headers);
-          const directResponse = dispatchIntegrationRequest ? await dispatchIntegrationRequest(
-            runtime3,
-            new Request(url.toString(), {
-              method: operation.method,
-              headers,
-              body: body2,
-              signal: cancellation.signal
-            }),
-            {
-              currentRequest,
-              data,
-              internal: true
-            }
-          ) : null;
-          cancellation.check();
-          if (directResponse) {
-            observers.response(directResponse);
-            return await finalizeOperationResponse(operation, directResponse);
-          }
-        }
-      }
-      appendIntegrationClientDataHeader(headers, data);
-      const body = createOperationBody(operation, input.body, headers);
-      const httpURL = resolveFarmAPIRequestURL(operation.path, baseURL, origin);
-      appendQuery(httpURL, input.query);
-      const response = await (options.fetch ?? fetch)(httpURL.toString(), {
-        method: operation.method,
-        headers,
-        body,
-        credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
-        signal: cancellation.signal
-      });
-      cancellation.check();
-      observers.response(response);
-      return await finalizeOperationResponse(operation, response);
-    });
-    return observers.finish(result);
-  } catch (error) {
-    return observers.finish({
-      data: null,
-      error: normalizeExecutionError(error)
-    });
-  } finally {
-    cancellation.dispose();
-  }
-}
-__name(executeServerOperation, "executeServerOperation");
-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 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/tracing.ts
-var import_api = require("@opentelemetry/api");
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = import_api.context.active();
-  const activeSpan = import_api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = import_api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: import_api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!(0, import_api.isSpanContextValid)(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
 
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-});
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    try {
-      Promise.resolve(handler(event)).catch((error) => {
-        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-      });
-    } catch (error) {
-      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-function shouldEmitFarmEvent(event) {
-  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
-    return false;
-  }
-  if (observabilityState.events && !observabilityState.events.has(event.type)) {
-    return false;
-  }
-  return true;
-}
-__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-function inferFarmEventLevel(type) {
-  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
-    return "error";
-  }
-  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
-    return "warn";
-  }
-  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
-    return "debug";
-  }
-  return "info";
-}
-__name(inferFarmEventLevel, "inferFarmEventLevel");
-function logFarmEvent(event) {
-  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
-  switch (event.level) {
-    case "error":
-      console.error(message);
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      console.log(message);
-      break;
-  }
-}
-__name(logFarmEvent, "logFarmEvent");
-function formatFarmEventDetails(event) {
-  const details = [];
-  const record = event;
-  for (const key of [
-    "route",
-    "pathname",
-    "method",
-    "status",
-    "key",
-    "tag",
-    "path",
-    "reason",
-    "durationMs",
-    "integration",
-    "server",
-    "tool",
-    "outcome",
-    "operation",
-    "plugin",
-    "hook",
-    "target",
-    "count"
-  ]) {
-    const value = record[key];
-    if (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-__name(formatFarmEventDetails, "formatFarmEventDetails");
-function formatDetailValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-__name(formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(formatError, "formatError");
 
-// src/cache-invalidation.ts
-var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
-var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
-var globalState = globalThis;
-function getFarmCacheInvalidationState() {
-  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set(),
-    taskListeners: /* @__PURE__ */ new Set()
-  });
-}
-__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
-function warnFarmCacheListenerError(scope, error) {
-  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
-  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
-}
-__name(warnFarmCacheListenerError, "warnFarmCacheListenerError");
-function notifyFarmCacheInvalidation(key, source = "local") {
-  if (typeof key !== "string" || key.length === 0) return;
-  for (const listener of getFarmCacheInvalidationState().listeners) {
-    try {
-      listener(key, source);
-    } catch (error) {
-      warnFarmCacheListenerError("invalidation", error);
-    }
-  }
-}
-__name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
-function applyFarmCacheInvalidations(keys, source = "local") {
-  if (!Array.isArray(keys)) return;
-  for (const key of keys) {
-    if (typeof key === "string") {
-      notifyFarmCacheInvalidation(key, source);
-    }
-  }
-}
-__name(applyFarmCacheInvalidations, "applyFarmCacheInvalidations");
-function decodeFarmCacheInvalidations(value) {
-  if (!value) return [];
-  try {
-    const parsed = JSON.parse(decodeURIComponent(value));
-    return Array.isArray(parsed) ? Array.from(
-      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
-    ) : [];
-  } catch {
-    return [];
-  }
-}
-__name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
-function subscribeFarmCacheInvalidation(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.listeners.add(listener);
-  return () => state.listeners.delete(listener);
-}
-__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
-
-// src/cache-invalidation-stream.ts
-var MAX_BUFFERED_BYTES = 64 * 1024;
-var textEncoder = new TextEncoder();
-
-// src/cache.ts
-var _FarmDataCache = class _FarmDataCache {
-  constructor(config = {}) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
-    this.activeGenerations = /* @__PURE__ */ new Set();
-    this.version = 0;
-    this.generation = 0;
-    this.namespace = "farm";
-    this.local = true;
-    this.maxEntries = 1024;
-    this.lease = {
-      enabled: true,
-      ttlMs: 1e4,
-      waitTimeoutMs: 1e4,
-      pollIntervalMs: 25
-    };
-    this.configure(config);
-  }
-  configure(config = {}) {
-    this.generation++;
-    this.entries.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    this.adapter = config.adapter;
-    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
-    this.local = !config.adapter;
-    this.maxEntries = normalizePositiveInteger(config.maxEntries, 1024, "cache.maxEntries");
-    this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
-      enabled: true,
-      ttlMs: normalizePositiveDuration(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
-      waitTimeoutMs: normalizePositiveDuration(
-        config.lease?.waitTimeoutMs,
-        1e4,
-        "cache.lease.waitTimeoutMs"
-      ),
-      pollIntervalMs: normalizePositiveDuration(
-        config.lease?.pollIntervalMs,
-        25,
-        "cache.lease.pollIntervalMs"
-      )
-    };
-  }
-  get adapterName() {
-    return this.adapter?.name || (this.adapter ? "custom" : "memory");
-  }
-  get hasAdapter() {
-    return this.adapter !== void 0;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  get(key, options = {}) {
-    return this.getEntry(key, options)?.value;
-  }
-  getEntry(key, options = {}) {
-    const entry = this.entries.get(key);
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    const stale = this.isStale(entry, options.now);
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: Array.from(entry.tags),
-        revalidate: entry.revalidate
-      });
-    }
-    if (!options.allowStale && stale) {
-      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      return void 0;
-    }
-    this.touchEntry(key, entry);
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: Array.from(entry.tags),
-      revalidate: entry.revalidate,
-      stale
-    });
-    return this.toPublicEntry(entry);
-  }
-  async getEntryAsync(key, options = {}) {
-    if (this.local) {
-      const localEntry = this.getEntry(key, options);
-      if (localEntry) return localEntry;
-    }
-    if (!this.adapter) {
-      return this.local ? void 0 : this.getEntry(key, options);
-    }
-    const generation = this.generation;
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const entry = await adapter.get(`${namespace}:entry:${key}`);
-    if (generation !== this.generation) return void 0;
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    const stale = await this.isAdapterEntryStale(entry, options.now, adapter, namespace);
-    if (generation !== this.generation) return void 0;
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: [...entry.tags],
-        revalidate: entry.revalidate
-      });
-      if (!options.allowStale) {
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-        return void 0;
-      }
-    }
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate,
-      stale
-    });
-    if (this.local && !stale) {
-      this.hydrateLocalEntry(entry);
-    }
-    return { ...entry, key };
-  }
-  set(key, value, options = {}) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    const tags = /* @__PURE__ */ new Set();
-    for (const tag of options.tags ?? []) {
-      tags.add(normalizeCacheTag(tag));
-    }
-    for (const routePath of options.paths ?? []) {
-      tags.add(createPathCacheTag(routePath));
-    }
-    const entry = {
-      key,
-      value,
-      tags,
-      tagVersions: void 0,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: ++this.version,
-      revalidate
-    };
-    this.storeLocalEntry(entry);
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: Array.from(tags),
-      revalidate: entry.revalidate
-    });
-    return this.toPublicEntry(entry);
-  }
-  async setAsync(key, value, options = {}, tagVersions) {
-    return this.writeAsync(key, value, options, tagVersions);
-  }
-  async writeAsync(key, value, options, tagVersions, createdVersion) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    const tags = normalizeCacheOptionsTags(options);
-    const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
-    const entry = {
-      key,
-      value,
-      tags: Array.from(tags),
-      tagVersions: capturedVersions,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: createdVersion ?? ++this.version,
-      revalidate
-    };
-    if (this.local) {
-      this.hydrateLocalEntry(entry);
-    }
-    if (this.adapter) {
-      await this.adapter.set(this.createAdapterKey(key), entry);
-    }
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate
-    });
-    return entry;
-  }
-  delete(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
-    emitFarmEvent({ type: "cache.delete", key, deleted });
-    return deleted;
-  }
-  async deleteAsync(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
-    if (this.adapter) {
-      await this.adapter.delete(this.createAdapterKey(key));
-    }
-    emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
-    return this.adapter ? true : deleted;
-  }
-  clear() {
-    const count = this.entries.size;
-    this.generation++;
-    this.entries.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    emitFarmEvent({ type: "cache.clear", count });
-  }
-  async clearAsync() {
-    this.clear();
-    await this.adapter?.clear?.();
-  }
-  isStale(entry, now = Date.now()) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    for (const tag of entry.tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
-      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async isStaleAsync(entry, now = Date.now()) {
-    if (this.adapter) {
-      return this.isAdapterEntryStale(entry, now);
-    }
-    return this.isStale(entry, now);
-  }
-  revalidateTag(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  async revalidateTagAsync(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  revalidatePath(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async revalidatePathAsync(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async getOrSet(key, producer, options = {}) {
-    normalizeRevalidate(options.revalidate);
-    const cached = await this.getEntryAsync(key);
-    if (cached) {
-      return cached.value;
-    }
-    const inflight = this.inflight.get(key);
-    if (inflight) {
-      emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight;
-    }
-    const tags = Array.from(normalizeCacheOptionsTags(options));
-    const generation = this.generation;
-    const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      if (this.inflight.get(key) === promise) {
-        this.inflight.delete(key);
-      }
-    });
-    this.inflight.set(key, promise);
-    return promise;
-  }
-  async fillCacheEntry(key, producer, options, tags, generation) {
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const lease = { ...this.lease };
-    const leaseKey = `${namespace}:lease:${key}`;
-    let leaseToken;
-    if (adapter?.acquireLease && adapter.releaseLease && lease.enabled) {
-      leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-      if (!leaseToken) {
-        const shared2 = await this.waitForAdapterEntry(
-          key,
-          adapter,
-          namespace,
-          lease,
-          generation
-        );
-        if (shared2) {
-          emitFarmEvent({ type: "cache.dedupe", key });
-          return shared2.value;
-        }
-        if (generation === this.generation) {
-          leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-        }
-      }
-    }
-    const initialCreatedVersion = this.version;
-    const activeGeneration = {
-      tags: new Set(tags),
-      createdVersion: initialCreatedVersion
-    };
-    this.activeGenerations.add(activeGeneration);
-    try {
-      const initialTagVersions = await this.getAdapterTagVersions(tags, adapter, namespace);
-      const value = await producer();
-      if (generation === this.generation) {
-        await this.writeAsync(key, value, options, initialTagVersions, initialCreatedVersion);
-      }
-      return value;
-    } finally {
-      this.activeGenerations.delete(activeGeneration);
-      this.pruneInvalidatedTagVersions();
-      if (leaseToken && adapter?.releaseLease) {
-        try {
-          await adapter.releaseLease(leaseKey, leaseToken);
-        } catch (error) {
-          emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-        }
-      }
-    }
-  }
-  async waitForAdapterEntry(key, adapter, namespace, lease, generation) {
-    const deadline = Date.now() + lease.waitTimeoutMs;
-    while (Date.now() < deadline) {
-      await delay(lease.pollIntervalMs);
-      if (generation !== this.generation) return void 0;
-      const entry = await adapter.get(`${namespace}:entry:${key}`);
-      if (generation !== this.generation) return void 0;
-      if (!entry) {
-        emitFarmEvent({ type: "cache.miss", key });
-        continue;
-      }
-      assertFarmCacheEntry(entry, key);
-      const stale = await this.isAdapterEntryStale(entry, Date.now(), adapter, namespace);
-      if (generation !== this.generation) return void 0;
-      if (stale) {
-        emitFarmEvent({
-          type: "cache.stale",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate
-        });
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      } else {
-        emitFarmEvent({
-          type: "cache.hit",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate,
-          stale: false
-        });
-        return { ...entry, key };
-      }
-    }
-    return void 0;
-  }
-  countEntriesForTag(tag) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (entry.tags.has(tag)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  countEntriesForTags(tags) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (tags.every((tag) => entry.tags.has(tag))) {
-        count++;
-      }
-    }
-    return count;
-  }
-  invalidateTag(normalizedTag) {
-    const count = this.countEntriesForTag(normalizedTag);
-    this.invalidatedTagVersions.delete(normalizedTag);
-    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    this.pruneInvalidatedTagVersions();
-    return count;
-  }
-  toPublicEntry(entry) {
-    return {
-      key: entry.key,
-      value: entry.value,
-      tags: Array.from(entry.tags),
-      tagVersions: entry.tagVersions,
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion,
-      revalidate: entry.revalidate
-    };
-  }
-  hydrateLocalEntry(entry) {
-    this.storeLocalEntry({
-      key: entry.key,
-      value: entry.value,
-      tags: new Set(entry.tags.map(normalizeCacheTag)),
-      tagVersions: entry.tagVersions,
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion ?? ++this.version,
-      revalidate: normalizeRevalidate(entry.revalidate)
-    });
-  }
-  touchEntry(key, entry) {
-    this.entries.delete(key);
-    this.entries.set(key, entry);
-  }
-  storeLocalEntry(entry) {
-    this.entries.delete(entry.key);
-    this.entries.set(entry.key, entry);
-    while (this.entries.size > this.maxEntries) {
-      const oldestKey = this.entries.keys().next().value;
-      if (oldestKey === void 0) break;
-      this.entries.delete(oldestKey);
-    }
-    this.pruneInvalidatedTagVersions();
-  }
-  pruneInvalidatedTagVersions() {
-    tags: for (const [tag, invalidatedVersion] of this.invalidatedTagVersions) {
-      for (const entry of this.entries.values()) {
-        if (entry.tags.has(tag) && entry.createdVersion < invalidatedVersion) continue tags;
-      }
-      for (const generation of this.activeGenerations) {
-        if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)
-          continue tags;
-      }
-      this.invalidatedTagVersions.delete(tag);
-    }
-  }
-  createAdapterKey(key) {
-    return `${this.namespace}:entry:${key}`;
-  }
-  createAdapterTag(tag) {
-    return `${this.namespace}:tag:${tag}`;
-  }
-  async getAdapterTagVersions(tags, adapter = this.adapter, namespace = this.namespace) {
-    if (!adapter?.getTagVersions || tags.length === 0) return {};
-    const normalized = tags.map(normalizeCacheTag);
-    const physicalTags = normalized.map((tag) => `${namespace}:tag:${tag}`);
-    const versions = await adapter.getTagVersions(physicalTags);
-    return Object.fromEntries(
-      normalized.map((tag, index) => [
-        tag,
-        normalizeAdapterVersion(versions[physicalTags[index]])
-      ])
-    );
-  }
-  async isAdapterEntryStale(entry, now = Date.now(), adapter = this.adapter, namespace = this.namespace) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    const currentVersions = await this.getAdapterTagVersions(entry.tags, adapter, namespace);
-    for (const tag of entry.tags) {
-      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-__name(_FarmDataCache, "FarmDataCache");
-var FarmDataCache = _FarmDataCache;
-var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
-var farmDataCacheGlobal = globalThis;
-var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
-function createPathCacheTag(routePath) {
-  return `path:${normalizeRevalidatePath(routePath)}`;
-}
-__name(createPathCacheTag, "createPathCacheTag");
-function createRouteDataCacheKey(key) {
-  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
-}
-__name(createRouteDataCacheKey, "createRouteDataCacheKey");
-function normalizeRevalidatePath(routePath) {
-  if (typeof routePath !== "string") {
-    throw new TypeError("revalidatePath expects a path string.");
-  }
-  let normalized = routePath.trim();
-  if (!normalized) {
-    throw new Error("revalidatePath expects a non-empty path.");
-  }
-  try {
-    if (/^https?:\/\//i.test(normalized)) {
-      normalized = new URL(normalized).pathname;
-    }
-  } catch {
-  }
-  normalized = normalized.split(/[?#]/, 1)[0] ?? normalized;
-  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  normalized = normalized.replace(/\/{2,}/g, "/");
-  normalized = new URL(normalized, "http://farm.invalid").pathname;
-  if (normalized.length > 1) {
-    normalized = normalized.replace(/\/+$/, "");
-  }
-  return normalized || "/";
-}
-__name(normalizeRevalidatePath, "normalizeRevalidatePath");
-function createFarmCacheKey(parts) {
-  return stableSerialize(parts);
-}
-__name(createFarmCacheKey, "createFarmCacheKey");
-function normalizeRevalidate(revalidate) {
-  if (revalidate === false || revalidate === void 0) {
-    return revalidate;
-  }
-  if (!Number.isFinite(revalidate) || revalidate < 0) {
-    throw new TypeError("Cache revalidate must be false or a finite, non-negative number.");
-  }
-  return revalidate;
-}
-__name(normalizeRevalidate, "normalizeRevalidate");
-function normalizeCacheTag(tag) {
-  if (typeof tag !== "string") {
-    throw new TypeError("Cache tags must be strings.");
-  }
-  const normalized = tag.trim();
-  if (!normalized) {
-    throw new Error("Cache tags cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheTag, "normalizeCacheTag");
-function normalizeCacheNamespace(namespace) {
-  if (typeof namespace !== "string") {
-    throw new TypeError("Cache namespace must be a string.");
-  }
-  const normalized = namespace.trim().replace(/:+$/g, "");
-  if (!normalized) {
-    throw new Error("Cache namespace cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheNamespace, "normalizeCacheNamespace");
-function normalizeAdapterVersion(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-__name(normalizeAdapterVersion, "normalizeAdapterVersion");
-function normalizePositiveDuration(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive number of milliseconds.`);
-  }
-  return Math.floor(value);
-}
-__name(normalizePositiveDuration, "normalizePositiveDuration");
-function normalizePositiveInteger(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive integer.`);
-  }
-  return value;
-}
-__name(normalizePositiveInteger, "normalizePositiveInteger");
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-__name(delay, "delay");
-function normalizeCacheOptionsTags(options) {
-  const tags = /* @__PURE__ */ new Set();
-  for (const tag of options.tags ?? []) {
-    tags.add(normalizeCacheTag(tag));
-  }
-  for (const routePath of options.paths ?? []) {
-    tags.add(createPathCacheTag(routePath));
-  }
-  return tags;
-}
-__name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
-function assertFarmCacheEntry(entry, expectedKey) {
-  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
-    throw new TypeError(
-      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
-    );
-  }
-}
-__name(assertFarmCacheEntry, "assertFarmCacheEntry");
-function getFunctionCacheIdentity(fn) {
-  const name = fn.name || "anonymous";
-  return `${name}:${hashFunctionSource(String(fn))}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function hashFunctionSource(source) {
-  let hash = 2166136261;
-  for (let index = 0; index < source.length; index++) {
-    hash ^= source.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-__name(hashFunctionSource, "hashFunctionSource");
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-__name(compareCodepoint, "compareCodepoint");
-function serializeBinaryBytes(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-__name(serializeBinaryBytes, "serializeBinaryBytes");
-function serializeCanonicalStringEntries(entries, seen) {
-  const valuesByKey = /* @__PURE__ */ new Map();
-  for (const [key, item] of entries) {
-    const values = valuesByKey.get(key);
-    if (values) values.push(item);
-    else valuesByKey.set(key, [item]);
-  }
-  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
-    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
-  ).join(",");
-}
-__name(serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
-function isPlainCacheKeyObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype === null) return true;
-  const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
-}
-__name(isPlainCacheKeyObject, "isPlainCacheKeyObject");
-function getCacheKeyValueType(value) {
-  const prototype = Object.getPrototypeOf(value);
-  const constructor = prototype ? Object.getOwnPropertyDescriptor(prototype, "constructor")?.value : void 0;
-  if (typeof constructor === "function" && constructor.name) {
-    return constructor.name;
-  }
-  return Object.prototype.toString.call(value).slice(8, -1) || "object";
-}
-__name(getCacheKeyValueType, "getCacheKeyValueType");
-function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const valueType = typeof value;
-  if (valueType === "string") return JSON.stringify(value);
-  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
-    return `${valueType}:${String(value)}`;
-  }
-  if (valueType === "symbol") {
-    return `symbol:${String(value)}`;
-  }
-  if (valueType === "function") {
-    return `function:${getFunctionCacheIdentity(value)}`;
-  }
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (value instanceof ArrayBuffer) {
-    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
-    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (ArrayBuffer.isView(value)) {
-    const viewType = Object.prototype.toString.call(value).slice(8, -1);
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < value.length; index++) {
-        items.push(
-          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
-        );
-      }
-      seen.delete(value);
-      return `[${items.join(",")}]`;
-    }
-    if (value instanceof Set) {
-      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
-      seen.delete(value);
-      return `set:[${items.join(",")}]`;
-    }
-    if (value instanceof Map) {
-      const items = Array.from(
-        value,
-        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
-      ).sort(compareCodepoint);
-      seen.delete(value);
-      return `map:[${items.join(",")}]`;
-    }
-    if (value instanceof URLSearchParams) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `urlsearchparams:[${serialized2}]`;
-    }
-    if (value instanceof Headers) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `headers:[${serialized2}]`;
-    }
-    if (!isPlainCacheKeyObject(value)) {
-      throw new TypeError(
-        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
-      );
-    }
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => compareCodepoint(a, b)
-    );
-    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
-    seen.delete(value);
-    return `{${serialized}}`;
-  }
-  return String(value);
-}
-__name(stableSerialize, "stableSerialize");
-
-// src/client-cache.ts
-var invalidationTrackers = /* @__PURE__ */ new WeakMap();
-var cacheFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((unsubscribe) => unsubscribe()) : void 0;
-var DEFAULT_GC_SWEEP_INTERVAL_MS = 3e4;
-var _FarmClientDataCache = class _FarmClientDataCache {
-  constructor(options = {}) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.aliases = /* @__PURE__ */ new Map();
-    this.aliasesByTarget = /* @__PURE__ */ new Map();
-    this.invalidatedAt = /* @__PURE__ */ new Map();
-    this.listeners = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    this.pendingMetadataSweeps = /* @__PURE__ */ new Set();
-    this.gcSweepIntervalMs = options.gcSweepIntervalMs ?? DEFAULT_GC_SWEEP_INTERVAL_MS;
-    if (options.subscribeToInvalidation !== false) {
-      if (typeof WeakRef === "function") {
-        const reference = new WeakRef(this);
-        const unsubscribe = _FarmClientDataCache.subscribeWeakCache(reference);
-        cacheFinalizer?.register(this, unsubscribe, reference);
-        this.unsubscribeInvalidation = unsubscribe;
-      } else {
-        this.unsubscribeInvalidation = subscribeFarmCacheInvalidation(
-          (key) => this.applyInvalidation(key, Date.now(), false)
-        );
-      }
-    }
-  }
-  // This closure must only capture a weak reference, never the cache itself.
-  static subscribeWeakCache(reference) {
-    const unsubscribe = subscribeFarmCacheInvalidation((key) => {
-      const cache = reference.deref();
-      if (cache) cache.applyInvalidation(key, Date.now(), false);
-      else dispose();
-    });
-    function dispose() {
-      unsubscribe();
-      cacheFinalizer?.unregister(reference);
-    }
-    __name(dispose, "dispose");
-    return dispose;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  /** @internal Attach or detach the persistence engine's observation sink. */
-  attachPersistence(sink) {
-    this.persistence = sink;
-  }
-  resolveKey(key) {
-    let resolved = key;
-    const seen = /* @__PURE__ */ new Set();
-    while (this.aliases.has(resolved) && !seen.has(resolved)) {
-      seen.add(resolved);
-      resolved = this.aliases.get(resolved);
-    }
-    return resolved;
-  }
-  get(key, now = Date.now()) {
-    const resolved = this.resolveKey(key);
-    const entry = this.entries.get(resolved);
-    if (!entry) return void 0;
-    if (entry.gcAt !== void 0 && now >= entry.gcAt) {
-      if (entry.fetching) return void 0;
-      this.entries.delete(resolved);
-      this.persistence?.onDelete(resolved);
-      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
-      this.emit(resolved);
-      return void 0;
-    }
-    return entry;
-  }
-  set(key, entry) {
-    const resolved = this.resolveKey(key);
-    const invalidatedAt = this.invalidatedAt.get(resolved);
-    const nextEntry = invalidatedAt !== void 0 && invalidatedAt > entry.updatedAt ? { ...entry, staleAt: 0, invalidatedAt } : { ...entry, invalidatedAt: void 0 };
-    if (invalidatedAt === void 0 || entry.updatedAt >= invalidatedAt) {
-      this.invalidatedAt.delete(resolved);
-    }
-    this.entries.set(resolved, nextEntry);
-    this.pendingMetadataSweeps.delete(resolved);
-    if (nextEntry.gcAt !== void 0) this.scheduleGcSweep();
-    this.persistence?.onSet(resolved, nextEntry);
-    this.emit(resolved);
-    return this;
-  }
-  delete(key) {
-    const resolved = this.resolveKey(key);
-    const deleted = this.entries.delete(resolved);
-    this.inflight.delete(resolved);
-    if (deleted) this.persistence?.onDelete(resolved);
-    if (deleted || this.pendingMetadataSweeps.has(resolved)) {
-      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
-    }
-    this.emit(resolved);
-    return deleted;
-  }
-  clear() {
-    const keys = /* @__PURE__ */ new Set([...this.entries.keys(), ...this.listeners.keys()]);
-    this.entries.clear();
-    this.aliases.clear();
-    this.aliasesByTarget.clear();
-    this.invalidatedAt.clear();
-    this.inflight.clear();
-    this.pendingMetadataSweeps.clear();
-    this.persistence?.onClear();
-    for (const key of keys) this.emit(key);
-  }
-  dispose() {
-    this.unsubscribeInvalidation?.();
-    this.unsubscribeInvalidation = void 0;
-    if (this.gcTimer !== void 0) {
-      clearTimeout(this.gcTimer);
-      this.gcTimer = void 0;
-    }
-    this.clear();
-  }
-  isStale(key, now = Date.now()) {
-    const entry = this.get(key, now);
-    return !entry || entry.invalidatedAt !== void 0 || now >= entry.staleAt;
-  }
-  invalidate(key, now = Date.now()) {
-    this.applyInvalidation(key, now, true);
-  }
-  applyInvalidation(key, now, retainUnowned) {
-    const resolved = this.resolveKey(key);
-    for (const keys of invalidationTrackers.get(this) ?? []) keys.add(resolved);
-    const entry = this.entries.get(resolved);
-    const alreadyRetained = this.invalidatedAt.has(resolved);
-    if (retainUnowned || entry || alreadyRetained || this.hasMetadataOwner(resolved)) {
-      this.invalidatedAt.set(resolved, now);
-      if (!entry && !retainUnowned && !alreadyRetained) this.pendingMetadataSweeps.add(resolved);
-    }
-    if (entry) {
-      this.entries.set(resolved, {
-        ...entry,
-        staleAt: 0,
-        invalidatedAt: now
-      });
-    }
-    this.emit(resolved, "invalidate");
-  }
-  hasMetadataOwner(key) {
-    const related = /* @__PURE__ */ new Set([key]);
-    for (const target of related) {
-      if (this.listeners.has(target) || this.inflight.has(target)) return true;
-      for (const alias of this.aliasesByTarget.get(target) ?? []) related.add(alias);
-    }
-    return false;
-  }
-  alias(alias, key) {
-    const resolved = this.resolveKey(key);
-    if (alias === resolved) return;
-    const aliasEntry = this.entries.get(alias);
-    const aliasInvalidatedAt = this.invalidatedAt.get(alias) ?? aliasEntry?.invalidatedAt;
-    const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
-    if (aliasEntry && !this.entries.has(resolved)) {
-      this.entries.set(resolved, aliasEntry);
-      this.persistence?.onSet(resolved, aliasEntry);
-    }
-    if (this.entries.delete(alias)) this.persistence?.onDelete(alias);
-    this.invalidatedAt.delete(alias);
-    const invalidatedAt = [aliasInvalidatedAt, resolvedInvalidatedAt].reduce(
-      (latest, value) => value === void 0 ? latest : latest === void 0 ? value : Math.max(latest, value),
-      void 0
-    );
-    const resolvedEntry = this.entries.get(resolved);
-    if (invalidatedAt !== void 0 && (!resolvedEntry || invalidatedAt > resolvedEntry.updatedAt)) {
-      this.invalidatedAt.set(resolved, invalidatedAt);
-      if (resolvedEntry) {
-        this.entries.set(resolved, {
-          ...resolvedEntry,
-          staleAt: 0,
-          invalidatedAt
-        });
-      }
-    } else if (invalidatedAt !== void 0) {
-      this.invalidatedAt.delete(resolved);
-      if (resolvedEntry?.invalidatedAt !== void 0) {
-        this.entries.set(resolved, { ...resolvedEntry, invalidatedAt: void 0 });
-      }
-    }
-    const aliasInflight = this.inflight.get(alias);
-    if (aliasInflight && !this.inflight.has(resolved)) {
-      this.inflight.set(resolved, aliasInflight);
-    }
-    this.inflight.delete(alias);
-    if (this.pendingMetadataSweeps.delete(alias) && !this.entries.has(resolved)) {
-      this.pendingMetadataSweeps.add(resolved);
-    }
-    const previousTarget = this.aliases.get(alias);
-    if (previousTarget !== resolved) {
-      const previousResolved = previousTarget !== void 0 && this.pendingMetadataSweeps.size > 0 ? this.resolveKey(alias) : void 0;
-      this.removeAlias(alias);
-      this.aliases.set(alias, resolved);
-      let aliases = this.aliasesByTarget.get(resolved);
-      if (!aliases) this.aliasesByTarget.set(resolved, aliases = /* @__PURE__ */ new Set());
-      aliases.add(alias);
-      if (previousResolved !== void 0) this.sweepPendingEntryMetadata(previousResolved);
-    }
-    this.emit(alias);
-    this.emit(resolved, this.invalidatedAt.has(resolved) ? "invalidate" : void 0);
-  }
-  subscribe(key, listener) {
-    let listeners = this.listeners.get(key);
-    if (!listeners) {
-      listeners = /* @__PURE__ */ new Set();
-      this.listeners.set(key, listeners);
-    }
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-      if (listeners.size === 0 && this.listeners.get(key) === listeners) {
-        this.listeners.delete(key);
-        this.sweepPendingEntryMetadata(key);
-      }
-    };
-  }
-  getInflight(key) {
-    return this.inflight.get(this.resolveKey(key));
-  }
-  setInflight(key, promise) {
-    this.inflight.set(this.resolveKey(key), promise);
-  }
-  deleteInflight(key) {
-    const resolved = this.resolveKey(key);
-    if (this.inflight.delete(resolved)) this.sweepPendingEntryMetadata(resolved);
-  }
-  scheduleGcSweep() {
-    if (this.gcSweepIntervalMs === false || this.gcTimer !== void 0) return;
-    const timer = setTimeout(() => {
-      this.gcTimer = void 0;
-      this.sweepExpiredEntries();
-    }, this.gcSweepIntervalMs);
-    timer.unref?.();
-    this.gcTimer = timer;
-  }
-  sweepExpiredEntries(now = Date.now()) {
-    const watched = /* @__PURE__ */ new Set();
-    for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
-    let remaining = false;
-    const swept = /* @__PURE__ */ new Set();
-    for (const [key, entry] of this.entries) {
-      if (entry.gcAt === void 0) continue;
-      if (now < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
-        remaining = true;
-        continue;
-      }
-      this.entries.delete(key);
-      this.persistence?.onDelete(key);
-      swept.add(key);
-    }
-    if (swept.size > 0) this.sweepEntryMetadata(swept);
-    if (remaining) this.scheduleGcSweep();
-  }
-  /**
-   * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
-   * marks and provisional aliases are created per query invocation, so with
-   * dynamic keys they accumulate for the lifetime of the page even though the
-   * entries they describe are long gone.
-   */
-  sweepEntryMetadata(swept) {
-    const protectedKeys = /* @__PURE__ */ new Set();
-    for (const key of swept) if (this.hasMetadataOwner(key)) protectedKeys.add(key);
-    for (const key of swept) {
-      if (this.entries.has(key)) {
-        this.pendingMetadataSweeps.delete(key);
-      } else if (protectedKeys.has(key)) {
-        this.pendingMetadataSweeps.add(key);
-      } else {
-        this.pendingMetadataSweeps.delete(key);
-        this.invalidatedAt.delete(key);
-      }
-    }
-    const related = /* @__PURE__ */ new Set();
-    const targets = new Set(swept);
-    for (const target of targets) {
-      for (const alias of this.aliasesByTarget.get(target) ?? []) {
-        related.add(alias);
-        targets.add(alias);
-      }
-    }
-    const removable = [];
-    for (const alias of related) {
-      if (this.entries.has(alias) || this.listeners.has(alias) || this.inflight.has(alias))
-        continue;
-      const resolved = this.resolveKey(alias);
-      if (!swept.has(resolved)) continue;
-      if (this.entries.has(resolved) || protectedKeys.has(resolved)) continue;
-      removable.push(alias);
-    }
-    for (const alias of removable) {
-      this.removeAlias(alias);
-      this.invalidatedAt.delete(alias);
-    }
-  }
-  removeAlias(alias) {
-    const target = this.aliases.get(alias);
-    if (target === void 0) return;
-    this.aliases.delete(alias);
-    const aliases = this.aliasesByTarget.get(target);
-    aliases?.delete(alias);
-    if (aliases?.size === 0) this.aliasesByTarget.delete(target);
-  }
-  sweepPendingEntryMetadata(key) {
-    if (this.pendingMetadataSweeps.size === 0) return;
-    if (key !== void 0) {
-      const resolved = this.resolveKey(key);
-      if (this.pendingMetadataSweeps.has(resolved)) {
-        this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
-      }
-      return;
-    }
-    this.sweepEntryMetadata(new Set(this.pendingMetadataSweeps));
-  }
-  emit(key, event) {
-    this.notifyListeners(key, event);
-    if (this.listeners.size === 0) return;
-    for (const [alias, target] of this.aliases) {
-      if (!this.listeners.has(alias)) continue;
-      if (this.resolveKey(target) === key) {
-        this.notifyListeners(alias, event);
-      }
-    }
-  }
-  notifyListeners(key, event) {
-    for (const listener of this.listeners.get(key) ?? []) {
-      try {
-        listener(event);
-      } catch (error) {
-        const detail = error instanceof Error ? error.stack ?? error.message : String(error);
-        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
-      }
-    }
-  }
-};
-__name(_FarmClientDataCache, "FarmClientDataCache");
-var FarmClientDataCache = _FarmClientDataCache;
-var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
-var clientCacheGlobal = globalThis;
-var sharedFarmClientDataCache = clientCacheGlobal[FARM_CLIENT_DATA_CACHE] ?? (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache());
-function getFarmClientDataCache() {
-  return sharedFarmClientDataCache;
-}
-__name(getFarmClientDataCache, "getFarmClientDataCache");
-function normalizeFarmClientCacheKey(key) {
-  return typeof key === "string" ? key : createRouteDataCacheKey(key);
-}
-__name(normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
-
-// src/routing/specificity.ts
-var SEGMENT_RANK = {
-  static: 4,
-  dynamic: 3,
-  "catch-all": 1,
-  "optional-catch-all": 0
-};
-var ROUTE_END_RANK = 2;
-function compareRouteSpecificity(left, right) {
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
-    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
-    if (leftRank !== rightRank) return rightRank - leftRank;
-  }
-  return 0;
-}
-__name(compareRouteSpecificity, "compareRouteSpecificity");
-
-// src/api/route-pattern.ts
-var compiledEntries = /* @__PURE__ */ new WeakMap();
-function matchAPIRoute(routes, pathname) {
-  const exactRoute = routes.get(pathname);
-  if (exactRoute) return { route: exactRoute, params: {} };
-  const normalizedPathname = normalizePathname(pathname);
-  if (normalizedPathname !== pathname) {
-    const normalizedRoute = routes.get(normalizedPathname);
-    if (normalizedRoute) return { route: normalizedRoute, params: {} };
-  }
-  const pathnameSegments = getPathSegments(normalizedPathname).map(decodePathSegment);
-  let bestMatch = null;
-  let bestSpecificity = null;
-  for (const route of routes.values()) {
-    const routePath = route.path;
-    let entry = compiledEntries.get(route);
-    if (!entry || entry.path !== routePath) {
-      entry = compileRouteEntry(routePath);
-      compiledEntries.set(route, entry);
-    }
-    const params = matchRouteEntry(entry, pathnameSegments);
-    if (!params) continue;
-    if (bestSpecificity === null || compareRouteSpecificity(entry.specificity, bestSpecificity) < 0) {
-      bestMatch = { route, params };
-      bestSpecificity = entry.specificity;
-    }
-  }
-  return bestMatch;
-}
-__name(matchAPIRoute, "matchAPIRoute");
-function compileRouteEntry(path) {
-  const segments = getPathSegments(path).map((segment) => {
-    const dynamic = parseDynamicSegment(segment);
-    return dynamic ? { dynamic } : { value: decodePathSegment(segment) };
-  });
-  return {
-    path,
-    segments,
-    specificity: segments.map((segment) => {
-      const dynamic = segment.dynamic;
-      if (!dynamic) return "static";
-      if (!dynamic.catchAll) return "dynamic";
-      return dynamic.optional ? "optional-catch-all" : "catch-all";
-    })
-  };
-}
-__name(compileRouteEntry, "compileRouteEntry");
-function matchRouteEntry(entry, pathnameSegments) {
-  const params = {};
-  let pathIndex = 0;
-  for (const routeSegment of entry.segments) {
-    const dynamicSegment = routeSegment.dynamic;
-    if (dynamicSegment?.catchAll) {
-      const remainingSegments = pathnameSegments.slice(pathIndex);
-      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
-        return null;
-      }
-      if (remainingSegments.length > 0) {
-        params[dynamicSegment.name] = remainingSegments;
-      }
-      pathIndex = pathnameSegments.length;
-      continue;
-    }
-    const pathnameSegment = pathnameSegments[pathIndex];
-    if (pathnameSegment === void 0) {
-      return null;
-    }
-    if (dynamicSegment) {
-      params[dynamicSegment.name] = pathnameSegment;
-      pathIndex++;
-      continue;
-    }
-    if (routeSegment.value !== pathnameSegment) {
-      return null;
-    }
-    pathIndex++;
-  }
-  return pathIndex === pathnameSegments.length ? params : null;
-}
-__name(matchRouteEntry, "matchRouteEntry");
-function getPathSegments(pathname) {
-  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
-}
-__name(getPathSegments, "getPathSegments");
-function normalizePathname(pathname) {
-  if (pathname.length > 1 && pathname.endsWith("/")) {
-    return pathname.replace(/\/+$/, "");
-  }
-  return pathname;
-}
-__name(normalizePathname, "normalizePathname");
-function parseDynamicSegment(segment) {
-  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
-  if (optionalCatchAll?.[1]) {
-    return { name: optionalCatchAll[1], catchAll: true, optional: true };
-  }
-  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
-  if (catchAll?.[1]) {
-    return { name: catchAll[1], catchAll: true, optional: false };
-  }
-  const dynamic = segment.match(/^\[(.+)\]$/);
-  if (dynamic?.[1]) {
-    return { name: dynamic[1], catchAll: false, optional: false };
-  }
-  return null;
-}
-__name(parseDynamicSegment, "parseDynamicSegment");
-function decodePathSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodePathSegment, "decodePathSegment");
-
-// src/api/client-routes.ts
-var _ClientRouteManifest = class _ClientRouteManifest {
-  constructor(routes) {
-    this.candidates = /* @__PURE__ */ new Map();
-    this.nextSegments = /* @__PURE__ */ new Map();
-    this.routes = new Map(
-      routes.map((route) => [
-        route.path.replace(/\/$/, ""),
-        {
-          path: route.path.replace(/\/$/, ""),
-          methods: [...route.methods]
-        }
-      ])
-    );
-    const addCandidate = /* @__PURE__ */ __name((path, route) => {
-      let candidates = this.candidates.get(path);
-      if (!candidates) this.candidates.set(path, candidates = []);
-      candidates.push(route);
-    }, "addCandidate");
-    for (const route of this.routes.values()) {
-      addCandidate(route.path, route);
-      const segments = route.path.split("/");
-      let parent = "";
-      for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        if (i > 0 && parseDynamicSegment(segment)) {
-          let next = this.nextSegments.get(parent);
-          if (!next) this.nextSegments.set(parent, next = /* @__PURE__ */ new Set());
-          next.add(segment);
-          if (i === segments.length - 1) addCandidate(parent, route);
-        }
-        parent = i === 0 ? segment : `${parent}/${segment}`;
-      }
-    }
-  }
-  bind(path, input) {
-    const params = readParams(input);
-    const normalized = path.replace(/\/$/, "");
-    const candidates = new Set(
-      [...this.nextSegments.get(normalized) ?? []].filter((segment2) => {
-        const dynamic2 = parseDynamicSegment(segment2);
-        return dynamic2 && Object.keys(params).every((key) => key === dynamic2.name) && (Object.prototype.hasOwnProperty.call(params, dynamic2.name) || dynamic2.optional);
-      })
-    );
-    if (candidates.size !== 1)
-      throw new TypeError(
-        `Cannot bind route params at ${path}: supply exactly the next dynamic segment's parameter.`
-      );
-    const segment = [...candidates][0];
-    const dynamic = parseDynamicSegment(segment);
-    encodeParameter(dynamic, params[dynamic.name]);
-    return {
-      segment,
-      params: Object.freeze(
-        Object.fromEntries(
-          Object.entries(params).map(([key, value]) => [
-            key,
-            Array.isArray(value) ? Object.freeze([...value]) : value
-          ])
-        )
-      )
-    };
-  }
-  resolve(path, method, bound, input) {
-    const normalized = path.replace(/\/$/, "");
-    const supplied = readParams(input?.params);
-    const candidates = (this.candidates.get(normalized) ?? []).filter((route2) => {
-      if (route2.path === normalized) return true;
-      if (!route2.path.startsWith(`${normalized}/`)) return false;
-      const tail = route2.path.slice(normalized.length + 1);
-      return !tail.includes("/") && Boolean(parseDynamicSegment(tail)) && input?.params !== void 0;
-    });
-    const selected = candidates.filter((route2) => {
-      const unbound = route2.path.split("/").map(parseDynamicSegment).filter((part) => part && !Object.prototype.hasOwnProperty.call(bound, part.name));
-      return Object.keys(supplied).every((key) => unbound.some((part) => part.name === key)) && unbound.every(
-        (part) => part.optional || Object.prototype.hasOwnProperty.call(supplied, part.name)
-      );
-    });
-    if (selected.length !== 1)
-      throw new TypeError(
-        `Cannot resolve ${method} ${normalized}: missing, unexpected, or ambiguous route params.`
-      );
-    const route = selected[0];
-    if (!route.methods.includes(method) && !(method === "HEAD" && route.methods.includes("GET"))) {
-      throw new TypeError(`${method} is not registered for ${route.path}.`);
-    }
-    const params = { ...bound, ...supplied };
-    const resolved = route.path.split("/").map((segment) => {
-      const dynamic = parseDynamicSegment(segment);
-      return dynamic ? encodeParameter(dynamic, params[dynamic.name]) : segment;
-    }).filter(Boolean).join("/");
-    const pathname = `/${resolved}`;
-    const winner = matchAPIRoute(this.routes, pathname);
-    if (winner?.route.path !== route.path) {
-      throw new TypeError(
-        `Route ${route.path} resolves to ${pathname}, which is shadowed by ${winner?.route.path ?? "another route"}.`
-      );
-    }
-    return pathname;
-  }
-};
-__name(_ClientRouteManifest, "ClientRouteManifest");
-var ClientRouteManifest = _ClientRouteManifest;
-function readParams(input) {
-  if (input === void 0) return {};
-  if (!input || typeof input !== "object" || Array.isArray(input) || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) {
-    throw new TypeError("Route params must be a plain object.");
-  }
-  for (const key of Object.keys(input)) {
-    if (["__proto__", "constructor", "prototype"].includes(key))
-      throw new TypeError(`Unsafe route parameter ${key}.`);
-  }
-  return input;
-}
-__name(readParams, "readParams");
-function encodeParameter(parameter, value) {
-  if (parameter.optional && value === void 0) return "";
-  const parts = parameter.catchAll ? value : [value];
-  if (!Array.isArray(parts) || !parts.length && !parameter.optional) {
-    throw new TypeError(
-      `Route parameter ${parameter.name} must be ${parameter.catchAll ? "a non-empty array of strings" : "a string"}.`
-    );
-  }
-  return Array.from(parts, (part) => {
-    if (typeof part !== "string" || !part || part === "." || part === ".." || Array.from(part).some(
-      (character) => character.charCodeAt(0) <= 31 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159
-    )) {
-      throw new TypeError(`Invalid value for route parameter ${parameter.name}.`);
-    }
-    return encodeURIComponent(part);
-  }).join("/");
-}
-__name(encodeParameter, "encodeParameter");
-
-// src/server/request-bridge.ts
-var CURRENT_REQUEST_RESOLVER_KEY2 = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
-function getGlobalState() {
-  return globalThis;
-}
-__name(getGlobalState, "getGlobalState");
-function _resolveCurrentRequest() {
-  return getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY2]?.();
-}
-__name(_resolveCurrentRequest, "_resolveCurrentRequest");
-
-// src/client-retry.ts
-var MAX_TIMER_DELAY = 2147483647;
-function resolveClientRetryCount(value) {
-  const count = value ?? 0;
-  if (!Number.isSafeInteger(count) || count < 0) {
-    throw new RangeError("retry.count must be a non-negative safe integer");
-  }
-  return count;
-}
-__name(resolveClientRetryCount, "resolveClientRetryCount");
-function resolveClientRetryDelay(value) {
-  const delay2 = value ?? 0;
-  if (!Number.isFinite(delay2) || delay2 < 0 || delay2 > MAX_TIMER_DELAY) {
-    throw new RangeError(`retry.delay must be between 0 and ${MAX_TIMER_DELAY} milliseconds`);
-  }
-  return delay2;
-}
-__name(resolveClientRetryDelay, "resolveClientRetryDelay");
-
-// src/api/server-client-bridge.ts
-var API_RUNTIME_RESOLVER = /* @__PURE__ */ Symbol.for("farm.apiRequestRuntimeResolver");
-function resolveAPIRequestRuntime() {
-  return globalThis[API_RUNTIME_RESOLVER]?.();
-}
-__name(resolveAPIRequestRuntime, "resolveAPIRequestRuntime");
-
-// src/api/transport.ts
-function isJSONStreamResponse(response) {
-  const contentType = response.headers?.get?.("content-type")?.toLowerCase() ?? "";
-  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
-}
-__name(isJSONStreamResponse, "isJSONStreamResponse");
-function readJSONStream(response) {
-  if (!response.body) {
-    throw new TypeError("Cannot read a JSON stream response without a body");
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let completed = false;
-  let cancelled = false;
-  let claimed = false;
-  let released = false;
-  const releaseReader = /* @__PURE__ */ __name(() => {
-    if (released) return;
-    released = true;
-    reader.releaseLock();
-  }, "releaseReader");
-  const parseLine = /* @__PURE__ */ __name(async (line) => {
-    try {
-      return JSON.parse(line);
-    } catch (error) {
-      completed = true;
-      buffer = "";
-      void reader.cancel(error).catch(() => {
-      });
-      releaseReader();
-      throw error;
-    }
-  }, "parseLine");
-  const readNext = /* @__PURE__ */ __name(async () => {
-    while (true) {
-      if (cancelled) return { done: true, value: void 0 };
-      const lineEnd = buffer.indexOf("\n");
-      if (lineEnd >= 0) {
-        const line = buffer.slice(0, lineEnd).trim();
-        buffer = buffer.slice(lineEnd + 1);
-        if (!line) continue;
-        return { done: false, value: await parseLine(line) };
-      }
-      if (completed) {
-        const line = buffer.trim();
-        buffer = "";
-        if (!line) {
-          releaseReader();
-          return { done: true, value: void 0 };
-        }
-        return { done: false, value: await parseLine(line) };
-      }
-      let chunk;
-      try {
-        chunk = await reader.read();
-      } catch (error) {
-        if (cancelled) return { done: true, value: void 0 };
-        completed = true;
-        buffer = "";
-        releaseReader();
-        throw error;
-      }
-      if (cancelled) return { done: true, value: void 0 };
-      completed = chunk.done;
-      buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-    }
-  }, "readNext");
-  let readQueue = Promise.resolve();
-  const iterator = {
-    next() {
-      const result = readQueue.then(readNext);
-      readQueue = result.then(
-        () => {
-        },
-        () => {
-        }
-      );
-      return result;
-    },
-    async return() {
-      cancelled = true;
-      completed = true;
-      buffer = "";
-      if (!released) {
-        try {
-          await reader.cancel();
-        } finally {
-          releaseReader();
-        }
-      }
-      return { done: true, value: void 0 };
-    }
-  };
-  return {
-    response,
-    async cancel(reason) {
-      cancelled = true;
-      completed = true;
-      buffer = "";
-      if (!released) {
-        try {
-          await reader.cancel(reason);
-        } finally {
-          releaseReader();
-        }
-      }
-    },
-    [Symbol.asyncIterator]() {
-      if (claimed) {
-        throw new TypeError("Farm API streams can only be consumed once");
-      }
-      claimed = true;
-      return iterator;
-    }
-  };
-}
-__name(readJSONStream, "readJSONStream");
-function isFarmAPIStream(value) {
-  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
-}
-__name(isFarmAPIStream, "isFarmAPIStream");
-
-// 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;
-var FARM_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "QUERY"]);
-var FARM_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 425, 429]);
-function isFarmRetryableFailure(context2) {
-  if (!FARM_IDEMPOTENT_METHODS.has(context2.method)) return false;
-  if (context2.status === void 0) return true;
-  return context2.status >= 500 || FARM_RETRYABLE_STATUSES.has(context2.status);
-}
-__name(isFarmRetryableFailure, "isFarmRetryableFailure");
-function createApiClients(options = {}) {
-  const localScopes = /* @__PURE__ */ new WeakMap();
-  const routeMeta = /* @__PURE__ */ new WeakMap();
-  const api = createNestedProxy(
-    [],
-    async (path, method, input, clientOptions) => {
-      if (typeof window !== "undefined") {
-        throw new Error(
-          "api is server-only. Use apiClient from createApiClients() in the browser."
-        );
-      }
-      const currentRequest = _resolveCurrentRequest();
-      const runtime3 = resolveAPIRequestRuntime();
-      if (!currentRequest || !runtime3) {
-        throw new Error(
-          "api requires an active Farm server request. Call it from a server page, query, action, or API handler; use apiClient with an absolute baseURL for standalone HTTP calls."
-        );
-      }
-      let localClients = localScopes.get(runtime3);
-      if (!localClients) {
-        localClients = /* @__PURE__ */ new WeakMap();
-        localScopes.set(runtime3, localClients);
-      }
-      let local = localClients.get(currentRequest);
-      if (!local) {
-        const origin = new URL(currentRequest.url).origin;
-        const headers = new Headers();
-        for (const name of ["cookie", "authorization", "accept-language"]) {
-          const value = currentRequest.headers.get(name);
-          if (value !== null) headers.set(name, value);
-        }
-        local = createAPIClientRuntime(
-          {
-            ...options,
-            integrations: false,
-            baseURL: new URL(runtime3.basePath, origin).toString()
-          },
-          {
-            headers,
-            signal: currentRequest.signal,
-            cache: new FarmClientDataCache({ subscribeToInvalidation: false }),
-            routeMeta,
-            fetch: /* @__PURE__ */ __name((url, init) => {
-              if (new URL(url).origin !== origin) {
-                throw new Error(
-                  "api can only dispatch to this Farm app. Use apiClient for HTTP calls."
-                );
-              }
-              currentRequest.signal.throwIfAborted();
-              return runtime3.dispatch(new Request(url, init));
-            }, "fetch")
-          }
-        );
-        localClients.set(currentRequest, local);
-      }
-      return local.request(path, method, input, clientOptions);
-    },
-    routeMeta,
-    "/api",
-    true,
-    options.integrations === false ? void 0 : {
-      integrations: integrationsServer({
-        baseURL: options.baseURL,
-        headers: options.headers,
-        credentials: options.credentials,
-        timeoutMs: options.timeoutMs,
-        fetch: options.fetch,
-        onRequest: options.onRequest,
-        onResponse: options.onResponse,
-        onError: options.onError,
-        ...options.integrations
-      })
-    },
-    options.routes ? new ClientRouteManifest(options.routes) : void 0
-  );
-  return {
-    api,
-    apiClient: createAPIClient(options)
-  };
-}
-__name(createApiClients, "createApiClients");
-function createAPIClient(options = {}) {
-  return createAPIClientRuntime(options).client;
-}
-__name(createAPIClient, "createAPIClient");
-function createAPIClientRuntime(options = {}, transport) {
-  options ?? (options = {});
-  const baseURL = options.baseURL || getFarmAPIBaseURL();
-  const httpFetch = options.fetch;
-  const integrationOptions = options.integrations === false ? false : {
-    baseURL: options.baseURL,
-    headers: options.headers,
-    credentials: options.credentials,
-    timeoutMs: options.timeoutMs,
-    fetch: httpFetch,
-    onRequest: options.onRequest,
-    onResponse: options.onResponse,
-    onError: options.onError,
-    ...typeof options.integrations === "object" ? options.integrations : {}
-  };
-  const rootAliases = integrationOptions === false ? void 0 : {
-    integrations: integrationsClient(integrationOptions)
-  };
-  const sharedCacheState = transport?.cache ?? getFarmClientDataCache();
-  const localCaches = transport ? /* @__PURE__ */ new Set([sharedCacheState]) : void 0;
-  const sharedInflightState = /* @__PURE__ */ new Map();
-  let scopedRequestState;
-  const routeMeta = transport?.routeMeta ?? /* @__PURE__ */ new WeakMap();
-  let requestCounter = 0;
-  const fetchClient = /* @__PURE__ */ __name(async (path, requestOptions, defaultHeaders, cancellation) => {
-    const url = resolveFarmAPIRequestURL(path, baseURL);
-    const method = String(requestOptions.method || "GET").toUpperCase();
-    if (requestOptions.query) {
-      appendAPIQuery(url.searchParams, requestOptions.query);
-    }
-    const headers = new Headers(defaultHeaders);
-    new Headers(requestOptions.headers).forEach((value, key) => headers.set(key, value));
-    const fetchOptions = {
-      method,
-      headers,
-      credentials: options.credentials,
-      signal: cancellation.signal
-    };
-    if (method === "QUERY" && !headers.has("content-type")) {
-      headers.set("content-type", "application/json");
-    }
-    if (requestOptions.body !== void 0) {
-      if (isFormData(requestOptions.body)) {
-        headers.delete("content-type");
-        fetchOptions.body = requestOptions.body;
-      } else {
-        if (!headers.has("content-type")) headers.set("content-type", "application/json");
-        fetchOptions.body = JSON.stringify(requestOptions.body);
-      }
-    }
-    cancellation.check();
-    const response = await (transport?.fetch ?? httpFetch ?? fetch)(url.toString(), fetchOptions);
-    cancellation.check();
-    const invalidations = decodeFarmCacheInvalidations(
-      response.headers?.get?.(FARM_CACHE_INVALIDATION_HEADER)
-    );
-    if (transport) {
-      for (const cache of localCaches) {
-        for (const key of invalidations) cache.invalidate(key);
-      }
-    } else {
-      applyFarmCacheInvalidations(invalidations);
-    }
-    let data;
-    try {
-      data = await readAPIResponseData(response, method);
-      cancellation.check();
-    } catch (decodeError) {
-      if (!(decodeError instanceof APIResponseDecodeError)) throw decodeError;
-      if (response.ok) throw decodeError.cause;
-      return { response, data: void 0, decodeError: decodeError.cause };
-    }
-    return { response, data };
-  }, "fetchClient");
-  const request = /* @__PURE__ */ __name(async (path, method, input = {}, clientOptions) => {
-    const maxRetries = resolveClientRetryCount(clientOptions?.retry?.count);
-    if (typeof clientOptions?.retry?.delay !== "function") {
-      resolveClientRetryDelay(clientOptions?.retry?.delay);
-    }
-    const cancellation = createClientCancellation(
-      clientOptions?.signal,
-      clientOptions?.timeoutMs ?? options.timeoutMs,
-      transport?.signal
-    );
-    const normalizeCallError = /* @__PURE__ */ __name((error) => {
-      if (!cancellation.signal?.aborted) return normalizeError(error);
-      const normalized = new APIClientError(
-        cancellation.timedOut ? "timeout" : "aborted",
-        void 0,
-        {
-          status: 0,
-          message: cancellation.timedOut ? "Client request timed out" : "Client request aborted"
-        }
-      );
-      normalized.cause = cancellation.signal.reason;
-      return normalized;
-    }, "normalizeCallError");
-    try {
-      const methodUpper = method.toUpperCase();
-      const requestId = `${Date.now()}-${++requestCounter}`;
-      const defaultHeaders = new Headers(transport?.headers);
-      let requestContextError;
-      try {
-        cancellation.check();
-        const resolved = resolveClientHeaders(options.headers);
-        const headers = resolved instanceof Headers ? resolved : await cancellation.run(() => resolved);
-        cancellation.check();
-        headers.forEach((value, name) => defaultHeaders.set(name, value));
-      } catch (error) {
-        requestContextError = normalizeCallError(error);
-      }
-      const cacheOptions = clientOptions?.cache ? {
-        ...options.cacheDefaults,
-        ...clientOptions.cache
-      } : void 0;
-      const configuredCacheKey = clientOptions?.key ?? cacheOptions?.key;
-      const cacheKey = normalizeFarmClientCacheKey(
-        configuredCacheKey ?? buildCacheKey(methodUpper, path, input, baseURL, defaultHeaders)
-      );
-      const now = Date.now();
-      const emitStatus = /* @__PURE__ */ __name((phase, payload) => {
-        notifyClientObserver(
-          clientOptions?.onStatus,
-          [
-            {
-              phase,
-              requestId,
-              method: methodUpper,
-              key: cacheKey,
-              input,
-              timestamp: Date.now(),
-              ...payload
-            }
-          ],
-          "API client onStatus"
-        );
-      }, "emitStatus");
-      const policy = cacheOptions?.policy ?? (cacheOptions ? "cache-first" : "network-only");
-      const staleTime = cacheOptions?.staleTime ?? 0;
-      const hasReliableDefaultCacheKey = methodUpper !== "QUERY" || !isFormData(input?.body) || configuredCacheKey !== void 0;
-      const isCacheEnabled = Boolean(cacheOptions) && (methodUpper === "GET" || methodUpper === "QUERY") && hasReliableDefaultCacheKey;
-      const needsCacheState = isCacheEnabled || Boolean(clientOptions?.optimistic?.update?.length) || Boolean(clientOptions?.invalidate);
-      let requestCacheContext = void 0;
-      if (needsCacheState && !requestContextError) {
-        try {
-          requestCacheContext = getRequestCacheContext(
-            { headers: defaultHeaders, credentials: options.credentials },
-            input,
-            // Custom transports can inject an identity outside visible headers.
-            // Never share their cached data with other client instances.
-            httpFetch ? "client" : cacheOptions?.scope
-          );
-        } catch (error) {
-          requestContextError = normalizeError(error);
-        }
-      }
-      let cacheState = sharedCacheState;
-      let inflightState = sharedInflightState;
-      let requestScopedState;
-      if (requestCacheContext !== void 0) {
-        if (scopedRequestState && scopedRequestState.context !== requestCacheContext) {
-          scopedRequestState.retired = true;
-          if (scopedRequestState.inflight.size === 0) scopedRequestState.cache.dispose();
-          scopedRequestState = void 0;
-        }
-        scopedRequestState ?? (scopedRequestState = {
-          context: requestCacheContext,
-          cache: new FarmClientDataCache({ subscribeToInvalidation: !transport }),
-          inflight: /* @__PURE__ */ new Map(),
-          retired: false
-        });
-        requestScopedState = scopedRequestState;
-        cacheState = requestScopedState.cache;
-        localCaches?.add(cacheState);
-        inflightState = requestScopedState.inflight;
-      }
-      const optimisticState = getOptimisticState(cacheState);
-      const entry = getValidCacheEntry(cacheState, cacheKey, now);
-      const isStale = entry ? isEntryStale(entry, now) : true;
-      const applyOptimisticUpdates = /* @__PURE__ */ __name(() => {
-        if (!clientOptions?.optimistic?.update?.length) return [];
-        const snapshots = /* @__PURE__ */ new Map();
-        for (const update of clientOptions.optimistic.update) {
-          const [target, targetInput, updater] = update.length === 2 ? [update[0], void 0, update[1]] : [update[0], update[1], update[2]];
-          const targetKey = resolveTargetKey(
-            routeMeta,
-            target,
-            targetInput,
-            baseURL,
-            defaultHeaders,
-            transport ? baseURL : void 0
-          );
-          if (!targetKey) continue;
-          const targetEntry = getValidCacheEntry(cacheState, targetKey, now);
-          const currentEntry = cacheState.get(targetKey);
-          let stack = optimisticState.get(targetKey);
-          if (stack && !reconcileOptimisticInvalidation(cacheState, targetKey, stack)) {
-            stack = void 0;
-          }
-          if (!stack) {
-            stack = {
-              entry: targetEntry ? { ...targetEntry } : void 0,
-              layers: [],
-              renderedEntry: currentEntry
-            };
-            optimisticState.set(targetKey, stack);
-          }
-          let snapshot = snapshots.get(targetKey);
-          if (!snapshot) {
-            const previousEntry = stack.layers.length === 0 ? stack.entry : stack.renderedEntry;
-            const layer = {
-              updaters: [],
-              updatedAt: now,
-              staleAt: targetEntry?.staleAt ?? now + (cacheOptions?.staleTime ?? options.cacheDefaults?.staleTime ?? 0),
-              gcAt: targetEntry?.gcAt ?? getGcAt(now, cacheOptions?.gcTime ?? options.cacheDefaults?.gcTime)
-            };
-            stack.layers.push(layer);
-            snapshot = {
-              key: targetKey,
-              stack,
-              layer
-            };
-            snapshots.set(targetKey, snapshot);
-            snapshot.layer.updaters.push(updater);
-            const nextEntry2 = applyOptimisticLayer(previousEntry, {
-              ...snapshot.layer,
-              updaters: [updater]
-            });
-            storeOptimisticEntry(cacheState, targetKey, stack, nextEntry2);
-            continue;
-          }
-          snapshot.layer.updaters.push(updater);
-          const nextEntry = applyOptimisticLayer(stack.renderedEntry, {
-            ...snapshot.layer,
-            updaters: [updater]
-          });
-          storeOptimisticEntry(cacheState, targetKey, stack, nextEntry);
-        }
-        return Array.from(snapshots.values());
-      }, "applyOptimisticUpdates");
-      const rollbackOptimisticUpdates = /* @__PURE__ */ __name((snapshots) => {
-        if (!clientOptions?.optimistic?.rollbackOnError) return;
-        settleOptimisticUpdates(cacheState, optimisticState, snapshots, "rollback");
-      }, "rollbackOptimisticUpdates");
-      const invalidateUncommittedOptimisticUpdates = /* @__PURE__ */ __name((snapshots) => {
-        if (clientOptions?.optimistic?.rollbackOnError) return;
-        for (const key of settleOptimisticUpdates(
-          cacheState,
-          optimisticState,
-          snapshots,
-          "invalidate"
-        )) {
-          emitStatus("invalidated", { key });
-        }
-      }, "invalidateUncommittedOptimisticUpdates");
-      const executeNetwork = /* @__PURE__ */ __name(async (opts) => {
-        const release = cancellation.hold();
-        let unsubscribeInvalidation;
-        let readOwners;
-        let readOwner;
-        const resolvedCacheKey = cacheState.resolveKey(cacheKey);
-        try {
-          const dedupeMs = cacheOptions?.dedupeMs ?? 0;
-          const inflight = inflightState.get(cacheKey);
-          const allowDedupe = isCacheEnabled && dedupeMs > 0 && !cancellation.signal && !requestContextError;
-          if (allowDedupe && inflight && !inflight.cancellable && now - inflight.startedAt < dedupeMs) {
-            emitStatus("pending", { isBackground: opts?.isBackground, data: entry?.data });
-            const result2 = await inflight.promise;
-            if (result2.error) {
-              emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
-              notifyClientObserver(options.onError, [result2.error]);
-              if (opts?.callCallbacks !== false) {
-                notifyClientObserver(clientOptions?.onError, [result2.error], "API client onError");
-              }
-            } else {
-              emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
-              if (opts?.callCallbacks !== false) {
-                notifyClientObserver(
-                  clientOptions?.onSuccess,
-                  [result2.data],
-                  "API client onSuccess"
-                );
-              }
-            }
-            return result2;
-          }
-          let invalidatedDuringRequest = false;
-          if (isCacheEnabled) {
-            readOwners = getCacheReadOwners(cacheState);
-            readOwner = {};
-            readOwners.set(resolvedCacheKey, readOwner);
-            unsubscribeInvalidation = cacheState.subscribe(cacheKey, (event) => {
-              if (event === "invalidate") invalidatedDuringRequest = true;
-            });
-          }
-          emitStatus(opts?.isBackground ? "revalidating" : "pending", {
-            isBackground: opts?.isBackground
-          });
-          const promise = (async () => {
-            const shouldRetryFailure = clientOptions?.retry?.shouldRetry ?? isFarmRetryableFailure;
-            let attempt = 0;
-            while (true) {
-              if (options.onRequest || clientOptions?.onRequest) {
-                const requestEvent = {
-                  requestId,
-                  method: methodUpper,
-                  key: cacheKey,
-                  path,
-                  input,
-                  attempt,
-                  timestamp: Date.now()
-                };
-                notifyClientObserver(options.onRequest, [requestEvent]);
-                notifyClientObserver(
-                  clientOptions?.onRequest,
-                  [requestEvent],
-                  "API client onRequest"
-                );
-              }
-              try {
-                if (requestContextError) throw requestContextError;
-                const { response, data, decodeError } = await cancellation.run(
-                  () => fetchClient(
-                    path,
-                    {
-                      ...input,
-                      method: methodUpper
-                    },
-                    defaultHeaders,
-                    cancellation
-                  )
-                );
-                const error = response.ok ? null : createResponseError2(response, data, decodeError);
-                const responseEvent = {
-                  requestId,
-                  method: methodUpper,
-                  key: cacheKey,
-                  path,
-                  input,
-                  attempt,
-                  timestamp: Date.now(),
-                  response,
-                  data: response.ok ? data : void 0,
-                  error: error ?? void 0,
-                  ok: response.ok,
-                  status: response.status
-                };
-                notifyClientObserver(options.onResponse, [
-                  response.ok ? data : void 0,
-                  error,
-                  responseEvent
-                ]);
-                notifyResponseObserver(
-                  clientOptions?.onResponse,
-                  response.ok ? data : void 0,
-                  error,
-                  responseEvent
-                );
-                if (!error) {
-                  return { data, error: null, key: cacheKey };
-                }
-                if (attempt >= maxRetries || !shouldRetryFailure({
-                  attempt,
-                  method: methodUpper,
-                  status: response.status,
-                  error
-                })) {
-                  return { data: void 0, error, key: cacheKey };
-                }
-              } catch (err) {
-                const error = normalizeCallError(err);
-                const responseEvent = {
-                  requestId,
-                  method: methodUpper,
-                  key: cacheKey,
-                  path,
-                  input,
-                  attempt,
-                  timestamp: Date.now(),
-                  error,
-                  ok: false
-                };
-                notifyClientObserver(options.onResponse, [void 0, error, responseEvent]);
-                notifyResponseObserver(clientOptions?.onResponse, void 0, error, responseEvent);
-                if (attempt >= maxRetries || requestContextError || cancellation.signal?.aborted || !shouldRetryFailure({ attempt, method: methodUpper, error })) {
-                  return { data: void 0, error, key: cacheKey };
-                }
-              }
-              attempt += 1;
-              const delay2 = resolveClientRetryDelay(
-                typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay
-              );
-              if (delay2 > 0) {
-                try {
-                  await cancellation.delay(delay2);
-                } catch (error) {
-                  return { data: void 0, error: normalizeCallError(error), key: cacheKey };
-                }
-              }
-            }
-          })();
-          const inflightEntry = {
-            promise,
-            startedAt: now,
-            cancellable: !!cancellation.signal || !!requestContextError
-          };
-          inflightState.set(cacheKey, inflightEntry);
-          try {
-            const result2 = await promise;
-            if (inflightState.get(cacheKey) === inflightEntry && readOwners?.get(resolvedCacheKey) === readOwner && !invalidatedDuringRequest && !result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
-              const updatedAt = Date.now();
-              const cached = {
-                data: result2.data,
-                updatedAt,
-                staleAt: updatedAt + staleTime,
-                gcAt: getGcAt(updatedAt, cacheOptions?.gcTime),
-                invalidatedAt: void 0,
-                persist: cacheOptions?.persist === true ? true : void 0,
-                [API_CACHE_REFETCH]: createCacheRefetch(
-                  request,
-                  path,
-                  method,
-                  input,
-                  cacheKey,
-                  cacheOptions,
-                  clientOptions,
-                  options.onError
-                )
-              };
-              cacheState.set(cacheKey, cached);
-            }
-            if (result2.error) {
-              emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
-              notifyClientObserver(options.onError, [result2.error]);
-              if (opts?.callCallbacks !== false) {
-                notifyClientObserver(clientOptions?.onError, [result2.error], "API client onError");
-              }
-            } else {
-              emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
-              if (opts?.callCallbacks !== false) {
-                notifyClientObserver(
-                  clientOptions?.onSuccess,
-                  [result2.data],
-                  "API client onSuccess"
-                );
-              }
-            }
-            return result2;
-          } finally {
-            if (inflightState.get(cacheKey) === inflightEntry) {
-              inflightState.delete(cacheKey);
-            }
-            if (requestContextError && requestScopedState) {
-              requestScopedState.retired = true;
-              if (scopedRequestState === requestScopedState) scopedRequestState = void 0;
-            }
-            if (requestScopedState?.retired && requestScopedState.inflight.size === 0) {
-              requestScopedState.cache.dispose();
-            }
-          }
-        } finally {
-          if (readOwner && readOwners?.get(resolvedCacheKey) === readOwner) {
-            readOwners.delete(resolvedCacheKey);
-          }
-          unsubscribeInvalidation?.();
-          release();
-        }
-      }, "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
-        };
-        const refetches = /* @__PURE__ */ new Set();
-        for (const target of invalidateOptions.targets) {
-          const targetKey = resolveTargetKey(
-            routeMeta,
-            target,
-            void 0,
-            baseURL,
-            defaultHeaders,
-            transport ? baseURL : void 0
-          );
-          if (!targetKey) continue;
-          const existing = cacheState.get(targetKey);
-          const invalidatedAt = Date.now();
-          cacheState.invalidate(targetKey, invalidatedAt);
-          if (existing) {
-            const stack = optimisticState.get(targetKey);
-            if (stack?.renderedEntry === existing) {
-              stack.invalidatedAt = invalidatedAt;
-              stack.renderedEntry = cacheState.get(targetKey);
-            }
-          }
-          emitStatus("invalidated", { key: targetKey });
-          const refetch = existing?.[API_CACHE_REFETCH];
-          if (invalidateOptions.refetch && refetch) {
-            refetches.add(refetch);
-          }
-        }
-        for (const refetch of refetches) refetch();
-      }, "invalidateTargets");
-      const optimisticSnapshots = requestContextError ? [] : applyOptimisticUpdates();
-      if (isCacheEnabled && !requestContextError && !cancellation.signal?.aborted) {
-        if (entry && !isStale && policy !== "network-only") {
-          emitStatus("success", { data: entry.data });
-          notifyClientObserver(clientOptions?.onSuccess, [entry.data], "API client onSuccess");
-          notifyClientObserver(
-            clientOptions?.onSettled,
-            [entry.data, null],
-            "API client onSettled"
-          );
-          return { data: entry.data, error: null, key: cacheKey };
-        }
-        if (entry && isStale && policy === "stale-while-revalidate") {
-          emitStatus("success", { data: entry.data });
-          notifyClientObserver(clientOptions?.onSuccess, [entry.data], "API client onSuccess");
-          notifyClientObserver(
-            clientOptions?.onSettled,
-            [entry.data, null],
-            "API client onSettled"
-          );
-          void executeNetwork({ isBackground: true, callCallbacks: false });
-          return { data: entry.data, error: null, key: cacheKey };
-        }
-      }
-      const result = await executeNetwork();
-      if (result.error) {
-        if (cancellation.signal?.aborted) {
-          settleOptimisticUpdates(cacheState, optimisticState, optimisticSnapshots, "rollback");
-        } else {
-          rollbackOptimisticUpdates(optimisticSnapshots);
-          invalidateUncommittedOptimisticUpdates(optimisticSnapshots);
-        }
-      } else {
-        settleOptimisticUpdates(cacheState, optimisticState, optimisticSnapshots, "commit");
-        await invalidateTargets();
-      }
-      notifyClientObserver(
-        clientOptions?.onSettled,
-        [result.data, result.error],
-        "API client onSettled"
-      );
-      return result;
-    } finally {
-      cancellation.dispose();
-    }
-  }, "request");
-  const client = createNestedProxy(
-    [],
-    request,
-    routeMeta,
-    baseURL,
-    isSameOriginAPIBaseURL(baseURL),
-    rootAliases,
-    options.routes ? new ClientRouteManifest(options.routes) : void 0
-  );
-  return { client, request };
-}
-__name(createAPIClientRuntime, "createAPIClientRuntime");
-async function readAPIResponseData(response, method) {
-  if (method === "HEAD" || response.status === 204 || response.status === 205 || response.status === 304) {
-    return void 0;
-  }
-  if (!response.headers?.get && typeof response.json === "function") {
-    return readResponseJSON(response);
-  }
-  if (response.body === null) return void 0;
-  if (isJSONStreamResponse(response)) {
-    return readJSONStream(response);
-  }
-  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  if (typeof response.arrayBuffer === "function") {
-    const data = await response.arrayBuffer();
-    if (data.byteLength === 0) return void 0;
-    if (!contentType || contentType === "application/json" || contentType.endsWith("+json")) {
-      return parseResponseJSON(new TextDecoder().decode(data));
-    }
-    if (contentType.startsWith("text/") || contentType === "application/xml" || contentType === "application/xhtml+xml" || contentType === "application/graphql") {
-      return new TextDecoder().decode(data);
-    }
-    return data;
-  }
-  if ((!contentType || contentType === "application/json" || contentType.endsWith("+json")) && typeof response.json === "function") {
-    return readResponseJSON(response);
-  }
-  if ((contentType?.startsWith("text/") || contentType === "application/xml" || contentType === "application/xhtml+xml" || contentType === "application/graphql") && typeof response.text === "function") {
-    return response.text();
-  }
-  if (typeof response.json === "function") {
-    return readResponseJSON(response);
-  }
-  return void 0;
-}
-__name(readAPIResponseData, "readAPIResponseData");
-var _APIResponseDecodeError = class _APIResponseDecodeError extends Error {
-  constructor(cause) {
-    super(cause instanceof Error ? cause.message : "Failed to decode JSON response");
-    this.name = "APIResponseDecodeError";
-    this.cause = cause;
-  }
-};
-__name(_APIResponseDecodeError, "APIResponseDecodeError");
-var APIResponseDecodeError = _APIResponseDecodeError;
-function parseResponseJSON(value) {
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    throw new APIResponseDecodeError(error);
-  }
-}
-__name(parseResponseJSON, "parseResponseJSON");
-async function readResponseJSON(response) {
-  try {
-    return await response.json();
-  } catch (error) {
-    if (error instanceof SyntaxError) throw new APIResponseDecodeError(error);
-    throw error;
-  }
-}
-__name(readResponseJSON, "readResponseJSON");
-function createNestedProxy(path, client, routeMeta, baseURL, sameOrigin, rootAliases, manifest, bound = {}) {
-  const target = /* @__PURE__ */ __name(() => {
-  }, "target");
-  const proxy = new Proxy(target, {
-    // When accessing a property (api.hello)
-    get(_target, prop) {
-      if (prop === "then") return void 0;
-      if (prop === "$params") {
-        return (params) => {
-          if (!manifest)
-            throw new TypeError(
-              "$params requires createAPIClient({ routes: apiRoutes }) from the generated API manifest."
-            );
-          const scope = manifest.bind(buildProxyRoutePath(path), params);
-          return createNestedProxy(
-            [...path, scope.segment],
-            client,
-            routeMeta,
-            baseURL,
-            sameOrigin,
-            rootAliases,
-            manifest,
-            Object.freeze({ ...bound, ...scope.params })
-          );
-        };
-      }
-      if (prop === FARM_API_ROUTE_REF_SYMBOL) {
-        return path.length > 0;
-      }
-      if (prop === FARM_API_ROUTE_META_SYMBOL) {
-        let metadata;
-        try {
-          metadata = resolveRouteMeta({ path, baseURL, manifest, bound });
-        } catch {
-          return null;
-        }
-        const requestURL = resolveFarmAPIRequestURL(metadata.routePath, baseURL);
-        return Object.freeze({
-          path: `${requestURL.pathname}${requestURL.search}${requestURL.hash}`,
-          method: metadata.method,
-          baseURL: requestURL.origin,
-          sameOrigin
-        });
-      }
-      if (path.length === 0 && typeof prop === "string" && rootAliases && Object.prototype.hasOwnProperty.call(rootAliases, prop)) {
-        return rootAliases[prop];
-      }
-      if (typeof prop !== "string") {
-        return Reflect.get(_target, prop);
-      }
-      return createNestedProxy(
-        [...path, prop],
-        client,
-        routeMeta,
-        baseURL,
-        sameOrigin,
-        rootAliases,
-        manifest,
-        bound
-      );
-    },
-    // When calling as a function
-    apply(_target, _thisArg, args) {
-      const lastPart = path[path.length - 1];
-      const httpMethods = ["get", "head", "query", "post", "put", "delete", "patch", "options"];
-      if (httpMethods.includes(lastPart)) {
-        const routePath = buildProxyRoutePath(path.slice(0, -1));
-        const method = lastPart.toUpperCase();
-        const [options, clientOptions] = args;
-        const resolved = manifest ? manifest.resolve(routePath, method, bound, options) : routePath;
-        if (!manifest && options?.params)
-          throw new TypeError("Dynamic params require the generated routes manifest.");
-        return client(resolved, method, options, clientOptions);
-      } else {
-        const routePath = buildProxyRoutePath(path);
-        const [options, clientOptions] = args;
-        const method = options?.method || "GET";
-        const resolved = manifest ? manifest.resolve(routePath, method, bound, options) : routePath;
-        return client(resolved, method, options, clientOptions);
-      }
-    }
-  });
-  routeMeta.set(proxy, { path: [...path], baseURL, manifest, bound });
-  return proxy;
-}
-__name(createNestedProxy, "createNestedProxy");
-function buildProxyRoutePath(path) {
-  return "/api/" + path.join("/").replace(/^\/+/, "");
-}
-__name(buildProxyRoutePath, "buildProxyRoutePath");
-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");
-var API_CACHE_REFETCH = /* @__PURE__ */ Symbol.for("farm.api.cache-refetch");
-function createCacheRefetch(request, path, method, input, key, cache, options, onError) {
-  const readOptions = {
-    cache: { ...cache, key, policy: "network-only", dedupeMs: 0 },
-    retry: options?.retry,
-    timeoutMs: options?.timeoutMs
-  };
-  return () => {
-    void request(path, method, input, readOptions).catch((error) => {
-      notifyClientObserver(onError, [normalizeError(error)]);
-    });
-  };
-}
-__name(createCacheRefetch, "createCacheRefetch");
-var optimisticStates = /* @__PURE__ */ new WeakMap();
-var cacheReadOwners = /* @__PURE__ */ new WeakMap();
-function getCacheReadOwners(cache) {
-  let owners = cacheReadOwners.get(cache);
-  if (!owners) {
-    owners = /* @__PURE__ */ new Map();
-    cacheReadOwners.set(cache, owners);
-  }
-  return owners;
-}
-__name(getCacheReadOwners, "getCacheReadOwners");
-function getOptimisticState(cache) {
-  let state = optimisticStates.get(cache);
-  if (!state) {
-    state = /* @__PURE__ */ new Map();
-    optimisticStates.set(cache, state);
-  }
-  return state;
-}
-__name(getOptimisticState, "getOptimisticState");
-function applyOptimisticLayer(entry, layer) {
-  let data = entry?.data;
-  for (const updater of layer.updaters) data = updater(data);
-  return {
-    data,
-    updatedAt: layer.updatedAt,
-    staleAt: entry?.staleAt ?? layer.staleAt,
-    gcAt: entry?.gcAt ?? layer.gcAt,
-    invalidatedAt: entry?.invalidatedAt,
-    [API_CACHE_REFETCH]: entry?.[API_CACHE_REFETCH]
-  };
-}
-__name(applyOptimisticLayer, "applyOptimisticLayer");
-function storeOptimisticEntry(cacheState, key, stack, entry) {
-  if (!entry) {
-    cacheState.delete(key);
-    stack.renderedEntry = void 0;
-    return;
-  }
-  cacheState.set(key, entry);
-  if (stack.invalidatedAt !== void 0) {
-    cacheState.invalidate(key, stack.invalidatedAt);
-  }
-  stack.renderedEntry = cacheState.get(key);
-}
-__name(storeOptimisticEntry, "storeOptimisticEntry");
-function reconcileOptimisticInvalidation(cacheState, key, stack) {
-  const current = cacheState.get(key);
-  const rendered = stack.renderedEntry;
-  if (current === rendered) return true;
-  if (!current || !rendered || current.data !== rendered.data || current.updatedAt !== rendered.updatedAt || current.gcAt !== rendered.gcAt || current.status !== rendered.status || current.error !== rendered.error || current.fetching !== rendered.fetching || current.staleAt !== 0 || current.invalidatedAt === void 0) {
-    return false;
-  }
-  stack.invalidatedAt = current.invalidatedAt;
-  stack.renderedEntry = current;
-  return true;
-}
-__name(reconcileOptimisticInvalidation, "reconcileOptimisticInvalidation");
-function renderOptimisticStack(cacheState, key, stack) {
-  let entry = stack.entry ? { ...stack.entry } : void 0;
-  for (const layer of stack.layers) entry = applyOptimisticLayer(entry, layer);
-  storeOptimisticEntry(cacheState, key, stack, entry);
-}
-__name(renderOptimisticStack, "renderOptimisticStack");
-function settleOptimisticUpdates(cacheState, optimisticState, snapshots, outcome) {
-  const settledKeys = [];
-  for (const snapshot of snapshots) {
-    const stack = optimisticState.get(snapshot.key);
-    if (stack !== snapshot.stack) continue;
-    if (!reconcileOptimisticInvalidation(cacheState, snapshot.key, stack)) {
-      optimisticState.delete(snapshot.key);
-      continue;
-    }
-    if (outcome === "rollback") {
-      stack.layers = stack.layers.filter((layer) => layer !== snapshot.layer);
-    } else {
-      snapshot.layer.committed = true;
-      if (outcome === "invalidate") stack.invalidatedAt = Date.now();
-    }
-    while (stack.layers[0]?.committed) {
-      stack.entry = applyOptimisticLayer(stack.entry, stack.layers.shift());
-    }
-    renderOptimisticStack(cacheState, snapshot.key, stack);
-    if (stack.layers.length === 0) optimisticState.delete(snapshot.key);
-    settledKeys.push(snapshot.key);
-  }
-  return settledKeys;
-}
-__name(settleOptimisticUpdates, "settleOptimisticUpdates");
-function buildCacheKey(method, path, input, baseURL, defaultHeaders) {
-  const keyInput = input && typeof input === "object" ? {
-    query: input.query,
-    body: input.body,
-    ...method === "QUERY" ? {
-      contentType: getHeader(input.headers, "content-type") ?? getHeader(defaultHeaders, "content-type") ?? "application/json",
-      contentEncoding: getHeader(input.headers, "content-encoding") ?? getHeader(defaultHeaders, "content-encoding")
-    } : {}
-  } : input;
-  const url = resolveFarmAPIRequestURL(path, baseURL);
-  return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
-}
-__name(buildCacheKey, "buildCacheKey");
-function isSameOriginAPIBaseURL(baseURL) {
-  if (typeof window === "undefined") return baseURL.startsWith("/");
-  return resolveFarmAPIRequestURL("/api", baseURL).origin === window.location.origin;
-}
-__name(isSameOriginAPIBaseURL, "isSameOriginAPIBaseURL");
-function stableStringify(value) {
-  if (value === null || value === void 0) return String(value);
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "bigint") return `bigint:${value.toString()}`;
-  if (typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  if (value instanceof URLSearchParams) {
-    return `urlsearchparams:${stableStringify(Array.from(value.entries()))}`;
-  }
-  const keys = Object.keys(value).sort();
-  const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
-  return `{${entries.join(",")}}`;
-}
-__name(stableStringify, "stableStringify");
-function getHeader(headers, name) {
-  if (!headers || typeof headers !== "object") return void 0;
-  if (typeof Headers !== "undefined" && headers instanceof Headers) {
-    return headers.get(name) ?? void 0;
-  }
-  const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
-  return entry?.[1] === void 0 ? void 0 : String(entry[1]);
-}
-__name(getHeader, "getHeader");
-function getRequestCacheContext(options, input, scope) {
-  const credentials = options.credentials ?? "same-origin";
-  const headers = new Headers(options.headers);
-  const requestHeaders = input && typeof input === "object" && "headers" in input ? input.headers : void 0;
-  if (requestHeaders) {
-    new Headers(requestHeaders).forEach((value, key) => headers.set(key, value));
-  }
-  const carriesBrowserIdentity = credentials !== "omit" || [...headers].length > 0;
-  if (scope !== "client" && !carriesBrowserIdentity) return void 0;
-  return stableStringify({
-    credentials,
-    headers: [...headers].sort(([left], [right]) => left.localeCompare(right))
-  });
-}
-__name(getRequestCacheContext, "getRequestCacheContext");
-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", defaultHeaders, localBaseURL) {
-  if (!target) return null;
-  if (typeof target === "string") return target;
-  if (typeof target === "function") {
-    const meta = routeMeta.get(target);
-    if (!meta) return null;
-    const { method, routePath } = resolveRouteMeta(meta, input);
-    return buildCacheKey(
-      method,
-      routePath,
-      input ?? {},
-      localBaseURL ?? meta.baseURL,
-      defaultHeaders
-    );
-  }
-  if (Array.isArray(target)) {
-    const [route, routeInput] = target;
-    if (typeof route === "function") {
-      return resolveTargetKey(routeMeta, route, routeInput, baseURL, defaultHeaders, localBaseURL);
-    }
-    return normalizeFarmClientCacheKey(target);
-  }
-  if ("key" in target) return normalizeFarmClientCacheKey(target.key);
-  if ("path" in target) {
-    const method = target.method ?? "GET";
-    return buildCacheKey(method, target.path, target.input ?? {}, baseURL, defaultHeaders);
-  }
-  return null;
-}
-__name(resolveTargetKey, "resolveTargetKey");
-function resolveRouteMeta(meta, input) {
-  const httpMethods = ["get", "head", "query", "post", "put", "delete", "patch", "options"];
-  const lastPart = meta.path[meta.path.length - 1];
-  if (lastPart && httpMethods.includes(lastPart)) {
-    return {
-      routePath: meta.manifest ? meta.manifest.resolve(
-        buildProxyRoutePath(meta.path.slice(0, -1)),
-        lastPart.toUpperCase(),
-        meta.bound ?? {},
-        input
-      ) : buildProxyRoutePath(meta.path.slice(0, -1)),
-      method: lastPart.toUpperCase()
-    };
-  }
-  return {
-    routePath: meta.manifest ? meta.manifest.resolve(buildProxyRoutePath(meta.path), "GET", meta.bound ?? {}, input) : buildProxyRoutePath(meta.path),
-    method: "GET"
-  };
-}
-__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 notifyResponseObserver(observer, data, error, event) {
-  notifyClientObserver(observer, [data, error, event], "API client onResponse");
-}
-__name(notifyResponseObserver, "notifyResponseObserver");
-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 appendAPIQuery(searchParams, query) {
-  if (query instanceof URLSearchParams) {
-    const keys = new Set(query.keys());
-    for (const key of keys) searchParams.delete(key);
-    query.forEach((value, key) => searchParams.append(key, value));
-    return;
-  }
-  if (!query || typeof query !== "object" || Array.isArray(query)) {
-    throw new TypeError("API query input must be an object or URLSearchParams.");
-  }
-  for (const [key, value] of Object.entries(query)) {
-    if (value === void 0 || value === null) continue;
-    searchParams.delete(key);
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item === void 0 || item === null) continue;
-      if (!isAPIQueryPrimitive(item)) {
-        throw new TypeError(
-          `API query parameter "${key}" must be a string, number, boolean, bigint, or an array of those values.`
-        );
-      }
-      searchParams.append(key, String(item));
-    }
-  }
-}
-__name(appendAPIQuery, "appendAPIQuery");
-function isAPIQueryPrimitive(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
-}
-__name(isAPIQueryPrimitive, "isAPIQueryPrimitive");
-function createResponseError2(response, data, cause) {
-  const expected = readEndpointErrorEnvelope(data);
-  if (expected) {
-    return new APIClientError(expected.code, expected.data, {
-      status: response.status,
-      message: expected.message,
-      response
-    });
-  }
-  const error = new APIClientError("http_error", data, {
-    status: response.status,
-    message: `HTTP ${response.status}: ${response.statusText}`,
-    response
-  });
-  if (cause !== void 0) error.cause = cause;
-  return error;
-}
-__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");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  APIClientError,
-  createAPIClient,
-  createApiClients,
-  createServerAPIClient
-});
+exports.APIClientError = _chunkIXTFU4PLcjs.APIClientError; exports.createAPIClient = _chunkIXTFU4PLcjs.createAPIClient; exports.createApiClients = _chunkIXTFU4PLcjs.createApiClients; exports.createServerAPIClient = _chunkIXTFU4PLcjs.createServerAPIClient;