@farm.js/core 0.1.0-beta.0

package/dist/client.cjs

@@ -0,0 +1,4571 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  FarmClientPluginManager: () => FarmClientPluginManager,
+  IntegrationClientError: () => IntegrationClientError,
+  Link: () => Link,
+  SPARouter: () => SPARouter,
+  api: () => api,
+  createAPIClient: () => createAPIClient,
+  createClientPluginManager: () => createClientPluginManager,
+  createIntegrationApi: () => createIntegrationApi,
+  createIntegrationClient: () => createIntegrationClient,
+  createIntegrationClients: () => createIntegrationClients,
+  createIntegrationServerClient: () => createIntegrationServerClient,
+  createIntegrations: () => createIntegrations,
+  createServerAPIClient: () => createServerAPIClient,
+  createStore: () => createStore,
+  defineIntegrationAPI: () => defineIntegrationAPI,
+  defineIntegrationAPIOperation: () => defineIntegrationAPIOperation,
+  endpoint: () => endpoint,
+  fetchServerQuery: () => fetchServerQuery,
+  getIntegrationAPIManifest: () => getIntegrationAPIManifest,
+  getRouter: () => getRouter2,
+  installChunkErrorRecovery: () => installChunkErrorRecovery,
+  integrationClients: () => integrationClients,
+  integrationsClient: () => integrationsClient,
+  integrationsServer: () => integrationsServer,
+  isChunkLoadError: () => isChunkLoadError,
+  navigateTo: () => navigateTo,
+  prefetch: () => prefetch,
+  prefetchServerQuery: () => prefetchServerQuery,
+  pushState: () => pushState,
+  readPageState: () => readPageState,
+  replaceState: () => replaceState,
+  useBlocker: () => useBlocker,
+  useNavigation: () => useNavigation,
+  usePageState: () => usePageState,
+  useRouter: () => useRouter,
+  useScrollRestoration: () => useScrollRestoration,
+  useServerQuery: () => useServerQuery
+});
+module.exports = __toCommonJS(client_exports);
+
+// 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, runtime]) => [
+      key,
+      runtime.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, api2]) => [key, api2, api2]);
+}
+__name(resolveAutomaticClientNamespaces, "resolveAutomaticClientNamespaces");
+function resolveAutomaticServerNamespaces() {
+  return Object.entries(getRegisteredIntegrationsLocal()).flatMap(([key, source]) => {
+    const api2 = tryResolveSourceAPI(source);
+    return api2 ? [[key, api2, source]] : [];
+  });
+}
+__name(resolveAutomaticServerNamespaces, "resolveAutomaticServerNamespaces");
+function appendQuery(url, query) {
+  if (!query) {
+    return;
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item != null) {
+          url.searchParams.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+}
+__name(appendQuery, "appendQuery");
+function appendHeaders(target, source) {
+  if (!source) {
+    return;
+  }
+  const headers = new Headers(source);
+  headers.forEach((value, key) => {
+    target.set(key, value);
+  });
+}
+__name(appendHeaders, "appendHeaders");
+var DEFAULT_FORWARDED_HEADERS = [
+  "authorization",
+  "cookie",
+  "x-client-ip",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-real-ip"
+];
+function resolveRequestLike(request) {
+  if (!request) {
+    return void 0;
+  }
+  if (request instanceof Request) {
+    return {
+      url: request.url,
+      headers: request.headers
+    };
+  }
+  return {
+    url: request.url,
+    headers: request.headers ? new Headers(request.headers) : void 0
+  };
+}
+__name(resolveRequestLike, "resolveRequestLike");
+function resolveServerBaseURL(explicitBaseURL, request) {
+  if (explicitBaseURL) {
+    return explicitBaseURL;
+  }
+  if (request?.url) {
+    try {
+      return new URL(request.url).origin;
+    } catch {
+    }
+  }
+  const headers = request?.headers;
+  const host = headers?.get("x-forwarded-host") || headers?.get("host");
+  if (host) {
+    const proto = headers?.get("x-forwarded-proto") || "http";
+    return `${proto}://${host}`;
+  }
+  return "http://localhost:3000";
+}
+__name(resolveServerBaseURL, "resolveServerBaseURL");
+function resolveForwardHeaders(request, forwardHeaders) {
+  if (!request?.headers || forwardHeaders === false) {
+    return new Headers();
+  }
+  const allowed = Array.isArray(forwardHeaders) && forwardHeaders.length > 0 ? new Set(forwardHeaders.map((item) => item.toLowerCase())) : new Set(DEFAULT_FORWARDED_HEADERS);
+  const headers = new Headers();
+  request.headers.forEach((value, key) => {
+    if (allowed.has(key.toLowerCase())) {
+      headers.set(key, value);
+    }
+  });
+  return headers;
+}
+__name(resolveForwardHeaders, "resolveForwardHeaders");
+function createBody(format, body, headers) {
+  if (body == null || format === "none") {
+    return void 0;
+  }
+  if (format === "form") {
+    if (body instanceof FormData || body instanceof URLSearchParams) {
+      return body;
+    }
+    const form = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value == null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item != null) {
+            form.append(key, String(item));
+          }
+        }
+        continue;
+      }
+      form.set(key, String(value));
+    }
+    headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+    return form;
+  }
+  headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+__name(createBody, "createBody");
+async function parseResponseData(response) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}
+__name(parseResponseData, "parseResponseData");
+async function safeParseResponseData(response) {
+  try {
+    return await parseResponseData(response);
+  } catch {
+    return void 0;
+  }
+}
+__name(safeParseResponseData, "safeParseResponseData");
+function createResponseError(response, errorData) {
+  const message = typeof errorData === "string" ? errorData : typeof errorData === "object" && errorData ? String(
+    errorData.error || errorData.message || response.statusText
+  ) : response.statusText || "Integration request failed.";
+  return new IntegrationClientError(message, response, errorData);
+}
+__name(createResponseError, "createResponseError");
+function normalizeExecutionError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return new Error(error);
+  }
+  return new Error("Integration request failed.");
+}
+__name(normalizeExecutionError, "normalizeExecutionError");
+async function finalizeOperationResponse(operation2, response) {
+  if (!response.ok) {
+    const errorData = await safeParseResponseData(response);
+    return {
+      data: null,
+      error: createResponseError(response, errorData)
+    };
+  }
+  if (operation2.responseFormat === "response") {
+    return {
+      data: response,
+      error: null
+    };
+  }
+  return {
+    data: await parseResponseData(response),
+    error: null
+  };
+}
+__name(finalizeOperationResponse, "finalizeOperationResponse");
+async function executeClientOperation(operation2, input, options, requestOptions) {
+  try {
+    if (!operation2.path) {
+      return {
+        data: null,
+        error: new Error(
+          "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
+        )
+      };
+    }
+    const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+    const url = new URL(operation2.path, baseURL);
+    appendQuery(url, input.query);
+    const headers = new Headers({
+      "x-farm-integration-client": "1",
+      ...options.headers,
+      ...operation2.headers,
+      ...requestOptions?.headers
+    });
+    if (operation2.responseFormat !== "response") {
+      headers.set("accept", "application/json");
+    }
+    appendIntegrationClientDataHeader(
+      headers,
+      mergeIntegrationClientData(options.data, requestOptions?.data)
+    );
+    const response = await fetch(url.toString(), {
+      method: operation2.method,
+      headers,
+      body: createBody(operation2.bodyFormat, input.body, headers),
+      credentials: requestOptions?.credentials ?? operation2.credentials ?? options.credentials ?? "include",
+      signal: requestOptions?.signal
+    });
+    if (!response.ok) {
+      const errorData = await safeParseResponseData(response);
+      return {
+        data: null,
+        error: createResponseError(response, errorData)
+      };
+    }
+    if (operation2.responseFormat === "response") {
+      return {
+        data: response,
+        error: null
+      };
+    }
+    return {
+      data: await parseResponseData(response),
+      error: null
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: normalizeExecutionError(error)
+    };
+  }
+}
+__name(executeClientOperation, "executeClientOperation");
+async function executeServerOperation(operation2, input, options, requestOptions, integrationKey, source) {
+  try {
+    if (!operation2.path) {
+      return {
+        data: null,
+        error: new Error(
+          "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
+        )
+      };
+    }
+    const serverRequestOptions = requestOptions && ("request" in requestOptions || "baseURL" in requestOptions || "forwardHeaders" in requestOptions) ? requestOptions : void 0;
+    const currentRequest = serverRequestOptions?.request instanceof Request ? serverRequestOptions.request : options.request instanceof Request ? options.request : resolveCurrentRequestLocal();
+    const request = resolveRequestLike(
+      serverRequestOptions?.request ?? options.request ?? currentRequest
+    );
+    const baseURL = resolveServerBaseURL(serverRequestOptions?.baseURL ?? options.baseURL, request);
+    const url = new URL(operation2.path, baseURL);
+    appendQuery(url, input.query);
+    const headers = new Headers();
+    appendHeaders(
+      headers,
+      resolveForwardHeaders(
+        request,
+        serverRequestOptions?.forwardHeaders ?? options.forwardHeaders
+      )
+    );
+    appendHeaders(headers, options.headers);
+    appendHeaders(headers, operation2.headers);
+    appendHeaders(headers, requestOptions?.headers);
+    headers.set("x-farm-integration-client", "1");
+    if (operation2.responseFormat !== "response") {
+      headers.set("accept", "application/json");
+    }
+    const data = mergeIntegrationClientData(options.data, requestOptions?.data);
+    if (integrationKey) {
+      const runtime = "kind" in (source || {}) && source.kind === "farm-integration" ? getRegisteredIntegrationRuntimeLocal(integrationKey) || {
+        integration: source,
+        config: {},
+        isDev: process.env.NODE_ENV !== "production",
+        isProd: process.env.NODE_ENV === "production"
+      } : getRegisteredIntegrationRuntimeLocal(integrationKey);
+      if (runtime) {
+        const dispatchIntegrationRequest = resolveIntegrationRequestDispatcherLocal();
+        const directResponse = dispatchIntegrationRequest ? await dispatchIntegrationRequest(
+          runtime,
+          new Request(url.toString(), {
+            method: operation2.method,
+            headers,
+            body: createBody(operation2.bodyFormat, input.body, headers)
+          }),
+          {
+            currentRequest,
+            data,
+            internal: true
+          }
+        ) : null;
+        if (directResponse) {
+          return await finalizeOperationResponse(operation2, directResponse);
+        }
+      }
+    }
+    appendIntegrationClientDataHeader(headers, data);
+    const response = await fetch(url.toString(), {
+      method: operation2.method,
+      headers,
+      body: createBody(operation2.bodyFormat, input.body, headers),
+      credentials: requestOptions?.credentials ?? operation2.credentials ?? options.credentials ?? "include",
+      signal: requestOptions?.signal
+    });
+    return await finalizeOperationResponse(operation2, response);
+  } catch (error) {
+    return {
+      data: null,
+      error: normalizeExecutionError(error)
+    };
+  }
+}
+__name(executeServerOperation, "executeServerOperation");
+function createIntegrationClient(sources, options = {}) {
+  const rawSources = "integrations" in sources ? sources.integrations : sources;
+  const isServer = options.isServer === true;
+  const namespaces = Object.entries(rawSources).map(([key, source]) => {
+    const api2 = tryResolveSourceAPI(source);
+    if (!api2) {
+      return null;
+    }
+    return [key, api2, source];
+  }).filter(
+    (value) => value !== null
+  );
+  const cache = /* @__PURE__ */ new Map();
+  const integrationNamespaces = new Proxy(
+    {},
+    {
+      get(target, property) {
+        if (typeof property !== "string") {
+          return void 0;
+        }
+        if (Reflect.has(target, property)) {
+          return Reflect.get(target, property);
+        }
+        if (cache.has(property)) {
+          return cache.get(property);
+        }
+        const match = namespaces.find(([key]) => key === property);
+        if (!match) {
+          return void 0;
+        }
+        const namespace = isServer ? createServerNamespaceProxy(
+          match[0],
+          match[2],
+          match[1],
+          options
+        ) : createNamespaceProxy(match[1], options);
+        cache.set(property, namespace);
+        return namespace;
+      }
+    }
+  );
+  if ("integrations" in sources) {
+    Object.defineProperty(integrationNamespaces, "integrations", {
+      value: integrationNamespaces,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    return integrationNamespaces;
+  }
+  return integrationNamespaces;
+}
+__name(createIntegrationClient, "createIntegrationClient");
+function createAutomaticIntegrationAliases(isServer, options = {}) {
+  const cache = isServer ? /* @__PURE__ */ new Map() : null;
+  const integrationNamespaces = new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property !== "string") {
+          return void 0;
+        }
+        if (property === "integrations") {
+          return integrationNamespaces;
+        }
+        if (cache?.has(property)) {
+          return cache.get(property);
+        }
+        const namespaces = isServer ? resolveAutomaticServerNamespaces() : resolveAutomaticClientNamespaces();
+        const match = namespaces.find(([key]) => key === property);
+        if (!match) {
+          return void 0;
+        }
+        const namespace = isServer ? createServerNamespaceProxy(
+          match[0],
+          match[2],
+          match[1],
+          options
+        ) : createNamespaceProxy(match[1], options);
+        cache?.set(property, namespace);
+        return namespace;
+      }
+    }
+  );
+  Object.defineProperty(integrationNamespaces, "integrations", {
+    value: integrationNamespaces,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return integrationNamespaces;
+}
+__name(createAutomaticIntegrationAliases, "createAutomaticIntegrationAliases");
+function integrationsClient(options = {}) {
+  return createAutomaticIntegrationAliases(
+    false,
+    options
+  );
+}
+__name(integrationsClient, "integrationsClient");
+function integrationsServer(options = {}) {
+  return createAutomaticIntegrationAliases(true, {
+    ...options,
+    isServer: true
+  });
+}
+__name(integrationsServer, "integrationsServer");
+function createIntegrationServerClient(sources, options = {}) {
+  return createIntegrationClient(sources, {
+    ...options,
+    isServer: true
+  });
+}
+__name(createIntegrationServerClient, "createIntegrationServerClient");
+function createIntegrationApi(sources, options = {}) {
+  const client = createIntegrationClient(sources, options);
+  return {
+    ...client,
+    server(serverOptions = {}) {
+      return createIntegrationServerClient(sources, {
+        ...options,
+        ...serverOptions
+      });
+    }
+  };
+}
+__name(createIntegrationApi, "createIntegrationApi");
+function isIntegrationClientOptionsInput(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && ("baseURL" in value || "headers" in value || "credentials" in value || "data" in value || "isServer" in value);
+}
+__name(isIntegrationClientOptionsInput, "isIntegrationClientOptionsInput");
+function resolveIntegrationServerOptions(clientOptions = {}, serverOptions = {}) {
+  const data = mergeIntegrationClientData(clientOptions.data, serverOptions.data);
+  return {
+    baseURL: clientOptions.baseURL,
+    headers: clientOptions.headers,
+    credentials: clientOptions.credentials,
+    ...serverOptions,
+    ...data ? { data } : {}
+  };
+}
+__name(resolveIntegrationServerOptions, "resolveIntegrationServerOptions");
+function createIntegrationClients(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0 || isIntegrationClientOptionsInput(sources)) {
+    const automaticClientOptions = isIntegrationClientOptionsInput(sources) ? sources : {};
+    const automaticServerOptions = arguments.length > 1 ? clientOptions : void 0;
+    return {
+      api: integrationsServer(
+        resolveIntegrationServerOptions(
+          automaticClientOptions,
+          automaticServerOptions
+        )
+      ),
+      apiClient: integrationsClient(automaticClientOptions)
+    };
+  }
+  const explicitSources = sources && "integrations" in sources ? sources.integrations : sources;
+  return {
+    api: createIntegrationServerClient(
+      {
+        integrations: explicitSources
+      },
+      resolveIntegrationServerOptions(clientOptions, serverOptions)
+    ),
+    apiClient: createIntegrationClient(
+      {
+        integrations: explicitSources
+      },
+      clientOptions
+    )
+  };
+}
+__name(createIntegrationClients, "createIntegrationClients");
+function createIntegrations(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0) {
+    return createIntegrationClients();
+  }
+  return createIntegrationClients(
+    sources,
+    clientOptions,
+    serverOptions
+  );
+}
+__name(createIntegrations, "createIntegrations");
+function createClientSafeIntegrationAPI(api2) {
+  if (!api2) {
+    return void 0;
+  }
+  const entries = Object.entries(api2).map(([key, value]) => {
+    if (isOperation(value)) {
+      return [
+        key,
+        {
+          kind: value.kind,
+          path: value.path,
+          method: value.method,
+          bodyFormat: value.bodyFormat,
+          responseFormat: value.responseFormat,
+          credentials: value.credentials,
+          isServer: value.isServer,
+          __pathless: value.__pathless
+        }
+      ];
+    }
+    if (value && typeof value === "object") {
+      return [key, createClientSafeIntegrationAPI(value)];
+    }
+    return [key, value];
+  });
+  return Object.fromEntries(entries);
+}
+__name(createClientSafeIntegrationAPI, "createClientSafeIntegrationAPI");
+function getIntegrationAPIManifest() {
+  const manifestEntries = Object.entries(getRegisteredIntegrationsLocal()).map(([key, integration]) => {
+    const api2 = createClientSafeIntegrationAPI(integration.api);
+    return api2 ? [key, api2] : null;
+  }).filter((value) => value !== null);
+  return Object.fromEntries(manifestEntries);
+}
+__name(getIntegrationAPIManifest, "getIntegrationAPIManifest");
+function integrationClients(sources, clientOptions, serverOptions) {
+  if (arguments.length === 0) {
+    return createIntegrationClients();
+  }
+  return createIntegrationClients(
+    sources,
+    clientOptions,
+    serverOptions
+  );
+}
+__name(integrationClients, "integrationClients");
+function resolveSingleNamespaceOperation(api2) {
+  const entries = Object.entries(api2);
+  if (entries.length !== 1) {
+    return null;
+  }
+  const [, value] = entries[0];
+  return isOperation(value) ? value : null;
+}
+__name(resolveSingleNamespaceOperation, "resolveSingleNamespaceOperation");
+function createClientOperationCaller(operation2, property, options) {
+  if (operation2.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(operation2, input, options, requestOptions);
+  };
+}
+__name(createClientOperationCaller, "createClientOperationCaller");
+function createServerOperationCaller(operation2, 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(
+      operation2,
+      input,
+      options,
+      requestOptions,
+      integrationKey,
+      source
+    );
+  };
+}
+__name(createServerOperationCaller, "createServerOperationCaller");
+function createNamespaceProxy(api2, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const directOperation = resolveSingleNamespaceOperation(api2);
+  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 = api2[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, api2, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const directOperation = resolveSingleNamespaceOperation(api2);
+  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 = api2[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/observability.ts
+var runtimeHandlers = /* @__PURE__ */ new Set();
+var observabilityState = {
+  logs: false,
+  handlers: []
+};
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (!shouldEmitFarmEvent(event)) {
+    return event;
+  }
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  for (const handler of [...observabilityState.handlers, ...runtimeHandlers]) {
+    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)}`);
+    }
+  }
+  return event;
+}
+__name(emitFarmEvent, "emitFarmEvent");
+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",
+    "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_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()
+  });
+}
+__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function getActiveFarmI18nSnapshot() {
+  if (typeof window !== "undefined" && window.__FARM_I18N__) {
+    return window.__FARM_I18N__;
+  }
+  return globalThis[FARM_I18N_SNAPSHOT_RESOLVER]?.();
+}
+__name(getActiveFarmI18nSnapshot, "getActiveFarmI18nSnapshot");
+
+// src/cache.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 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;
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  set(key, value, 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));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    this.entries.set(key, entry);
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  isStale(entry, now2 = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now2 - 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;
+  }
+  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;
+  }
+  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 getOrSet(key, producer, options = {}) {
+    const cached = this.getEntry(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const promise = Promise.resolve().then(producer).then((value) => {
+      this.set(key, value, options);
+      return value;
+    }).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  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) {
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    return this.countEntriesForTag(normalizedTag);
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+};
+__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());
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+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?:\/\//.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch {
+  }
+  normalized = normalized.split("?")[0] ?? normalized;
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  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) {
+    return void 0;
+  }
+  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 getFunctionCacheIdentity(fn) {
+  if (fn.name) {
+    return `name:${fn.name}`;
+  }
+  let id = functionIds.get(fn);
+  if (!id) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return `anonymous:${id}`;
+}
+__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
+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 `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(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 _FarmClientDataCache = class _FarmClientDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.invalidatedAt = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    subscribeFarmCacheInvalidation((key) => this.invalidate(key));
+  }
+  get size() {
+    return this.entries.size;
+  }
+  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, now2 = Date.now()) {
+    const resolved = this.resolveKey(key);
+    const entry = this.entries.get(resolved);
+    if (!entry) return void 0;
+    if (entry.gcAt !== void 0 && now2 >= entry.gcAt) {
+      this.entries.delete(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.emit(resolved);
+    return this;
+  }
+  delete(key) {
+    const resolved = this.resolveKey(key);
+    const deleted = this.entries.delete(resolved);
+    this.inflight.delete(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.invalidatedAt.clear();
+    this.inflight.clear();
+    for (const key of keys) this.emit(key);
+  }
+  isStale(key, now2 = Date.now()) {
+    const entry = this.get(key, now2);
+    return !entry || entry.invalidatedAt !== void 0 || now2 >= entry.staleAt;
+  }
+  invalidate(key, now2 = Date.now()) {
+    const resolved = this.resolveKey(key);
+    this.invalidatedAt.set(resolved, now2);
+    const entry = this.entries.get(resolved);
+    if (entry) {
+      this.entries.set(resolved, {
+        ...entry,
+        staleAt: 0,
+        invalidatedAt: now2
+      });
+    }
+    this.emit(resolved);
+  }
+  alias(alias, key) {
+    const resolved = this.resolveKey(key);
+    if (alias === resolved) return;
+    const aliasEntry = this.entries.get(alias);
+    if (aliasEntry && !this.entries.has(resolved)) {
+      this.entries.set(resolved, aliasEntry);
+    }
+    this.entries.delete(alias);
+    const aliasInflight = this.inflight.get(alias);
+    if (aliasInflight && !this.inflight.has(resolved)) {
+      this.inflight.set(resolved, aliasInflight);
+    }
+    this.inflight.delete(alias);
+    this.aliases.set(alias, resolved);
+    this.emit(alias);
+    this.emit(resolved);
+  }
+  subscribe(key, listener) {
+    let listeners2 = this.listeners.get(key);
+    if (!listeners2) {
+      listeners2 = /* @__PURE__ */ new Set();
+      this.listeners.set(key, listeners2);
+    }
+    listeners2.add(listener);
+    return () => {
+      listeners2.delete(listener);
+      if (listeners2.size === 0) this.listeners.delete(key);
+    };
+  }
+  getInflight(key) {
+    return this.inflight.get(this.resolveKey(key));
+  }
+  setInflight(key, promise) {
+    this.inflight.set(this.resolveKey(key), promise);
+  }
+  deleteInflight(key) {
+    this.inflight.delete(this.resolveKey(key));
+  }
+  emit(key) {
+    this.notifyListeners(key);
+    for (const [alias, target] of this.aliases) {
+      if (this.resolveKey(target) === key) {
+        this.notifyListeners(alias);
+      }
+    }
+  }
+  notifyListeners(key) {
+    for (const listener of this.listeners.get(key) ?? []) {
+      listener();
+    }
+  }
+};
+__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/api/client.ts
+function createAPIClient(options = {}) {
+  options ?? (options = {});
+  const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+  const integrationOptions = options.integrations === false ? false : {
+    baseURL: options.baseURL,
+    headers: options.headers,
+    credentials: options.credentials,
+    ...typeof options.integrations === "object" ? options.integrations : {}
+  };
+  const rootAliases = integrationOptions === false ? void 0 : {
+    integrations: integrationsClient(integrationOptions)
+  };
+  const cacheState = getFarmClientDataCache();
+  const inflightState = /* @__PURE__ */ new Map();
+  const routeMeta = /* @__PURE__ */ new WeakMap();
+  let requestCounter = 0;
+  const fetchClient = /* @__PURE__ */ __name(async (path, requestOptions = {}) => {
+    const url = new URL(path, baseURL);
+    if (requestOptions.query) {
+      Object.entries(requestOptions.query).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    const fetchOptions = {
+      method: requestOptions.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers,
+        ...requestOptions.headers
+      }
+    };
+    if (requestOptions.body) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    let data = void 0;
+    if (response.status !== 204 && response.status !== 205) {
+      data = await response.json();
+    }
+    return { response, data };
+  }, "fetchClient");
+  const request = /* @__PURE__ */ __name(async (path, method, input = {}, clientOptions) => {
+    const methodUpper = method.toUpperCase();
+    const requestId = `${Date.now()}-${++requestCounter}`;
+    const cacheOptions = clientOptions?.cache ? {
+      ...options.cacheDefaults,
+      ...clientOptions.cache
+    } : void 0;
+    const configuredCacheKey = clientOptions?.key ?? cacheOptions?.key;
+    const cacheKey = normalizeFarmClientCacheKey(
+      configuredCacheKey ?? buildCacheKey(methodUpper, path, input, baseURL)
+    );
+    const now2 = Date.now();
+    const emitStatus = /* @__PURE__ */ __name((phase, payload) => {
+      clientOptions?.onStatus?.({
+        phase,
+        requestId,
+        method: methodUpper,
+        key: cacheKey,
+        input,
+        timestamp: Date.now(),
+        ...payload
+      });
+    }, "emitStatus");
+    const entry = getValidCacheEntry(cacheState, cacheKey, now2);
+    const policy = cacheOptions?.policy ?? (cacheOptions ? "cache-first" : "network-only");
+    const staleTime = cacheOptions?.staleTime ?? 0;
+    const isCacheEnabled = Boolean(cacheOptions) && methodUpper === "GET";
+    const isStale = entry ? isEntryStale(entry, now2) : true;
+    const applyOptimisticUpdates = /* @__PURE__ */ __name(() => {
+      if (!clientOptions?.optimistic?.update?.length) return [];
+      const snapshots = [];
+      for (const update of clientOptions.optimistic.update) {
+        const [target, targetInput, updater] = update.length === 2 ? [update[0], void 0, update[1]] : [update[0], update[1], update[2]];
+        const targetKey = resolveTargetKey(routeMeta, target, targetInput, baseURL);
+        if (!targetKey) continue;
+        const targetEntry = getValidCacheEntry(cacheState, targetKey, now2);
+        const previousEntry = targetEntry ? { ...targetEntry } : void 0;
+        const previousData = targetEntry?.data;
+        const nextData = updater(previousData);
+        cacheState.set(targetKey, {
+          data: nextData,
+          updatedAt: now2,
+          staleAt: targetEntry?.staleAt ?? now2 + (cacheOptions?.staleTime ?? options.cacheDefaults?.staleTime ?? 0),
+          gcAt: targetEntry?.gcAt ?? getGcAt(now2, cacheOptions?.gcTime ?? options.cacheDefaults?.gcTime),
+          invalidatedAt: targetEntry?.invalidatedAt
+        });
+        snapshots.push({ key: targetKey, entry: previousEntry });
+      }
+      return snapshots;
+    }, "applyOptimisticUpdates");
+    const rollbackOptimisticUpdates = /* @__PURE__ */ __name((snapshots) => {
+      if (!clientOptions?.optimistic?.rollbackOnError) return;
+      for (const snapshot of snapshots) {
+        if (!snapshot.entry) {
+          cacheState.delete(snapshot.key);
+          continue;
+        }
+        cacheState.set(snapshot.key, { ...snapshot.entry });
+      }
+    }, "rollbackOptimisticUpdates");
+    const executeNetwork = /* @__PURE__ */ __name(async (opts) => {
+      const dedupeMs = cacheOptions?.dedupeMs ?? 0;
+      const inflight = inflightState.get(cacheKey);
+      const allowDedupe = isCacheEnabled && dedupeMs > 0;
+      if (allowDedupe && inflight && now2 - inflight.startedAt < dedupeMs) {
+        emitStatus("pending", { isBackground: opts?.isBackground, data: entry?.data });
+        const result2 = await inflight.promise;
+        if (result2.error) {
+          emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onError?.(result2.error);
+          }
+        } else {
+          emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onSuccess?.(result2.data);
+          }
+        }
+        return result2;
+      }
+      emitStatus(opts?.isBackground ? "revalidating" : "pending", {
+        isBackground: opts?.isBackground
+      });
+      const promise = (async () => {
+        const maxRetries = Math.max(0, clientOptions?.retry?.count ?? 0);
+        let attempt = 0;
+        while (true) {
+          clientOptions?.onRequest?.({
+            requestId,
+            method: methodUpper,
+            key: cacheKey,
+            path,
+            input,
+            attempt,
+            timestamp: Date.now()
+          });
+          try {
+            const { response, data } = await fetchClient(path, {
+              ...input,
+              method: methodUpper
+            });
+            const error = response.ok ? null : createResponseError2(response, data);
+            const responseEvent = {
+              requestId,
+              method: methodUpper,
+              key: cacheKey,
+              path,
+              input,
+              attempt,
+              timestamp: Date.now(),
+              response,
+              data: response.ok ? data : void 0,
+              error: error ?? void 0,
+              ok: response.ok,
+              status: response.status
+            };
+            clientOptions?.onResponse?.(response.ok ? data : void 0, error, responseEvent);
+            if (!error) {
+              return { data, error: null, key: cacheKey };
+            }
+            if (attempt >= maxRetries) {
+              return { data: void 0, error, key: cacheKey };
+            }
+          } catch (err) {
+            const error = normalizeError(err);
+            const responseEvent = {
+              requestId,
+              method: methodUpper,
+              key: cacheKey,
+              path,
+              input,
+              attempt,
+              timestamp: Date.now(),
+              error,
+              ok: false
+            };
+            clientOptions?.onResponse?.(void 0, error, responseEvent);
+            if (attempt >= maxRetries) {
+              return { data: void 0, error, key: cacheKey };
+            }
+          }
+          attempt += 1;
+          const delay = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
+          if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+      })();
+      inflightState.set(cacheKey, { promise, startedAt: now2 });
+      try {
+        const result2 = await promise;
+        if (!result2.error && isCacheEnabled) {
+          const updatedAt = Date.now();
+          cacheState.set(cacheKey, {
+            data: result2.data,
+            updatedAt,
+            staleAt: updatedAt + staleTime,
+            gcAt: getGcAt(updatedAt, cacheOptions?.gcTime),
+            invalidatedAt: void 0
+          });
+        }
+        if (result2.error) {
+          emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onError?.(result2.error);
+          }
+        } else {
+          emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onSuccess?.(result2.data);
+          }
+        }
+        return result2;
+      } finally {
+        inflightState.delete(cacheKey);
+      }
+    }, "executeNetwork");
+    const invalidateTargets = /* @__PURE__ */ __name(async () => {
+      if (!clientOptions?.invalidate) return;
+      const invalidateOptions = Array.isArray(clientOptions.invalidate) ? { targets: clientOptions.invalidate, refetch: false } : {
+        targets: clientOptions.invalidate.targets,
+        refetch: clientOptions.invalidate.refetch ?? false
+      };
+      for (const target of invalidateOptions.targets) {
+        const targetKey = resolveTargetKey(routeMeta, target, void 0, baseURL);
+        if (!targetKey) continue;
+        const existing = cacheState.get(targetKey);
+        if (existing) {
+          cacheState.set(targetKey, {
+            ...existing,
+            staleAt: 0,
+            invalidatedAt: Date.now()
+          });
+        }
+        emitStatus("invalidated", { key: targetKey });
+        if (invalidateOptions.refetch && existing && targetKey === cacheKey) {
+          void executeNetwork({ isBackground: true, callCallbacks: false });
+        }
+      }
+    }, "invalidateTargets");
+    const optimisticSnapshots = applyOptimisticUpdates();
+    if (isCacheEnabled) {
+      if (entry && !isStale && policy !== "network-only") {
+        emitStatus("success", { data: entry.data });
+        clientOptions?.onSuccess?.(entry.data);
+        clientOptions?.onSettled?.(entry.data, null);
+        return { data: entry.data, error: null, key: cacheKey };
+      }
+      if (entry && isStale && policy === "stale-while-revalidate") {
+        emitStatus("success", { data: entry.data });
+        clientOptions?.onSuccess?.(entry.data);
+        clientOptions?.onSettled?.(entry.data, null);
+        void executeNetwork({ isBackground: true, callCallbacks: false });
+        return { data: entry.data, error: null, key: cacheKey };
+      }
+    }
+    const result = await executeNetwork();
+    if (result.error) {
+      rollbackOptimisticUpdates(optimisticSnapshots);
+    }
+    await invalidateTargets();
+    clientOptions?.onSettled?.(result.data, result.error);
+    return result;
+  }, "request");
+  return createNestedProxy([], request, routeMeta, baseURL, rootAliases);
+}
+__name(createAPIClient, "createAPIClient");
+function createNestedProxy(path, client, routeMeta, baseURL, rootAliases) {
+  const target = /* @__PURE__ */ __name(() => {
+  }, "target");
+  const proxy = new Proxy(target, {
+    // When accessing a property (api.hello)
+    get(_target, prop) {
+      if (path.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
+        return rootAliases[prop];
+      }
+      return createNestedProxy([...path, prop], client, routeMeta, baseURL, rootAliases);
+    },
+    // When calling as a function
+    apply(_target, _thisArg, args) {
+      const lastPart = path[path.length - 1];
+      const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
+      if (httpMethods.includes(lastPart)) {
+        const routePath = "/api/" + path.slice(0, -1).join("/");
+        const method = lastPart.toUpperCase();
+        const [options, clientOptions] = args;
+        return client(routePath, method, options, clientOptions);
+      } else {
+        const routePath = "/api/" + path.join("/");
+        const [options, clientOptions] = args;
+        return client(routePath, options?.method || "GET", options, clientOptions);
+      }
+    }
+  });
+  routeMeta.set(proxy, { path: [...path], baseURL });
+  return proxy;
+}
+__name(createNestedProxy, "createNestedProxy");
+function createServerAPIClient(endpoints, options = {}) {
+  if (options.integrations === false || Object.prototype.hasOwnProperty.call(endpoints, "integrations")) {
+    return endpoints;
+  }
+  Object.defineProperty(endpoints, "integrations", {
+    get() {
+      return integrationsServer(
+        typeof options.integrations === "object" ? options.integrations : {}
+      );
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return endpoints;
+}
+__name(createServerAPIClient, "createServerAPIClient");
+function buildCacheKey(method, path, input, baseURL) {
+  const keyInput = input && typeof input === "object" ? { query: input.query, body: input.body } : input;
+  const url = new URL(path, baseURL);
+  return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
+}
+__name(buildCacheKey, "buildCacheKey");
+function stableStringify(value) {
+  if (value === null || value === void 0) return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+__name(stableStringify, "stableStringify");
+function getGcAt(now2, gcTime) {
+  if (gcTime === void 0) return void 0;
+  if (!Number.isFinite(gcTime) || gcTime <= 0) return now2;
+  return now2 + gcTime;
+}
+__name(getGcAt, "getGcAt");
+function getValidCacheEntry(cacheState, key, now2) {
+  const entry = cacheState.get(key);
+  if (!entry) return void 0;
+  if (entry.gcAt !== void 0 && now2 >= entry.gcAt) {
+    cacheState.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+__name(getValidCacheEntry, "getValidCacheEntry");
+function isEntryStale(entry, now2) {
+  if (entry.invalidatedAt !== void 0) return true;
+  return now2 >= entry.staleAt;
+}
+__name(isEntryStale, "isEntryStale");
+function resolveTargetKey(routeMeta, target, input, baseURL = "http://localhost:3000") {
+  if (!target) return null;
+  if (typeof target === "string") return target;
+  if (typeof target === "function") {
+    const meta = routeMeta.get(target);
+    if (!meta) return null;
+    const { method, routePath } = resolveRouteMeta(meta);
+    return buildCacheKey(method, routePath, input ?? {}, meta.baseURL);
+  }
+  if (Array.isArray(target)) {
+    const [route2, routeInput] = target;
+    return resolveTargetKey(routeMeta, route2, routeInput, baseURL);
+  }
+  if ("key" in target) return normalizeFarmClientCacheKey(target.key);
+  if ("path" in target) {
+    const method = target.method ?? "GET";
+    return buildCacheKey(method, target.path, target.input ?? {}, baseURL);
+  }
+  return null;
+}
+__name(resolveTargetKey, "resolveTargetKey");
+function resolveRouteMeta(meta) {
+  const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
+  const lastPart = meta.path[meta.path.length - 1];
+  if (lastPart && httpMethods.includes(lastPart)) {
+    return {
+      routePath: "/api/" + meta.path.slice(0, -1).join("/"),
+      method: lastPart.toUpperCase()
+    };
+  }
+  return {
+    routePath: "/api/" + meta.path.join("/"),
+    method: "GET"
+  };
+}
+__name(resolveRouteMeta, "resolveRouteMeta");
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  return new Error(typeof error === "string" ? error : "Unknown error");
+}
+__name(normalizeError, "normalizeError");
+function createResponseError2(response, data) {
+  const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+  error.status = response.status;
+  error.response = response;
+  error.data = data;
+  return error;
+}
+__name(createResponseError2, "createResponseError");
+
+// src/server-query-client.ts
+var import_react = require("react");
+var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
+var serverQueryClientGlobal = globalThis;
+var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ?? (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
+  functionIds: /* @__PURE__ */ new WeakMap(),
+  nextFunctionId: 0,
+  active: []
+});
+async function fetchServerQuery(query, input, options = {}) {
+  const cache = getFarmClientDataCache();
+  const provisionalKey = createServerQueryCallKey(query, input);
+  const entry = cache.get(provisionalKey);
+  const stale = cache.isStale(provisionalKey);
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight) return inflight;
+  if (!options.force && entry && !stale && entry.status !== "error") {
+    return entry.data;
+  }
+  if (!options.force && entry && stale && entry.status !== "pending" && entry.status !== "error" && (options.swr ?? true)) {
+    void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+    return entry.data;
+  }
+  return executeServerQuery(query, input, provisionalKey, options);
+}
+__name(fetchServerQuery, "fetchServerQuery");
+function prefetchServerQuery(query, input, options = {}) {
+  return fetchServerQuery(query, input, options);
+}
+__name(prefetchServerQuery, "prefetchServerQuery");
+function useServerQuery(query, input, options = {}) {
+  const cache = getFarmClientDataCache();
+  const key = createServerQueryCallKey(query, input);
+  const inputRef = (0, import_react.useRef)(input);
+  const optionsRef = (0, import_react.useRef)(options);
+  const mountedKeyRef = (0, import_react.useRef)();
+  inputRef.current = input;
+  optionsRef.current = options;
+  const subscribe = (0, import_react.useCallback)(
+    (listener) => cache.subscribe(key, listener),
+    [cache, key]
+  );
+  const getSnapshot = (0, import_react.useCallback)(() => cache.get(key), [cache, key]);
+  const entry = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
+  const run = (0, import_react.useCallback)(
+    (force = false) => fetchServerQuery(query, inputRef.current, {
+      ...optionsRef.current,
+      force
+    }),
+    [query]
+  );
+  (0, import_react.useEffect)(() => {
+    if (options.enabled === false) return;
+    const firstReadForKey = mountedKeyRef.current !== key;
+    if (firstReadForKey) mountedKeyRef.current = key;
+    if (firstReadForKey && (!entry || cache.isStale(key)) || entry?.invalidatedAt !== void 0 && !entry.fetching) {
+      void run().catch(() => void 0);
+    }
+  }, [cache, entry, key, options.enabled, run]);
+  (0, import_react.useEffect)(() => {
+    if (options.enabled === false || typeof window === "undefined") return;
+    const refreshIfStale = /* @__PURE__ */ __name(() => {
+      if (cache.isStale(key)) void run().catch(() => void 0);
+    }, "refreshIfStale");
+    const onFocus = options.refetchOnWindowFocus === false ? void 0 : refreshIfStale;
+    const onOnline = options.refetchOnReconnect === false ? void 0 : refreshIfStale;
+    if (onFocus) window.addEventListener("focus", onFocus);
+    if (onOnline) window.addEventListener("online", onOnline);
+    return () => {
+      if (onFocus) window.removeEventListener("focus", onFocus);
+      if (onOnline) window.removeEventListener("online", onOnline);
+    };
+  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
+  const status = entry?.status ?? (entry ? "success" : "idle");
+  const fetching = entry?.fetching ?? false;
+  return {
+    data: entry?.data,
+    error: entry?.error ?? null,
+    status,
+    pending: status === "pending" && (entry?.updatedAt ?? 0) === 0,
+    fetching,
+    stale: cache.isStale(key),
+    refetch: /* @__PURE__ */ __name(() => run(true), "refetch")
+  };
+}
+__name(useServerQuery, "useServerQuery");
+function createServerQueryCallKey(query, input) {
+  let id = serverQueryClientState.functionIds.get(query);
+  if (!id) {
+    id = ++serverQueryClientState.nextFunctionId;
+    serverQueryClientState.functionIds.set(query, id);
+  }
+  return createFarmCacheKey(["server-query-call", id, input]);
+}
+__name(createServerQueryCallKey, "createServerQueryCallKey");
+async function executeServerQuery(query, input, provisionalKey, options) {
+  const cache = getFarmClientDataCache();
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight) return inflight;
+  const previous = cache.get(provisionalKey);
+  cache.set(provisionalKey, {
+    data: previous?.data,
+    updatedAt: previous?.updatedAt ?? 0,
+    staleAt: previous?.staleAt ?? 0,
+    gcAt: previous?.gcAt,
+    invalidatedAt: previous?.invalidatedAt,
+    status: "pending",
+    error: null,
+    fetching: true
+  });
+  const promise = (async () => {
+    try {
+      serverQueryClientState.active.push({ provisionalKey });
+      let pending;
+      try {
+        pending = query(input);
+      } finally {
+        serverQueryClientState.active.pop();
+      }
+      const data = await pending;
+      const transported = cache.get(provisionalKey);
+      if (!transported || transported.fetching) {
+        const updatedAt = Date.now();
+        cache.set(provisionalKey, {
+          data,
+          updatedAt,
+          staleAt: options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
+          status: "success",
+          error: null,
+          fetching: false
+        });
+      }
+      return data;
+    } catch (cause) {
+      const error = normalizeServerQueryError(cause);
+      const current = cache.get(provisionalKey);
+      cache.set(provisionalKey, {
+        data: current?.data,
+        updatedAt: current?.updatedAt ?? 0,
+        staleAt: current?.staleAt ?? 0,
+        gcAt: current?.gcAt,
+        invalidatedAt: current?.invalidatedAt,
+        status: "error",
+        error,
+        fetching: false
+      });
+      throw error;
+    } finally {
+      cache.deleteInflight(provisionalKey);
+    }
+  })();
+  cache.setInflight(provisionalKey, promise);
+  return promise;
+}
+__name(executeServerQuery, "executeServerQuery");
+function normalizeServerQueryError(cause) {
+  if (cause instanceof Error) return cause;
+  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
+  error.cause = cause;
+  return error;
+}
+__name(normalizeServerQueryError, "normalizeServerQueryError");
+
+// src/integration-api.ts
+function defineIntegrationAPIOperation(operation2) {
+  return {
+    kind: "farm-integration-api-operation",
+    ...operation2
+  };
+}
+__name(defineIntegrationAPIOperation, "defineIntegrationAPIOperation");
+function defineIntegrationAPI(api2) {
+  return api2;
+}
+__name(defineIntegrationAPI, "defineIntegrationAPI");
+function operation(method, pathOrOptions, maybeOptions = {}) {
+  const hasExplicitPath = typeof pathOrOptions === "string";
+  const path = hasExplicitPath ? pathOrOptions : "";
+  const options = hasExplicitPath ? maybeOptions : {
+    ...maybeOptions,
+    ...pathOrOptions
+  };
+  return defineIntegrationAPIOperation({
+    path,
+    method,
+    __pathless: !hasExplicitPath,
+    ...options
+  });
+}
+__name(operation, "operation");
+function get(pathOrOptions, maybeOptions = {}) {
+  return operation("GET", pathOrOptions, maybeOptions);
+}
+__name(get, "get");
+function isOperation2(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
+}
+__name(isOperation2, "isOperation");
+function bindRoutePath(path, api2) {
+  const entries = Object.entries(api2).map(([key, value]) => {
+    if (isOperation2(value)) {
+      return [
+        key,
+        {
+          ...value,
+          path,
+          __pathless: false
+        }
+      ];
+    }
+    if (value && typeof value === "object") {
+      return [key, bindRoutePath(path, value)];
+    }
+    return [key, value];
+  });
+  return Object.fromEntries(entries);
+}
+__name(bindRoutePath, "bindRoutePath");
+function route(path, definitionOrOperation, ...operations) {
+  if (isOperation2(definitionOrOperation)) {
+    const allOperations = [definitionOrOperation, ...operations];
+    return Object.fromEntries(
+      allOperations.map((operation2) => [
+        operation2.method.toLowerCase(),
+        {
+          ...operation2,
+          path,
+          __pathless: false
+        }
+      ])
+    );
+  }
+  return bindRoutePath(path, definitionOrOperation);
+}
+__name(route, "route");
+function normalizeRouteSegment(segment) {
+  if (!segment) {
+    return "index";
+  }
+  if (segment.startsWith("[...") && segment.endsWith("]")) {
+    return segment.slice(4, -1) || "index";
+  }
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    return segment.slice(1, -1) || "index";
+  }
+  const matcherIndex = segment.indexOf("(");
+  if (matcherIndex > 0) {
+    return segment.slice(0, matcherIndex);
+  }
+  return camelCaseRouteSegment(segment);
+}
+__name(normalizeRouteSegment, "normalizeRouteSegment");
+function camelCaseRouteSegment(segment) {
+  return segment.replace(/-([a-zA-Z0-9])/g, (_match, value) => value.toUpperCase());
+}
+__name(camelCaseRouteSegment, "camelCaseRouteSegment");
+function getRouteClientSegments(path) {
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return ["index"];
+  }
+  const stripped = segments[0] === "api" && segments.length > 2 ? segments.slice(2) : segments.length > 1 ? segments.slice(1) : [segments[segments.length - 1]];
+  return stripped.map(normalizeRouteSegment).filter(Boolean);
+}
+__name(getRouteClientSegments, "getRouteClientSegments");
+function setRouteOperation(target, pathSegments, operation2) {
+  const [head, ...tail] = pathSegments;
+  if (!head) {
+    return;
+  }
+  if (tail.length === 0) {
+    const leaf = target[head] || {};
+    leaf[operation2.method.toLowerCase()] = {
+      ...operation2,
+      path: operation2.path,
+      __pathless: false
+    };
+    target[head] = leaf;
+    return;
+  }
+  const branch = target[head] || {};
+  target[head] = branch;
+  setRouteOperation(branch, tail, operation2);
+}
+__name(setRouteOperation, "setRouteOperation");
+function fromRoutes(routes) {
+  const definition = {};
+  for (const route2 of routes) {
+    if (!isOperation2(route2.__operation)) {
+      continue;
+    }
+    setRouteOperation(definition, getRouteClientSegments(route2.path), {
+      ...route2.__operation,
+      path: route2.path,
+      __pathless: false
+    });
+  }
+  return definition;
+}
+__name(fromRoutes, "fromRoutes");
+var api = {
+  get,
+  route,
+  fromRoutes,
+  post(pathOrOptions, maybeOptions = {}) {
+    return operation("POST", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  put(pathOrOptions, maybeOptions = {}) {
+    return operation("PUT", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  patch(pathOrOptions, maybeOptions = {}) {
+    return operation("PATCH", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  delete(pathOrOptions, maybeOptions = {}) {
+    return operation("DELETE", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  options(pathOrOptions, maybeOptions = {}) {
+    return operation(
+      "OPTIONS",
+      pathOrOptions,
+      maybeOptions
+    );
+  },
+  head(pathOrOptions, maybeOptions = {}) {
+    return operation(
+      "HEAD",
+      pathOrOptions,
+      maybeOptions
+    );
+  },
+  form: {
+    post(pathOrOptions, maybeOptions = {}) {
+      return operation("POST", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    },
+    put(pathOrOptions, maybeOptions = {}) {
+      return operation("PUT", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    },
+    patch(pathOrOptions, maybeOptions = {}) {
+      return operation("PATCH", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    },
+    delete(pathOrOptions, maybeOptions = {}) {
+      return operation("DELETE", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    }
+  }
+};
+var endpoint = api;
+
+// src/store.ts
+var import_react2 = require("react");
+var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
+  "use",
+  "get",
+  "set",
+  "replace",
+  "reset",
+  "subscribe"
+]);
+function cloneState(state) {
+  return { ...state };
+}
+__name(cloneState, "cloneState");
+function pickState(state, keys) {
+  const slice = {};
+  for (const key of keys) {
+    slice[key] = state[key];
+  }
+  return slice;
+}
+__name(pickState, "pickState");
+function getChangedKeys(state, previousState) {
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(state),
+    ...Object.keys(previousState)
+  ]);
+  return [...keys].filter((key) => !Object.is(state[key], previousState[key]));
+}
+__name(getChangedKeys, "getChangedKeys");
+function normalizeKeys(keys) {
+  return Array.from(new Set(keys));
+}
+__name(normalizeKeys, "normalizeKeys");
+function resolveValue(value, previousValue) {
+  return typeof value === "function" ? value(previousValue) : value;
+}
+__name(resolveValue, "resolveValue");
+function isStoreKey(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+__name(isStoreKey, "isStoreKey");
+function createStore(initialState, extend) {
+  const initialSnapshot = cloneState(initialState);
+  let state = cloneState(initialState);
+  const subscriptions = /* @__PURE__ */ new Set();
+  const addSubscription = /* @__PURE__ */ __name((keys, notify) => {
+    const subscription = { keys, notify };
+    subscriptions.add(subscription);
+    return () => {
+      subscriptions.delete(subscription);
+    };
+  }, "addSubscription");
+  const emit = /* @__PURE__ */ __name((nextState, previousState) => {
+    const changedKeys = getChangedKeys(nextState, previousState);
+    if (changedKeys.length === 0) {
+      return;
+    }
+    const changedKeySet = new Set(changedKeys);
+    for (const subscription of subscriptions) {
+      if (subscription.keys === null || subscription.keys.some((key) => changedKeySet.has(key))) {
+        subscription.notify(nextState, previousState);
+      }
+    }
+  }, "emit");
+  const getState = /* @__PURE__ */ __name((key) => {
+    return key === void 0 ? state : state[key];
+  }, "getState");
+  const replaceState2 = /* @__PURE__ */ __name((nextState) => {
+    const previousState = state;
+    const resolvedState = typeof nextState === "function" ? nextState(previousState) : nextState;
+    state = resolvedState;
+    emit(state, previousState);
+    return state;
+  }, "replaceState");
+  const setState = /* @__PURE__ */ __name((keyOrPatch, value) => {
+    const previousState = state;
+    let nextState;
+    if (isStoreKey(keyOrPatch)) {
+      const key = keyOrPatch;
+      const nextValue = resolveValue(value, previousState[key]);
+      if (Object.is(previousState[key], nextValue)) {
+        return nextValue;
+      }
+      nextState = {
+        ...previousState,
+        [key]: nextValue
+      };
+      state = nextState;
+      emit(nextState, previousState);
+      return nextValue;
+    }
+    const patch = typeof keyOrPatch === "function" ? keyOrPatch(previousState) : keyOrPatch;
+    nextState = {
+      ...previousState,
+      ...patch
+    };
+    state = nextState;
+    emit(nextState, previousState);
+    return nextState;
+  }, "setState");
+  const subscribeState = /* @__PURE__ */ __name((keyOrListener, listener) => {
+    if (typeof keyOrListener === "function") {
+      return addSubscription(null, (nextState, previousState) => {
+        keyOrListener(nextState, previousState);
+      });
+    }
+    if (Array.isArray(keyOrListener)) {
+      const keys = normalizeKeys(keyOrListener);
+      return addSubscription(keys, (nextState, previousState) => {
+        listener(
+          pickState(nextState, keys),
+          pickState(previousState, keys)
+        );
+      });
+    }
+    const key = keyOrListener;
+    return addSubscription([key], (nextState, previousState) => {
+      listener(nextState[key], previousState[key]);
+    });
+  }, "subscribeState");
+  const useStateValue = /* @__PURE__ */ __name((keyOrKeys) => {
+    if (Array.isArray(keyOrKeys)) {
+      const keys = normalizeKeys(keyOrKeys);
+      let lastState = state;
+      let lastSlice = pickState(state, keys);
+      const getSnapshot = /* @__PURE__ */ __name(() => {
+        if (lastState !== state) {
+          lastState = state;
+          lastSlice = pickState(state, keys);
+        }
+        return lastSlice;
+      }, "getSnapshot");
+      return (0, import_react2.useSyncExternalStore)(
+        (notify) => addSubscription(keys, () => notify()),
+        getSnapshot,
+        getSnapshot
+      );
+    }
+    if (typeof keyOrKeys === "string") {
+      return (0, import_react2.useSyncExternalStore)(
+        (notify) => addSubscription([keyOrKeys], () => notify()),
+        () => state[keyOrKeys],
+        () => state[keyOrKeys]
+      );
+    }
+    return (0, import_react2.useSyncExternalStore)(
+      (notify) => addSubscription(null, () => notify()),
+      () => state,
+      () => state
+    );
+  }, "useStateValue");
+  const store = {
+    use: useStateValue,
+    get: getState,
+    set: setState,
+    replace: replaceState2,
+    reset: /* @__PURE__ */ __name(() => replaceState2(cloneState(initialSnapshot)), "reset"),
+    subscribe: subscribeState
+  };
+  for (const key of Object.keys(initialSnapshot)) {
+    if (RESERVED_STORE_KEYS.has(key)) {
+      throw new Error(
+        `createStore does not allow the reserved key "${String(key)}" in the initial state.`
+      );
+    }
+    const field = /* @__PURE__ */ __name((() => useStateValue(key)), "field");
+    field.get = () => state[key];
+    field.set = (value) => setState(key, value);
+    field.subscribe = (listener) => subscribeState(key, listener);
+    Object.defineProperty(store, key, {
+      configurable: false,
+      enumerable: true,
+      value: field,
+      writable: false
+    });
+  }
+  if (extend) {
+    const methods = extend(store);
+    for (const [name, method] of Object.entries(methods)) {
+      if (name in store) {
+        throw new Error(
+          `createStore cannot attach the method "${name}" because it already exists.`
+        );
+      }
+      Object.defineProperty(store, name, {
+        configurable: false,
+        enumerable: true,
+        value: method,
+        writable: false
+      });
+    }
+  }
+  return store;
+}
+__name(createStore, "createStore");
+
+// src/client/link.tsx
+var import_react3 = require("react");
+
+// src/router.ts
+function createFarmRouter(routes) {
+  const normalizedRoutes = routes.map(normalizeRouteInput).sort(compareRoutes);
+  return {
+    routes: normalizedRoutes.map((entry) => entry.route),
+    match(pathname) {
+      const normalizedPathname = normalizePathname(pathname);
+      for (const entry of normalizedRoutes) {
+        const params = matchSegments(entry.segments, normalizedPathname);
+        if (params) {
+          return {
+            route: entry.route,
+            pathname: normalizedPathname,
+            params
+          };
+        }
+      }
+      return null;
+    },
+    build: buildFarmRoutePath,
+    isActive: isFarmRouteActive
+  };
+}
+__name(createFarmRouter, "createFarmRouter");
+function matchFarmRoute(pattern, pathname) {
+  return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));
+}
+__name(matchFarmRoute, "matchFarmRoute");
+function buildFarmRoutePath(pattern, params = {}, options = {}) {
+  const parts = [];
+  for (const segment of parseRoutePattern(pattern)) {
+    if (segment.type === "static") {
+      parts.push(encodePathSegment(segment.value));
+      continue;
+    }
+    const value = params[segment.name];
+    const values = Array.isArray(value) ? value : value == null ? [] : [value];
+    if (values.length === 0) {
+      if (segment.optional) continue;
+      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
+    }
+    if (!segment.catchAll && values.length > 1) {
+      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
+    }
+    parts.push(...values.map((item) => encodePathSegment(String(item))));
+  }
+  let pathname = parts.length ? `/${parts.join("/")}` : "/";
+  if (options.trailingSlash && pathname !== "/") {
+    pathname = `${pathname}/`;
+  }
+  return appendQueryAndHash(pathname, options);
+}
+__name(buildFarmRoutePath, "buildFarmRoutePath");
+function isFarmRouteActive(pattern, pathname, options = {}) {
+  const normalizedPathname = normalizePathname(pathname);
+  if (matchFarmRoute(pattern, normalizedPathname)) return true;
+  if (options.exact !== false) return false;
+  const normalizedPattern = normalizePathname(pattern);
+  if (normalizedPattern === "/") return normalizedPathname === "/";
+  return normalizedPathname.startsWith(`${normalizedPattern}/`);
+}
+__name(isFarmRouteActive, "isFarmRouteActive");
+function normalizeRouteInput(input, index) {
+  const route2 = typeof input === "string" ? { path: input } : input;
+  const path = normalizePathname(route2.path);
+  const segments = parseRoutePattern(path);
+  return {
+    route: {
+      ...route2,
+      path
+    },
+    segments,
+    score: scoreSegments(segments),
+    index
+  };
+}
+__name(normalizeRouteInput, "normalizeRouteInput");
+function parseRoutePattern(pattern) {
+  return splitPathname(pattern).filter((part) => !isRouteGroup(part)).map((part) => {
+    const optionalCatchAll = part.match(/^\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]$/);
+    if (optionalCatchAll) {
+      return {
+        type: "dynamic",
+        name: optionalCatchAll[1],
+        catchAll: true,
+        optional: true
+      };
+    }
+    const catchAll = part.match(/^\[\.\.\.([A-Za-z0-9_$-]+)\]$/);
+    if (catchAll) {
+      return {
+        type: "dynamic",
+        name: catchAll[1],
+        catchAll: true,
+        optional: false
+      };
+    }
+    const dynamic = part.match(/^\[([A-Za-z0-9_$-]+)\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);
+    if (dynamic) {
+      return {
+        type: "dynamic",
+        name: dynamic[1],
+        catchAll: false,
+        optional: false
+      };
+    }
+    const star = part.match(/^\*([A-Za-z0-9_$-]+)(\?)?$/);
+    if (star) {
+      return {
+        type: "dynamic",
+        name: star[1],
+        catchAll: true,
+        optional: !!star[2]
+      };
+    }
+    return {
+      type: "static",
+      value: decodePathSegment(part)
+    };
+  });
+}
+__name(parseRoutePattern, "parseRoutePattern");
+function matchSegments(segments, pathname) {
+  const parts = splitPathname(pathname);
+  const params = {};
+  if (segments.length === 0) {
+    return parts.length === 0 ? params : null;
+  }
+  let pathIndex = 0;
+  for (const segment of segments) {
+    if (segment.type === "static") {
+      if (decodePathSegment(parts[pathIndex] || "") !== segment.value) return null;
+      pathIndex++;
+      continue;
+    }
+    if (segment.catchAll) {
+      const remaining = parts.slice(pathIndex).map(decodePathSegment);
+      if (remaining.length === 0 && !segment.optional) return null;
+      params[segment.name] = remaining.join("/");
+      pathIndex = parts.length;
+      continue;
+    }
+    const value = parts[pathIndex];
+    if (!value) return null;
+    params[segment.name] = decodePathSegment(value);
+    pathIndex++;
+  }
+  return pathIndex === parts.length ? params : null;
+}
+__name(matchSegments, "matchSegments");
+function compareRoutes(left, right) {
+  if (right.score !== left.score) return right.score - left.score;
+  return left.index - right.index;
+}
+__name(compareRoutes, "compareRoutes");
+function scoreSegments(segments) {
+  return segments.reduce((score, segment) => {
+    if (segment.type === "static") return score + 100;
+    if (!segment.catchAll) return score + 50;
+    return score + (segment.optional ? 5 : 10);
+  }, segments.length);
+}
+__name(scoreSegments, "scoreSegments");
+function normalizePathname(value) {
+  const raw = value || "/";
+  let pathname = raw;
+  try {
+    pathname = new URL(raw, "http://farm.local").pathname;
+  } catch {
+    pathname = raw.split(/[?#]/, 1)[0] || "/";
+  }
+  pathname = pathname.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
+  return pathname || "/";
+}
+__name(normalizePathname, "normalizePathname");
+function splitPathname(pathname) {
+  return normalizePathname(pathname).split("/").filter(Boolean);
+}
+__name(splitPathname, "splitPathname");
+function isRouteGroup(part) {
+  return part.startsWith("(") && part.endsWith(")");
+}
+__name(isRouteGroup, "isRouteGroup");
+function decodePathSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+__name(decodePathSegment, "decodePathSegment");
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+__name(encodePathSegment, "encodePathSegment");
+function appendQueryAndHash(pathname, options) {
+  const search = createSearchParams(options.query);
+  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
+  const query = search.toString();
+  return `${pathname}${query ? `?${query}` : ""}${hash}`;
+}
+__name(appendQueryAndHash, "appendQueryAndHash");
+function createSearchParams(query) {
+  if (query instanceof URLSearchParams) return query;
+  const search = new URLSearchParams();
+  if (!query) return search;
+  for (const [key, value] of Object.entries(query)) {
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item == null) continue;
+      search.append(key, String(item));
+    }
+  }
+  return search;
+}
+__name(createSearchParams, "createSearchParams");
+
+// src/i18n/client-runtime.ts
+var import_intl_messageformat = __toESM(require("intl-messageformat"));
+
+// src/i18n/routing.ts
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname2(pathname);
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+__name(resolveFarmLocalePath, "resolveFarmLocalePath");
+function stripFarmLocaleFromPathname(pathname, config) {
+  return resolveFarmLocalePath(pathname, config).pathname;
+}
+__name(stripFarmLocaleFromPathname, "stripFarmLocaleFromPathname");
+function localizeFarmPathname(pathname, locale, config) {
+  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
+  if (config.routing === "none") return internalPathname;
+  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
+    return internalPathname;
+  }
+  return internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
+}
+__name(localizeFarmPathname, "localizeFarmPathname");
+function localizeFarmHref(href, locale, config) {
+  if (!href.startsWith("/") || href.startsWith("//")) return href;
+  const url = new URL(href, "http://farm.local");
+  url.pathname = localizeFarmPathname(url.pathname, locale, config);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+__name(localizeFarmHref, "localizeFarmHref");
+function normalizePathname2(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+__name(normalizePathname2, "normalizePathname");
+
+// src/i18n/client-runtime.ts
+var listeners = /* @__PURE__ */ new Set();
+var compiled = /* @__PURE__ */ new Map();
+var currentSnapshot;
+function getFarmI18nClientState() {
+  return currentSnapshot || getActiveFarmI18nSnapshot();
+}
+__name(getFarmI18nClientState, "getFarmI18nClientState");
+function _hydrateFarmI18n(snapshot) {
+  if (!snapshot) return;
+  const changed = currentSnapshot?.locale !== snapshot.locale;
+  currentSnapshot = snapshot;
+  if (typeof window !== "undefined") window.__FARM_I18N__ = snapshot;
+  if (typeof document !== "undefined") {
+    document.documentElement.lang = snapshot.locale;
+    document.documentElement.dir = snapshot.direction;
+  }
+  if (changed) compiled.clear();
+  for (const listener of listeners) listener();
+}
+__name(_hydrateFarmI18n, "_hydrateFarmI18n");
+var translate = /* @__PURE__ */ __name((key, values, rich = false) => {
+  const snapshot = requireSnapshot();
+  const message = snapshot.messages[key];
+  if (message === void 0) return key;
+  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
+  let formatter = compiled.get(cacheKey);
+  if (!formatter) {
+    formatter = new import_intl_messageformat.default(message, snapshot.locale);
+    compiled.set(cacheKey, formatter);
+  }
+  const result = formatter.format(values);
+  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+  }
+  return Array.isArray(result) ? result.join("") : String(result);
+}, "translate");
+var t = /* @__PURE__ */ __name(((key, values) => translate(key, values)), "t");
+t.rich = (key, values) => translate(key, values, true);
+t.raw = (key) => requireSnapshot().messages[key] ?? key;
+t.has = (key) => key in requireSnapshot().messages;
+function localizeActiveFarmHref(href, locale) {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) return href;
+  return localizeFarmHref(href, locale || snapshot.locale, snapshot);
+}
+__name(localizeActiveFarmHref, "localizeActiveFarmHref");
+function isFarmLocaleChangeHref(href) {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot || typeof window === "undefined") return false;
+  if (snapshot.routing === "none") return false;
+  const target = new URL(href, window.location.origin);
+  const match = resolveFarmLocalePath(target.pathname, snapshot);
+  const targetLocale = match.locale || snapshot.defaultLocale;
+  return targetLocale !== snapshot.locale;
+}
+__name(isFarmLocaleChangeHref, "isFarmLocaleChangeHref");
+function requireSnapshot() {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+__name(requireSnapshot, "requireSnapshot");
+
+// src/client/link.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function isModifierEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+__name(isModifierEvent, "isModifierEvent");
+function isExternalUrl(href) {
+  return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
+}
+__name(isExternalUrl, "isExternalUrl");
+function getRouter() {
+  if (typeof window !== "undefined" && window.__FARM_SPA_ROUTER__) {
+    return window.__FARM_SPA_ROUTER__;
+  }
+  return null;
+}
+__name(getRouter, "getRouter");
+function normalizePrefetch(prefetch2) {
+  if (prefetch2 === false || prefetch2 === "none") {
+    return { intent: false, viewport: false, render: false };
+  }
+  if (prefetch2 === true) {
+    return { intent: true, viewport: true, render: false };
+  }
+  if (prefetch2 === "hover") {
+    return { intent: true, viewport: false, render: false };
+  }
+  if (prefetch2 === "intent") {
+    return { intent: true, viewport: false, render: false };
+  }
+  if (prefetch2 === "viewport") {
+    return { intent: false, viewport: true, render: false };
+  }
+  if (prefetch2 === "render") {
+    return { intent: false, viewport: false, render: true };
+  }
+  return { intent: false, viewport: false, render: false };
+}
+__name(normalizePrefetch, "normalizePrefetch");
+function LinkInner({
+  href,
+  params,
+  query,
+  hash,
+  trailingSlash,
+  prefetch: prefetch2 = true,
+  prefetchDelay = 50,
+  replace = false,
+  scroll = true,
+  viewTransition = false,
+  locale,
+  onClick,
+  target,
+  onMouseEnter,
+  onMouseLeave,
+  onFocus,
+  onBlur,
+  onTouchStart,
+  ...props
+}, ref) {
+  const elementRef = (0, import_react3.useRef)(null);
+  const intentTimeoutRef = (0, import_react3.useRef)(null);
+  const hasPrefetched = (0, import_react3.useRef)(false);
+  const { intent, viewport, render } = normalizePrefetch(prefetch2);
+  const baseHref = resolveLinkHref(href, params, {
+    query,
+    hash,
+    trailingSlash
+  });
+  const resolvedHref = localizeActiveFarmHref(baseHref, locale);
+  const isExternal = isExternalUrl(resolvedHref);
+  const doPrefetch = (0, import_react3.useCallback)(() => {
+    if (isExternal || hasPrefetched.current) return;
+    const router = getRouter();
+    if (!router) return;
+    hasPrefetched.current = true;
+    router.prefetch(resolvedHref);
+  }, [resolvedHref, isExternal]);
+  (0, import_react3.useEffect)(() => {
+    hasPrefetched.current = false;
+  }, [resolvedHref]);
+  (0, import_react3.useEffect)(() => {
+    const element = elementRef.current;
+    if (!element || isExternal) return;
+    const router = getRouter();
+    if (!router) return;
+    if (viewport) {
+      router.observeForPrefetch(element);
+      return () => router.unobserveForPrefetch(element);
+    }
+  }, [resolvedHref, viewport, isExternal]);
+  (0, import_react3.useEffect)(() => {
+    if (!render || isExternal) return;
+    let cancelled = false;
+    let timeoutId = null;
+    const tryRenderPrefetch = /* @__PURE__ */ __name(() => {
+      if (cancelled || hasPrefetched.current) return;
+      const router = getRouter();
+      if (!router) {
+        timeoutId = setTimeout(tryRenderPrefetch, 30);
+        return;
+      }
+      hasPrefetched.current = true;
+      router.prefetch(resolvedHref);
+    }, "tryRenderPrefetch");
+    tryRenderPrefetch();
+    return () => {
+      cancelled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [render, isExternal, resolvedHref]);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      if (intentTimeoutRef.current) {
+        clearTimeout(intentTimeoutRef.current);
+        intentTimeoutRef.current = null;
+      }
+    };
+  }, []);
+  const cancelIntent = (0, import_react3.useCallback)(() => {
+    if (intentTimeoutRef.current) {
+      clearTimeout(intentTimeoutRef.current);
+      intentTimeoutRef.current = null;
+    }
+  }, []);
+  const scheduleIntentPrefetch = (0, import_react3.useCallback)(() => {
+    if (isExternal || !intent || hasPrefetched.current) return;
+    cancelIntent();
+    intentTimeoutRef.current = setTimeout(() => {
+      intentTimeoutRef.current = null;
+      doPrefetch();
+    }, prefetchDelay);
+  }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
+  const handleMouseEnter = (0, import_react3.useCallback)(
+    (event) => {
+      onMouseEnter?.(event);
+      scheduleIntentPrefetch();
+    },
+    [onMouseEnter, scheduleIntentPrefetch]
+  );
+  const handleMouseLeave = (0, import_react3.useCallback)(
+    (event) => {
+      onMouseLeave?.(event);
+      cancelIntent();
+    },
+    [onMouseLeave, cancelIntent]
+  );
+  const handleTouchStart = (0, import_react3.useCallback)(
+    (event) => {
+      onTouchStart?.(event);
+      scheduleIntentPrefetch();
+    },
+    [onTouchStart, scheduleIntentPrefetch]
+  );
+  const handleFocus = (0, import_react3.useCallback)(
+    (event) => {
+      onFocus?.(event);
+      scheduleIntentPrefetch();
+    },
+    [onFocus, scheduleIntentPrefetch]
+  );
+  const handleBlur = (0, import_react3.useCallback)(
+    (event) => {
+      onBlur?.(event);
+      cancelIntent();
+    },
+    [onBlur, cancelIntent]
+  );
+  const handleClick = (0, import_react3.useCallback)(
+    (event) => {
+      onClick?.(event);
+      if (event.defaultPrevented) return;
+      if (isExternal) return;
+      if (target && target !== "_self") return;
+      if (isModifierEvent(event)) return;
+      if (event.button !== 0) return;
+      if (typeof window !== "undefined") {
+        event.preventDefault();
+        if (isFarmLocaleChangeHref(resolvedHref)) {
+          window.location.assign(resolvedHref);
+          return;
+        }
+        const router = getRouter();
+        if (router) {
+          router.navigate(resolvedHref, { replace, scroll, viewTransition });
+        } else {
+          if (replace) window.location.replace(resolvedHref);
+          else window.location.href = resolvedHref;
+        }
+      }
+    },
+    [resolvedHref, replace, scroll, viewTransition, target, isExternal, onClick]
+  );
+  const setRefs = (0, import_react3.useCallback)(
+    (node) => {
+      elementRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    },
+    [ref]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "a",
+    {
+      ref: setRefs,
+      href: resolvedHref,
+      target,
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onTouchStart: handleTouchStart,
+      ...props,
+      "data-farm-link": "",
+      "data-replace": replace ? "" : void 0,
+      "data-no-scroll": !scroll ? "" : void 0,
+      "data-view-transition": viewTransition === "auto" ? "auto" : viewTransition ? "true" : void 0
+    }
+  );
+}
+__name(LinkInner, "LinkInner");
+var LinkWithRef = (0, import_react3.forwardRef)(LinkInner);
+LinkWithRef.displayName = "Link";
+var Link = LinkWithRef;
+function resolveLinkHref(href, params, options) {
+  if (isExternalUrl(href)) return href;
+  const { pathname, query, hash } = splitInternalHref(href);
+  const resolvedHref = buildFarmRoutePath(pathname, params, {
+    query: mergeQueryParams(query, options.query),
+    hash: options.hash ?? hash,
+    trailingSlash: options.trailingSlash
+  });
+  return applyPreservedSearchParams(resolvedHref);
+}
+__name(resolveLinkHref, "resolveLinkHref");
+function splitInternalHref(href) {
+  try {
+    const url = new URL(href, "http://farm.local");
+    return {
+      pathname: url.pathname || "/",
+      query: url.searchParams,
+      hash: url.hash ? url.hash.slice(1) : void 0
+    };
+  } catch {
+    const [withoutHash, rawHash] = href.split("#", 2);
+    const [pathname, rawQuery] = withoutHash.split("?", 2);
+    return {
+      pathname: pathname || "/",
+      query: new URLSearchParams(rawQuery || ""),
+      hash: rawHash
+    };
+  }
+}
+__name(splitInternalHref, "splitInternalHref");
+function mergeQueryParams(current, next) {
+  const merged = new URLSearchParams(current);
+  if (next instanceof URLSearchParams) {
+    for (const [key, value] of next.entries()) {
+      merged.append(key, value);
+    }
+  } else if (next) {
+    for (const [key, value] of Object.entries(next)) {
+      const values = Array.isArray(value) ? value : [value];
+      for (const item of values) {
+        if (item == null) continue;
+        merged.append(key, String(item));
+      }
+    }
+  }
+  return merged.toString() ? merged : void 0;
+}
+__name(mergeQueryParams, "mergeQueryParams");
+function applyPreservedSearchParams(href) {
+  if (typeof window === "undefined") return href;
+  const manifest = window.__FARM_MANIFEST__;
+  const routes = manifest?.routes && typeof manifest.routes === "object" ? Object.values(manifest.routes) : [];
+  if (routes.length === 0) return href;
+  const url = new URL(href, window.location.origin);
+  const route2 = routes.find((candidate) => matchManifestRoute(url.pathname, candidate));
+  const preserve = Array.isArray(route2?.search?.preserve) ? route2.search.preserve : [];
+  if (preserve.length === 0) return href;
+  const current = new URLSearchParams(window.location.search);
+  let changed = false;
+  for (const key of preserve) {
+    if (url.searchParams.has(key) || !current.has(key)) continue;
+    for (const value of current.getAll(key)) {
+      url.searchParams.append(key, value);
+      changed = true;
+    }
+  }
+  if (!changed) return href;
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+__name(applyPreservedSearchParams, "applyPreservedSearchParams");
+function matchManifestRoute(pathname, route2) {
+  if (!route2 || !Array.isArray(route2.segments)) return false;
+  const routeSegments = route2.segments;
+  const normalized = pathname === "/" ? "" : pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+  const pathSegments = normalized ? normalized.split("/") : [];
+  const hasCatchAll = routeSegments.some((segment) => segment.isCatchAll);
+  if (!hasCatchAll && pathSegments.length !== routeSegments.length) {
+    return false;
+  }
+  for (let index = 0; index < routeSegments.length; index++) {
+    const routeSegment = routeSegments[index];
+    const pathSegment = pathSegments[index];
+    if (routeSegment.isCatchAll) {
+      return true;
+    }
+    if (pathSegment === void 0) {
+      if (routeSegment.isOptional) continue;
+      return false;
+    }
+    if (!routeSegment.isDynamic && routeSegment.segment !== pathSegment) {
+      return false;
+    }
+  }
+  return pathSegments.length === routeSegments.length || hasCatchAll;
+}
+__name(matchManifestRoute, "matchManifestRoute");
+
+// src/client/router.ts
+var import_react4 = require("react");
+
+// src/deferred.ts
+var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+var FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+var FARM_DEFERRED_MARKER = "$farmDeferred";
+var _DeferredDataError = class _DeferredDataError extends Error {
+  constructor(message = "Deferred route data failed to load") {
+    super(message);
+    this.name = "DeferredDataError";
+    this.code = FARM_DEFERRED_ERROR_CODE;
+  }
+};
+__name(_DeferredDataError, "DeferredDataError");
+var DeferredDataError = _DeferredDataError;
+async function readDeferredDataResponse(response) {
+  const contentType = response.headers.get("Content-Type") || "";
+  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
+    return await response.json();
+  }
+  if (!response.body) {
+    throw new DeferredDataError("Deferred route data response has no body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const controllers = /* @__PURE__ */ new Map();
+  let buffer = "";
+  let complete = false;
+  const readLine = /* @__PURE__ */ __name(async () => {
+    while (true) {
+      const newline = buffer.indexOf("\n");
+      if (newline >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        return line;
+      }
+      if (complete) {
+        if (!buffer) return void 0;
+        const line = buffer;
+        buffer = "";
+        return line;
+      }
+      const chunk = await reader.read();
+      complete = chunk.done;
+      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+      if (chunk.done) buffer += decoder.decode();
+    }
+  }, "readLine");
+  const firstLine = await readLine();
+  if (!firstLine) {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is empty");
+  }
+  const initial = parseDeferredMessage(firstLine);
+  if (initial.type !== "data") {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is invalid");
+  }
+  const data = reviveDeferredValue(initial.data, controllers);
+  void (async () => {
+    try {
+      for (let line = await readLine(); line !== void 0; line = await readLine()) {
+        if (!line) continue;
+        const message = parseDeferredMessage(line);
+        if (message.type === "resolve") {
+          const controller = getControlledDeferred(message.id, controllers);
+          controller.resolve(reviveDeferredValue(message.data, controllers));
+        } else if (message.type === "reject") {
+          getControlledDeferred(message.id, controllers).reject(
+            new DeferredDataError(message.error?.message)
+          );
+        }
+      }
+      rejectPendingDeferred(controllers, "Deferred route data stream ended before completion");
+    } catch {
+      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return data;
+}
+__name(readDeferredDataResponse, "readDeferredDataResponse");
+function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
+  if (isDeferredMarker(value)) {
+    const id = value[FARM_DEFERRED_MARKER];
+    const controller = getControlledDeferred(id, controllers);
+    const settlement = settlements?.[id];
+    if (settlement && controller.promise.status === "pending") {
+      if (applyingSettlements.has(id)) return controller.promise;
+      applyingSettlements.add(id);
+      if (settlement.status === "fulfilled") {
+        controller.resolve(
+          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements)
+        );
+      } else {
+        controller.reject(new DeferredDataError(settlement.error.message));
+      }
+      applyingSettlements.delete(id);
+    } else if (settlements && controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError("Deferred route data was not resolved"));
+    }
+    return controller.promise;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => reviveDeferredValue(item, controllers, settlements, applyingSettlements)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    output[key] = reviveDeferredValue(item, controllers, settlements, applyingSettlements);
+  }
+  return output;
+}
+__name(reviveDeferredValue, "reviveDeferredValue");
+function getControlledDeferred(id, controllers) {
+  const existing = controllers.get(id);
+  if (existing) return existing;
+  let nativeResolve;
+  let nativeReject;
+  const promise = new Promise((resolve, reject) => {
+    nativeResolve = resolve;
+    nativeReject = reject;
+  });
+  promise.status = "pending";
+  promise.catch(() => void 0);
+  const controlled = {
+    promise,
+    resolve(value) {
+      if (promise.status !== "pending") return;
+      promise.status = "fulfilled";
+      promise.value = value;
+      nativeResolve(value);
+    },
+    reject(error) {
+      if (promise.status !== "pending") return;
+      promise.status = "rejected";
+      promise.reason = error;
+      nativeReject(error);
+    }
+  };
+  controllers.set(id, controlled);
+  return controlled;
+}
+__name(getControlledDeferred, "getControlledDeferred");
+function isDeferredMarker(value) {
+  return Boolean(
+    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
+  );
+}
+__name(isDeferredMarker, "isDeferredMarker");
+function parseDeferredMessage(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new DeferredDataError("Deferred route data response contains invalid JSON");
+  }
+}
+__name(parseDeferredMessage, "parseDeferredMessage");
+function rejectPendingDeferred(controllers, message) {
+  for (const controller of controllers.values()) {
+    if (controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError(message));
+    }
+  }
+}
+__name(rejectPendingDeferred, "rejectPendingDeferred");
+
+// src/deployment.ts
+var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
+var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
+var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
+var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+var _FarmDeploymentMismatchError = class _FarmDeploymentMismatchError extends Error {
+  constructor(clientDeploymentId, serverDeploymentId) {
+    super("The application was updated while this page was open. Refresh before trying again.");
+    this.clientDeploymentId = clientDeploymentId;
+    this.serverDeploymentId = serverDeploymentId;
+    this.name = "FarmDeploymentMismatchError";
+    this.code = FARM_DEPLOYMENT_MISMATCH_CODE;
+    this.retryable = false;
+  }
+};
+__name(_FarmDeploymentMismatchError, "FarmDeploymentMismatchError");
+var FarmDeploymentMismatchError = _FarmDeploymentMismatchError;
+function createFarmDeploymentRequestHeaders(deploymentId, init) {
+  const headers = new Headers(init);
+  if (deploymentId) {
+    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  }
+  return headers;
+}
+__name(createFarmDeploymentRequestHeaders, "createFarmDeploymentRequestHeaders");
+function getFarmResponseDeploymentId(response) {
+  return response.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim() || void 0;
+}
+__name(getFarmResponseDeploymentId, "getFarmResponseDeploymentId");
+function isFarmDeploymentMismatchResponse(response, clientDeploymentId) {
+  const serverDeploymentId = getFarmResponseDeploymentId(response);
+  if (clientDeploymentId && serverDeploymentId && clientDeploymentId !== serverDeploymentId) {
+    return true;
+  }
+  return response.status === FARM_DEPLOYMENT_MISMATCH_STATUS && response.headers.get(FARM_DEPLOYMENT_MISMATCH_HEADER) === "1";
+}
+__name(isFarmDeploymentMismatchResponse, "isFarmDeploymentMismatchResponse");
+function createFarmDeploymentMismatchError(response, clientDeploymentId) {
+  return new FarmDeploymentMismatchError(
+    clientDeploymentId,
+    getFarmResponseDeploymentId(response) || "unknown"
+  );
+}
+__name(createFarmDeploymentMismatchError, "createFarmDeploymentMismatchError");
+
+// src/client/spa-router.ts
+var FARM_PAGE_STATE_KEY = "__farmPageState";
+var IDLE_NAVIGATION_STATE = {
+  state: "idle",
+  pending: false,
+  from: null,
+  to: null,
+  action: null,
+  startedAt: null
+};
+var routerInstance = null;
+var _SPARouter = class _SPARouter {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.prefetchingUrls = /* @__PURE__ */ new Set();
+    this.observers = /* @__PURE__ */ new Map();
+    this.blockers = /* @__PURE__ */ new Set();
+    this.navigationListeners = /* @__PURE__ */ new Set();
+    this.navigationState = IDLE_NAVIGATION_STATE;
+    this.scrollElements = /* @__PURE__ */ new Map();
+    this.options = {
+      prefetchTimeout: options.prefetchTimeout ?? 100,
+      cacheMaxAge: options.cacheMaxAge ?? 3e4,
+      // 30 seconds
+      scrollRestoration: options.scrollRestoration ?? true,
+      shouldUseDocumentNavigation: options.shouldUseDocumentNavigation ?? (() => false),
+      deploymentId: options.deploymentId ?? readBrowserDeploymentId()
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("popstate", this.handlePopState.bind(this));
+      window.addEventListener("beforeunload", (event) => {
+        if (this.blockers.size > 0) {
+          event.preventDefault();
+          event.returnValue = "";
+        }
+        this.saveScrollPosition(window.location.pathname);
+      });
+    }
+  }
+  /**
+   * Set the navigation handler that updates React
+   */
+  setNavigationHandler(handler) {
+    this.onNavigate = handler;
+  }
+  /**
+   * Connect Farm's browser plugin lifecycle to SPA navigation.
+   */
+  setClientPluginManager(manager) {
+    this.clientPlugins = manager;
+  }
+  /**
+   * Navigate to a new URL
+   */
+  async navigate(href, options = {}) {
+    const { replace = false, scroll = true, state, viewTransition = false } = options;
+    const url = new URL(href, window.location.origin);
+    const pathname = url.pathname;
+    const search = url.search;
+    const fullPath = pathname + search;
+    if (isFarmLocaleChangeHref(url.toString()) || this.options.shouldUseDocumentNavigation(pathname)) {
+      if (replace) window.location.replace(url.toString());
+      else window.location.assign(url.toString());
+      return;
+    }
+    if (pathname === window.location.pathname && search === window.location.search) {
+      if (url.hash) {
+        window.location.hash = url.hash;
+      }
+      return;
+    }
+    const from = window.location.pathname + window.location.search;
+    if (await this.shouldBlockNavigation({ from, to: fullPath, action: replace ? "replace" : "push" })) {
+      return;
+    }
+    if (this.options.scrollRestoration) {
+      this.saveScrollPosition(window.location.pathname);
+    }
+    this.startNavigation({
+      from,
+      to: createNavigationLocation(url),
+      action: replace ? "replace" : "push"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await this.clientPlugins?.beginNavigation({
+        from,
+        to: url,
+        action: replace ? "replace" : "push"
+      });
+      const pageData = await this.fetchPageData(fullPath);
+      if (clientNavigation) {
+        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
+      }
+      if (pageData.isClientComponent === false) {
+        this.finishNavigation();
+        window.location.assign(pageData.canonicalPath || fullPath);
+        return;
+      }
+      await this.runViewTransition(
+        viewTransition,
+        () => this.commitNavigation({
+          fullPath,
+          pageData,
+          pathname,
+          replace,
+          scroll,
+          state,
+          url
+        })
+      );
+      if (clientNavigation) {
+        await this.clientPlugins?.resolveNavigation(clientNavigation);
+        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
+      }
+      this.finishNavigation();
+    } catch (error) {
+      if (clientNavigation) {
+        await this.clientPlugins?.failNavigation(clientNavigation, error);
+      }
+      this.finishNavigation();
+      console.error("[Farm.js] Navigation error:", error);
+      window.location.href = href;
+    }
+  }
+  /**
+   * Prefetch a URL
+   */
+  async prefetch(href) {
+    if (isFarmLocaleChangeHref(href)) return;
+    const url = new URL(href, window.location.origin);
+    const fullPath = url.pathname + url.search;
+    if (this.prefetchingUrls.has(fullPath)) return;
+    if (this.isCached(fullPath)) return;
+    this.prefetchingUrls.add(fullPath);
+    try {
+      await this.fetchPageData(fullPath, false);
+    } catch (error) {
+      console.warn("[Farm.js] Prefetch failed:", href, error);
+    } finally {
+      this.prefetchingUrls.delete(fullPath);
+    }
+  }
+  /**
+   * Observe an element for viewport intersection (prefetch when visible)
+   */
+  observeForPrefetch(element) {
+    if (typeof IntersectionObserver === "undefined") return;
+    const href = element.getAttribute("href");
+    if (!href || this.isExternalUrl(href)) return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            setTimeout(() => {
+              this.prefetch(href);
+            }, this.options.prefetchTimeout);
+            observer.unobserve(element);
+            this.observers.delete(element);
+          }
+        }
+      },
+      { rootMargin: "200px" }
+      // Start prefetching when 200px from viewport
+    );
+    observer.observe(element);
+    this.observers.set(element, observer);
+  }
+  /**
+   * Stop observing an element
+   */
+  unobserveForPrefetch(element) {
+    const observer = this.observers.get(element);
+    if (observer) {
+      observer.unobserve(element);
+      this.observers.delete(element);
+    }
+  }
+  addBlocker(blocker) {
+    this.blockers.add(blocker);
+    return () => {
+      this.blockers.delete(blocker);
+    };
+  }
+  getNavigationState() {
+    return this.navigationState;
+  }
+  subscribeNavigation(listener) {
+    this.navigationListeners.add(listener);
+    listener(this.navigationState);
+    return () => {
+      this.navigationListeners.delete(listener);
+    };
+  }
+  registerScrollElement(key, element) {
+    this.scrollElements.set(key, element);
+    this.restoreScrollElement(window.location.pathname, key, element);
+    return () => {
+      if (this.scrollElements.get(key) === element) {
+        this.scrollElements.delete(key);
+      }
+    };
+  }
+  pushState(state, href) {
+    this.writePageState("push", state, href);
+  }
+  replaceState(state, href) {
+    this.writePageState("replace", state, href);
+  }
+  async commitNavigation(options) {
+    const historyPath = options.pageData.canonicalPath || options.fullPath;
+    const historyState = createHistoryState(historyPath, options.state);
+    if (options.replace) {
+      window.history.replaceState(historyState, "", historyPath);
+    } else {
+      window.history.pushState(historyState, "", historyPath);
+    }
+    if (options.pageData.metadata?.title) {
+      document.title = options.pageData.metadata.title;
+    }
+    if (options.pageData.metadata?.description) {
+      let metaDesc = document.querySelector('meta[name="description"]');
+      if (!metaDesc) {
+        metaDesc = document.createElement("meta");
+        metaDesc.setAttribute("name", "description");
+        document.head.appendChild(metaDesc);
+      }
+      metaDesc.setAttribute("content", options.pageData.metadata.description);
+    }
+    _hydrateFarmI18n(options.pageData.i18n);
+    if (this.onNavigate) {
+      await this.onNavigate(options.pageData);
+    }
+    if (options.scroll) {
+      if (options.url.hash) {
+        const element = document.querySelector(options.url.hash);
+        if (element) {
+          element.scrollIntoView();
+        }
+      } else {
+        window.scrollTo(0, 0);
+      }
+    } else if (this.options.scrollRestoration) {
+      this.restoreScrollPosition(options.pathname);
+    }
+  }
+  async runViewTransition(mode, callback) {
+    if (!mode || typeof document === "undefined") {
+      await callback();
+      return;
+    }
+    const startViewTransition = document.startViewTransition;
+    if (typeof startViewTransition !== "function") {
+      await callback();
+      return;
+    }
+    const transition = startViewTransition.call(document, () => callback());
+    const updateDone = transition?.updateCallbackDone || transition?.ready;
+    if (updateDone && typeof updateDone.then === "function") {
+      await updateDone;
+    }
+    transition?.finished?.catch?.(() => void 0);
+  }
+  /**
+   * Fetch page data from cache or server
+   */
+  async fetchPageData(path, recover = true) {
+    const cached = this.cache.get(path);
+    if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
+      return cached.data;
+    }
+    const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path)}`, {
+      headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
+        Accept: "application/x-farm-deferred+json, application/json",
+        "X-Farm-SPA": "1"
+      })
+    });
+    if (isFarmDeploymentMismatchResponse(response, this.options.deploymentId)) {
+      const error = createFarmDeploymentMismatchError(
+        response,
+        this.options.deploymentId || "unknown"
+      );
+      dispatchDeploymentMismatch(error);
+      if (recover) {
+        window.location.assign(path);
+      }
+      throw error;
+    }
+    if (!response.ok) {
+      throw new Error(`Failed to fetch page data: ${response.status}`);
+    }
+    const data = await readDeferredDataResponse(response);
+    this.cache.set(path, {
+      data,
+      timestamp: Date.now()
+    });
+    return data;
+  }
+  /**
+   * Handle browser back/forward navigation
+   */
+  async handlePopState(event) {
+    if (document.documentElement.dataset.farmDocsRuntime === "true") return;
+    const path = window.location.pathname + window.location.search;
+    if (await this.shouldBlockNavigation({
+      from: event.state?.path || path,
+      to: path,
+      action: "pop"
+    })) {
+      return;
+    }
+    this.startNavigation({
+      from: event.state?.path || path,
+      to: createNavigationLocation(new URL(window.location.href)),
+      action: "pop"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await this.clientPlugins?.beginNavigation({
+        from: null,
+        to: window.location.href,
+        action: "pop"
+      });
+      const pageData = await this.fetchPageData(path);
+      if (clientNavigation) {
+        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
+      }
+      if (pageData.metadata?.title) {
+        document.title = pageData.metadata.title;
+      }
+      _hydrateFarmI18n(pageData.i18n);
+      if (this.onNavigate) {
+        await this.onNavigate(pageData);
+      }
+      if (this.options.scrollRestoration) {
+        this.restoreScrollPosition(window.location.pathname);
+      }
+      if (clientNavigation) {
+        await this.clientPlugins?.resolveNavigation(clientNavigation);
+        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
+      }
+      this.finishNavigation();
+    } catch (error) {
+      if (clientNavigation) {
+        await this.clientPlugins?.failNavigation(clientNavigation, error);
+      }
+      this.finishNavigation();
+      console.error("[Farm.js] Popstate navigation error:", error);
+      window.location.reload();
+    }
+  }
+  /**
+   * Check if URL is cached
+   */
+  isCached(path) {
+    const cached = this.cache.get(path);
+    return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
+  }
+  /**
+   * Check if URL is external
+   */
+  isExternalUrl(href) {
+    return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
+  }
+  async shouldBlockNavigation(context) {
+    for (const blocker of this.blockers) {
+      if (await blocker(context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  startNavigation(options) {
+    this.setNavigationState({
+      state: "loading",
+      pending: true,
+      from: options.from,
+      to: options.to,
+      action: options.action,
+      startedAt: Date.now()
+    });
+  }
+  finishNavigation() {
+    this.setNavigationState(IDLE_NAVIGATION_STATE);
+  }
+  setNavigationState(state) {
+    this.navigationState = state;
+    for (const listener of this.navigationListeners) {
+      listener(state);
+    }
+  }
+  writePageState(action, state, href) {
+    if (typeof window === "undefined") return;
+    const url = href ? new URL(href, window.location.origin).toString() : window.location.href;
+    const nextState = createHistoryState(
+      new URL(url).pathname + new URL(url).search,
+      state,
+      window.history.state
+    );
+    if (action === "replace") {
+      window.history.replaceState(nextState, "", url);
+    } else {
+      window.history.pushState(nextState, "", url);
+    }
+    window.dispatchEvent(new PopStateEvent("popstate", { state: nextState }));
+  }
+  /**
+   * Save scroll position for a path
+   */
+  saveScrollPosition(path) {
+    try {
+      sessionStorage.setItem(
+        `farm-scroll-${path}`,
+        JSON.stringify({ x: window.scrollX, y: window.scrollY })
+      );
+      for (const [key, element] of this.scrollElements) {
+        sessionStorage.setItem(
+          getScrollElementStorageKey(path, key),
+          JSON.stringify({ x: element.scrollLeft, y: element.scrollTop })
+        );
+      }
+    } catch {
+    }
+  }
+  /**
+   * Restore scroll position for a path
+   */
+  restoreScrollPosition(path) {
+    try {
+      const saved = sessionStorage.getItem(`farm-scroll-${path}`);
+      if (saved) {
+        const { x, y } = JSON.parse(saved);
+        setTimeout(() => window.scrollTo(x, y), 0);
+      }
+      for (const [key, element] of this.scrollElements) {
+        this.restoreScrollElement(path, key, element);
+      }
+    } catch {
+    }
+  }
+  restoreScrollElement(path, key, element) {
+    try {
+      const saved = sessionStorage.getItem(getScrollElementStorageKey(path, key));
+      if (!saved) return;
+      const { x, y } = JSON.parse(saved);
+      setTimeout(() => {
+        element.scrollLeft = x;
+        element.scrollTop = y;
+      }, 0);
+    } catch {
+    }
+  }
+  /**
+   * Clear the page cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+__name(_SPARouter, "SPARouter");
+var SPARouter = _SPARouter;
+function readBrowserDeploymentId() {
+  if (typeof window === "undefined") return void 0;
+  const runtimeId = window.__FARM_DEPLOYMENT_ID__;
+  if (typeof runtimeId === "string" && runtimeId) return runtimeId;
+  return document.querySelector('meta[name="farm-deployment-id"]')?.content;
+}
+__name(readBrowserDeploymentId, "readBrowserDeploymentId");
+function dispatchDeploymentMismatch(error) {
+  if (typeof window === "undefined" || typeof CustomEvent === "undefined") return;
+  window.dispatchEvent(new CustomEvent("farm:deployment-mismatch", { detail: error }));
+}
+__name(dispatchDeploymentMismatch, "dispatchDeploymentMismatch");
+function getRouter2() {
+  if (typeof window === "undefined") {
+    return new SPARouter();
+  }
+  const installedRouter = window.__FARM_SPA_ROUTER__;
+  if (installedRouter) {
+    routerInstance = installedRouter;
+    return installedRouter;
+  }
+  if (!routerInstance) {
+    routerInstance = new SPARouter();
+  }
+  return routerInstance;
+}
+__name(getRouter2, "getRouter");
+function navigateTo(href, options) {
+  return getRouter2().navigate(href, options);
+}
+__name(navigateTo, "navigateTo");
+function prefetch(href) {
+  return getRouter2().prefetch(href);
+}
+__name(prefetch, "prefetch");
+function pushState(state, href) {
+  getRouter2().pushState(state, href);
+}
+__name(pushState, "pushState");
+function replaceState(state, href) {
+  getRouter2().replaceState(state, href);
+}
+__name(replaceState, "replaceState");
+function readPageState() {
+  if (typeof window === "undefined") return null;
+  const state = window.history.state;
+  if (!state || typeof state !== "object") return null;
+  return state[FARM_PAGE_STATE_KEY] ?? null;
+}
+__name(readPageState, "readPageState");
+function createHistoryState(path, pageState, currentState) {
+  const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
+  return {
+    ...base,
+    path,
+    [FARM_PAGE_STATE_KEY]: pageState
+  };
+}
+__name(createHistoryState, "createHistoryState");
+function createNavigationLocation(url) {
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+__name(createNavigationLocation, "createNavigationLocation");
+function getScrollElementStorageKey(path, key) {
+  return `farm-scroll-${path}:${key}`;
+}
+__name(getScrollElementStorageKey, "getScrollElementStorageKey");
+
+// src/client/router.ts
+function useRouter(options = {}) {
+  const basePath = options.basePath || "";
+  const routes = options.routes;
+  const routeKey = routes?.map((route2) => typeof route2 === "string" ? route2 : route2.path).join("\n") || "";
+  const routeMatcher = (0, import_react4.useMemo)(
+    () => routeKey ? createFarmRouter(routeKey.split("\n")) : null,
+    [routeKey]
+  );
+  const [state, setState] = (0, import_react4.useState)(() => {
+    return readRouterState(basePath, routeMatcher);
+  });
+  (0, import_react4.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const handlePopState = /* @__PURE__ */ __name(() => {
+      setState(readRouterState(basePath, routeMatcher));
+    }, "handlePopState");
+    handlePopState();
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, [basePath, routeMatcher]);
+  const push = /* @__PURE__ */ __name((href) => {
+    if (typeof window === "undefined") return;
+    const url = href.startsWith("/") ? basePath + href : href;
+    window.history.pushState(null, "", url);
+    window.dispatchEvent(new PopStateEvent("popstate"));
+  }, "push");
+  const replace = /* @__PURE__ */ __name((href) => {
+    if (typeof window === "undefined") return;
+    const url = href.startsWith("/") ? basePath + href : href;
+    window.history.replaceState(null, "", url);
+    window.dispatchEvent(new PopStateEvent("popstate"));
+  }, "replace");
+  const pushState2 = /* @__PURE__ */ __name((pageState, href) => {
+    if (typeof window === "undefined") return;
+    getRouter2().pushState(pageState, resolveClientHref(href, basePath));
+  }, "pushState");
+  const replaceState2 = /* @__PURE__ */ __name((pageState, href) => {
+    if (typeof window === "undefined") return;
+    getRouter2().replaceState(pageState, resolveClientHref(href, basePath));
+  }, "replaceState");
+  const back = /* @__PURE__ */ __name(() => {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  }, "back");
+  const forward = /* @__PURE__ */ __name(() => {
+    if (typeof window !== "undefined") {
+      window.history.forward();
+    }
+  }, "forward");
+  return {
+    ...state,
+    push,
+    replace,
+    pushState: pushState2,
+    replaceState: replaceState2,
+    back,
+    forward
+  };
+}
+__name(useRouter, "useRouter");
+function usePageState() {
+  const [state, setState] = (0, import_react4.useState)(() => readPageState());
+  (0, import_react4.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const handlePopState = /* @__PURE__ */ __name(() => {
+      setState(readPageState());
+    }, "handlePopState");
+    handlePopState();
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, []);
+  return state;
+}
+__name(usePageState, "usePageState");
+function useNavigation() {
+  const [state, setState] = (0, import_react4.useState)(
+    () => getRouter2().getNavigationState()
+  );
+  (0, import_react4.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    return getRouter2().subscribeNavigation(setState);
+  }, []);
+  return state;
+}
+__name(useNavigation, "useNavigation");
+function useBlocker(options) {
+  const optionsRef = (0, import_react4.useRef)(options);
+  optionsRef.current = options;
+  const active = Boolean(options.when);
+  (0, import_react4.useEffect)(() => {
+    if (typeof window === "undefined" || !active) {
+      return;
+    }
+    return getRouter2().addBlocker(async (context) => {
+      const current = optionsRef.current;
+      const when = typeof current.when === "function" ? current.when(context) : current.when;
+      if (!when) return false;
+      if (current.shouldBlock && !await current.shouldBlock(context)) {
+        return false;
+      }
+      if (current.message && typeof window.confirm === "function") {
+        return !window.confirm(current.message);
+      }
+      return true;
+    });
+  }, [active]);
+  return { active };
+}
+__name(useBlocker, "useBlocker");
+function useScrollRestoration(key) {
+  const ref = (0, import_react4.useRef)(null);
+  (0, import_react4.useEffect)(() => {
+    const element = ref.current;
+    if (!element) return;
+    return getRouter2().registerScrollElement(key, element);
+  }, [key]);
+  return ref;
+}
+__name(useScrollRestoration, "useScrollRestoration");
+function readRouterState(basePath, routeMatcher) {
+  if (typeof window === "undefined") {
+    return {
+      pathname: "/",
+      searchParams: new URLSearchParams(),
+      params: {},
+      pageState: null
+    };
+  }
+  const url = new URL(window.location.href);
+  const pathname = normalizeClientPathname(url.pathname, basePath);
+  const i18n = getFarmI18nClientState();
+  const routePathname = i18n ? stripFarmLocaleFromPathname(pathname, i18n) : pathname;
+  return {
+    pathname,
+    searchParams: url.searchParams,
+    params: routeMatcher?.match(routePathname)?.params || {},
+    pageState: readPageState()
+  };
+}
+__name(readRouterState, "readRouterState");
+function normalizeClientPathname(pathname, basePath) {
+  const normalizedBase = basePath.replace(/\/+$/, "");
+  const isUnderBase = normalizedBase && (pathname === normalizedBase || pathname.startsWith(`${normalizedBase}/`));
+  const withoutBase = isUnderBase ? pathname.slice(normalizedBase.length) || "/" : pathname;
+  return withoutBase || "/";
+}
+__name(normalizeClientPathname, "normalizeClientPathname");
+function resolveClientHref(href, basePath) {
+  if (!href) return void 0;
+  return href.startsWith("/") ? basePath + href : href;
+}
+__name(resolveClientHref, "resolveClientHref");
+
+// src/client/chunk-recovery.ts
+var DEFAULT_MAX_AGE_MS = 3e4;
+var STORAGE_KEY_PREFIX = "farm:chunk-recovery:";
+var CHUNK_ERROR_PATTERNS = [
+  /ChunkLoadError/i,
+  /Loading chunk [\w-]+ failed/i,
+  /Loading CSS chunk [\w-]+ failed/i,
+  /CSS_CHUNK_LOAD_FAILED/i,
+  /failed to fetch dynamically imported module/i,
+  /error loading dynamically imported module/i,
+  /importing a module script failed/i,
+  /unable to preload CSS/i,
+  /module script failed/i
+];
+function isChunkLoadError(errorLike) {
+  const values = collectErrorText(errorLike);
+  if (values.some((value) => CHUNK_ERROR_PATTERNS.some((pattern) => pattern.test(value)))) {
+    return true;
+  }
+  const targetUrl = getEventTargetAssetUrl(errorLike);
+  return Boolean(targetUrl && /\.(?:m?js|css)(?:[?#].*)?$/i.test(targetUrl));
+}
+__name(isChunkLoadError, "isChunkLoadError");
+function installChunkErrorRecovery(options = {}) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const recover = /* @__PURE__ */ __name((errorLike) => {
+    if (!isChunkLoadError(errorLike)) {
+      return;
+    }
+    if (!markRecovered(options)) {
+      return;
+    }
+    options.onRecover?.(errorLike);
+    getReload(options)();
+  }, "recover");
+  const onError = /* @__PURE__ */ __name((event) => {
+    recover(getErrorEventPayload(event));
+  }, "onError");
+  const onUnhandledRejection = /* @__PURE__ */ __name((event) => {
+    recover(event.reason);
+  }, "onUnhandledRejection");
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+__name(installChunkErrorRecovery, "installChunkErrorRecovery");
+function markRecovered(options) {
+  const now2 = getNow(options);
+  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const storage = getStorage(options);
+  const key = getStorageKey(options);
+  if (!storage) {
+    return true;
+  }
+  try {
+    const previous = Number(storage.getItem(key));
+    if (Number.isFinite(previous) && previous > 0 && now2 - previous < maxAgeMs) {
+      return false;
+    }
+    storage.setItem(key, String(now2));
+    return true;
+  } catch {
+    return true;
+  }
+}
+__name(markRecovered, "markRecovered");
+function getErrorEventPayload(event) {
+  if ("error" in event && event.error) {
+    return event.error;
+  }
+  if ("message" in event && event.message) {
+    return event.message;
+  }
+  return event;
+}
+__name(getErrorEventPayload, "getErrorEventPayload");
+function collectErrorText(value, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || seen.has(value)) {
+    return [];
+  }
+  seen.add(value);
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+  const record = value;
+  const output = [];
+  for (const key of ["name", "message", "code", "type", "request", "src", "href"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string") {
+      output.push(candidate);
+    }
+  }
+  if ("reason" in record) {
+    output.push(...collectErrorText(record.reason, seen));
+  }
+  if ("error" in record) {
+    output.push(...collectErrorText(record.error, seen));
+  }
+  return output;
+}
+__name(collectErrorText, "collectErrorText");
+function getEventTargetAssetUrl(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const target = value.target;
+  if (!target || typeof target !== "object") {
+    return void 0;
+  }
+  const tagName = typeof target.tagName === "string" ? target.tagName.toLowerCase() : "";
+  if (tagName !== "script" && tagName !== "link") {
+    return void 0;
+  }
+  return typeof target.src === "string" && target.src ? target.src : typeof target.href === "string" && target.href ? target.href : void 0;
+}
+__name(getEventTargetAssetUrl, "getEventTargetAssetUrl");
+function getStorage(options) {
+  if ("storage" in options) {
+    return options.storage;
+  }
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+__name(getStorage, "getStorage");
+function getStorageKey(options) {
+  if (options.storageKey) {
+    return options.storageKey;
+  }
+  const location = getLocation(options);
+  return `${STORAGE_KEY_PREFIX}${location.pathname}${location.search}`;
+}
+__name(getStorageKey, "getStorageKey");
+function getLocation(options) {
+  return options.location ?? window.location;
+}
+__name(getLocation, "getLocation");
+function getReload(options) {
+  if (options.reload) {
+    return options.reload;
+  }
+  const location = getLocation(options);
+  return () => location.reload();
+}
+__name(getReload, "getReload");
+function getNow(options) {
+  return options.now ? options.now() : Date.now();
+}
+__name(getNow, "getNow");
+
+// src/client/plugin.ts
+var PERFORMANCE_ENTRY_TYPES = [
+  "navigation",
+  "paint",
+  "largest-contentful-paint",
+  "layout-shift",
+  "event"
+];
+var _FarmClientPluginManager = class _FarmClientPluginManager {
+  constructor(registrations, options) {
+    this.instances = [];
+    this.performanceObservers = [];
+    this.navigationSequence = 0;
+    this.starting = false;
+    this.started = false;
+    this.closed = false;
+    this.reportedErrors = /* @__PURE__ */ new WeakSet();
+    this.handleWindowError = /* @__PURE__ */ __name((event) => {
+      const error = event.error ?? new Error(event.message || "Unknown browser error");
+      void this.reportError(error, "window");
+    }, "handleWindowError");
+    this.handleUnhandledRejection = /* @__PURE__ */ __name((event) => {
+      void this.reportError(event.reason, "unhandled-rejection");
+    }, "handleUnhandledRejection");
+    this.handlePageHide = /* @__PURE__ */ __name(() => {
+      void this.close("pagehide");
+    }, "handlePageHide");
+    this.registrations = sortRegistrations(registrations);
+    this.options = {
+      ...options,
+      isDev: options.isDev ?? false,
+      isProd: options.isProd ?? !options.isDev,
+      window: options.window ?? (typeof window !== "undefined" ? window : void 0)
+    };
+  }
+  start() {
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = Promise.resolve().then(() => this.startInternal());
+    return this.startPromise;
+  }
+  async beginHydration(input) {
+    await this.start();
+    const session = {
+      ...input,
+      location: this.getLocation(),
+      startedAt: now()
+    };
+    await this.runHook(
+      "hydration.before",
+      (instance) => instance.plugin.hydration?.before?.({
+        ...this.createStateEvent(instance),
+        ...session
+      })
+    );
+    return session;
+  }
+  async completeHydration(session, options = {}) {
+    await this.runHook(
+      "hydration.after",
+      (instance) => instance.plugin.hydration?.after?.({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt,
+        recovered: options.recovered ?? false
+      })
+    );
+  }
+  async failHydration(session, error) {
+    await this.reportError(error, "hydration", void 0, session.location);
+  }
+  async beginNavigation(input) {
+    await this.start();
+    this.currentNavigation?.controller.abort("superseded");
+    const controller = new AbortController();
+    const session = {
+      id: `navigation:${++this.navigationSequence}`,
+      from: input.from === null ? null : toClientLocation(input.from ?? this.getLocation().href, this.getBaseUrl()),
+      to: toClientLocation(input.to, this.getBaseUrl()),
+      action: input.action,
+      signal: controller.signal,
+      startedAt: now(),
+      route: input.route
+    };
+    this.currentNavigation = { controller, session };
+    await this.runHook(
+      "navigation.before",
+      (instance) => instance.plugin.navigation?.before?.({
+        ...this.createStateEvent(instance),
+        ...session
+      })
+    );
+    return session;
+  }
+  async markNavigationLoaded(session, data) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.loaded",
+      (instance) => instance.plugin.navigation?.loaded?.({
+        ...this.createStateEvent(instance),
+        ...session,
+        data,
+        durationMs: now() - session.startedAt
+      })
+    );
+  }
+  async resolveNavigation(session) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.resolved",
+      (instance) => instance.plugin.navigation?.resolved?.({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt
+      })
+    );
+  }
+  scheduleNavigationRendered(session) {
+    if (session.signal.aborted) return Promise.resolve();
+    const clientWindow = this.options.window;
+    const schedule = clientWindow?.requestAnimationFrame ? (callback) => clientWindow.requestAnimationFrame(() => clientWindow.requestAnimationFrame(callback)) : (callback) => setTimeout(callback, 0);
+    return new Promise((resolve) => {
+      schedule(() => {
+        if (session.signal.aborted || this.closed) {
+          resolve();
+          return;
+        }
+        void this.runHook(
+          "navigation.rendered",
+          (instance) => instance.plugin.navigation?.rendered?.({
+            ...this.createStateEvent(instance),
+            ...session,
+            durationMs: now() - session.startedAt
+          })
+        ).finally(() => {
+          if (this.currentNavigation?.session === session) {
+            this.currentNavigation = void 0;
+          }
+          resolve();
+        });
+      });
+    });
+  }
+  async failNavigation(session, error) {
+    if (!session.signal.aborted) {
+      await this.runHook(
+        "navigation.error",
+        (instance) => instance.plugin.navigation?.error?.({
+          ...this.createStateEvent(instance),
+          ...session,
+          durationMs: now() - session.startedAt,
+          error
+        })
+      );
+      await this.reportError(error, "navigation", session, session.to);
+    }
+    if (this.currentNavigation?.session === session) {
+      this.currentNavigation = void 0;
+    }
+  }
+  async reportError(error, phase, navigation, location = this.getLocation()) {
+    if (this.closed) return;
+    if (isObject(error)) {
+      if (this.reportedErrors.has(error)) return;
+      this.reportedErrors.add(error);
+    }
+    if (!this.started && !this.starting) await this.start();
+    await this.runErrorHooks({ error, phase, navigation, location });
+  }
+  close(reason = "manual") {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.closeInternal(reason);
+    return this.closePromise;
+  }
+  getPlugins() {
+    return this.instances.map(({ registration }) => ({
+      name: registration.name,
+      version: registration.version
+    }));
+  }
+  async startInternal() {
+    if (this.started || this.closed) return;
+    this.starting = true;
+    try {
+      for (const registration of this.registrations) {
+        try {
+          const definition = registration.definition;
+          if (!definition || typeof definition !== "object") {
+            throw new TypeError(
+              `Client plugin "${registration.name}" does not define a lifecycle object`
+            );
+          }
+          const instance = {
+            registration,
+            plugin: definition,
+            state: void 0
+          };
+          instance.state = await definition.setup?.(this.createSetupEvent(instance));
+          this.instances.push(instance);
+        } catch (error) {
+          this.logHookError(registration.name, "setup", error);
+          await this.runErrorHooks({
+            error,
+            phase: "setup",
+            location: this.getLocation()
+          });
+        }
+      }
+      this.started = true;
+      this.installBrowserListeners();
+      this.installPerformanceObservers();
+    } finally {
+      this.starting = false;
+    }
+  }
+  installBrowserListeners() {
+    const clientWindow = this.options.window;
+    if (!clientWindow) return;
+    if (this.instances.some(({ plugin }) => plugin.error)) {
+      clientWindow.addEventListener("error", this.handleWindowError);
+      clientWindow.addEventListener("unhandledrejection", this.handleUnhandledRejection);
+    }
+    clientWindow.addEventListener("pagehide", this.handlePageHide, {
+      once: true
+    });
+  }
+  installPerformanceObservers() {
+    if (!this.instances.some(({ plugin }) => plugin.performance)) return;
+    const Observer = typeof PerformanceObserver !== "undefined" ? PerformanceObserver : void 0;
+    if (!Observer) return;
+    const supported = new Set(Observer.supportedEntryTypes || []);
+    for (const type of PERFORMANCE_ENTRY_TYPES) {
+      if (!supported.has(type)) continue;
+      try {
+        const observer = new Observer((list) => {
+          for (const entry of list.getEntries()) {
+            void this.runHook(
+              "performance",
+              (instance) => instance.plugin.performance?.({
+                ...this.createStateEvent(instance),
+                entry,
+                location: this.getLocation()
+              })
+            );
+          }
+        });
+        observer.observe({ type, buffered: true });
+        this.performanceObservers.push(observer);
+      } catch (error) {
+        void this.reportError(error, "performance");
+      }
+    }
+  }
+  async closeInternal(reason) {
+    if (this.closed) return;
+    if (this.startPromise) await this.startPromise;
+    this.closed = true;
+    this.currentNavigation?.controller.abort(reason);
+    this.currentNavigation = void 0;
+    const clientWindow = this.options.window;
+    clientWindow?.removeEventListener("error", this.handleWindowError);
+    clientWindow?.removeEventListener("unhandledrejection", this.handleUnhandledRejection);
+    clientWindow?.removeEventListener("pagehide", this.handlePageHide);
+    for (const observer of this.performanceObservers) observer.disconnect();
+    this.performanceObservers.length = 0;
+    for (const instance of [...this.instances].reverse()) {
+      try {
+        await instance.plugin.close?.({
+          ...this.createStateEvent(instance),
+          reason
+        });
+      } catch (error) {
+        this.logHookError(instance.registration.name, "close", error);
+      }
+    }
+  }
+  async runHook(hook, invoke) {
+    for (const instance of this.instances) {
+      try {
+        await invoke(instance);
+      } catch (error) {
+        this.logHookError(instance.registration.name, hook, error);
+        await this.runErrorHooks(
+          {
+            error,
+            phase: `plugin:${hook}`,
+            location: this.getLocation()
+          },
+          instance
+        );
+      }
+    }
+  }
+  async runErrorHooks(event, excluded) {
+    for (const instance of this.instances) {
+      if (instance === excluded || !instance.plugin.error) continue;
+      try {
+        await instance.plugin.error({
+          ...this.createStateEvent(instance),
+          ...event
+        });
+      } catch (error) {
+        this.logHookError(instance.registration.name, "error", error);
+      }
+    }
+  }
+  createSetupEvent(instance) {
+    return {
+      plugin: {
+        name: instance.registration.name,
+        version: instance.registration.version
+      },
+      public: readonlyPublicData(instance.registration.public),
+      router: this.options.router,
+      isDev: Boolean(this.options.isDev),
+      isProd: Boolean(this.options.isProd),
+      deploymentId: this.options.deploymentId
+    };
+  }
+  createStateEvent(instance) {
+    return {
+      ...this.createSetupEvent(instance),
+      state: instance.state
+    };
+  }
+  getLocation() {
+    const href = this.options.window?.location.href ?? "http://localhost/";
+    return toClientLocation(href, href);
+  }
+  getBaseUrl() {
+    return this.options.window?.location.href ?? "http://localhost/";
+  }
+  logHookError(name, hook, error) {
+    console.error(`[Farm.js] Client plugin "${name}" failed in ${hook}:`, error);
+  }
+};
+__name(_FarmClientPluginManager, "FarmClientPluginManager");
+var FarmClientPluginManager = _FarmClientPluginManager;
+function createClientPluginManager(registrations, options) {
+  return new FarmClientPluginManager(registrations, options);
+}
+__name(createClientPluginManager, "createClientPluginManager");
+function sortRegistrations(registrations) {
+  const rank = /* @__PURE__ */ __name((enforce) => enforce === "pre" ? 0 : enforce === "post" ? 2 : 1, "rank");
+  return registrations.map((registration, index) => ({ registration, index })).sort(
+    (left, right) => rank(left.registration.enforce) - rank(right.registration.enforce) || left.index - right.index
+  ).map(({ registration }) => registration);
+}
+__name(sortRegistrations, "sortRegistrations");
+function toClientLocation(input, base) {
+  if (typeof input === "object" && "href" in input && "pathname" in input) {
+    return {
+      href: input.href,
+      pathname: input.pathname,
+      search: input.search,
+      hash: input.hash
+    };
+  }
+  const url = new URL(input, base);
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+__name(toClientLocation, "toClientLocation");
+function readonlyPublicData(value) {
+  if (value && typeof value === "object") {
+    return Object.freeze(value);
+  }
+  return value;
+}
+__name(readonlyPublicData, "readonlyPublicData");
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+__name(now, "now");
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+__name(isObject, "isObject");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FarmClientPluginManager,
+  IntegrationClientError,
+  Link,
+  SPARouter,
+  api,
+  createAPIClient,
+  createClientPluginManager,
+  createIntegrationApi,
+  createIntegrationClient,
+  createIntegrationClients,
+  createIntegrationServerClient,
+  createIntegrations,
+  createServerAPIClient,
+  createStore,
+  defineIntegrationAPI,
+  defineIntegrationAPIOperation,
+  endpoint,
+  fetchServerQuery,
+  getIntegrationAPIManifest,
+  getRouter,
+  installChunkErrorRecovery,
+  integrationClients,
+  integrationsClient,
+  integrationsServer,
+  isChunkLoadError,
+  navigateTo,
+  prefetch,
+  prefetchServerQuery,
+  pushState,
+  readPageState,
+  replaceState,
+  useBlocker,
+  useNavigation,
+  usePageState,
+  useRouter,
+  useScrollRestoration,
+  useServerQuery
+});
+//# sourceMappingURL=client.cjs.map