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

package/dist/chunk-MKYBIIAQ.mjs

@@ -0,0 +1,2187 @@
+import {
+  defineSchema
+} from "./chunk-44SYJEG3.mjs";
+import {
+  compileMiddlewareConfig,
+  matchesCompiledMiddlewareConfig
+} from "./chunk-JG6DJF5A.mjs";
+import {
+  bufferFarmRequestBody,
+  clearRequestContext,
+  createFarmRequestBodyErrorResponse,
+  deleteRequestContext,
+  getRequestContext,
+  getRequestContextSnapshot,
+  hasRequestContext,
+  readNodeRequestBody,
+  resolveFarmServerConfig,
+  setRequestContext
+} from "./chunk-ZMMBIVQM.mjs";
+import {
+  applyWebResponseHeaders,
+  sendWebResponse
+} from "./chunk-Z2RZJZIZ.mjs";
+import {
+  createFarmAPIMiddlewarePathnames,
+  resolveFarmAPIServerBasePath
+} from "./chunk-BTHHUD7Q.mjs";
+import {
+  api,
+  defineIntegrationAPIOperation
+} from "./chunk-JPLUGGRV.mjs";
+import {
+  validateConfigRouteSource
+} from "./chunk-SAXPH6G5.mjs";
+import {
+  canonicalizeRequestPathSegments,
+  canonicalizeRequestPathname
+} from "./chunk-CQ6OSQ3K.mjs";
+import {
+  resolveFarmLocalePath
+} from "./chunk-L3KT7IXV.mjs";
+import {
+  stripFarmBasePath
+} from "./chunk-4RB44K6Z.mjs";
+import {
+  assertTerminalCatchAll,
+  assertUniqueRouteParameters,
+  compareRouteSpecificity,
+  getRoutePatternSpecificity
+} from "./chunk-55YI3RRB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/plugin-integration-context.ts
+var FARM_PLUGIN_INTEGRATION_CONTEXT = /* @__PURE__ */ Symbol.for("@farm.js/core/plugin-integration-context");
+function setFarmPluginIntegrationContext(plugin, integration) {
+  Object.defineProperty(plugin, FARM_PLUGIN_INTEGRATION_CONTEXT, {
+    value: integration
+  });
+}
+__name(setFarmPluginIntegrationContext, "setFarmPluginIntegrationContext");
+function getFarmPluginIntegrationContext(plugin) {
+  const value = plugin[FARM_PLUGIN_INTEGRATION_CONTEXT];
+  return value && typeof value === "object" ? value : void 0;
+}
+__name(getFarmPluginIntegrationContext, "getFarmPluginIntegrationContext");
+
+// src/integrations.ts
+var FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
+var FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
+function forwardIntegrationSetCookies(context, cookies) {
+  if (cookies.length === 0) return;
+  const existing = context.req.get(FARM_INTEGRATION_SET_COOKIES_KEY) ?? [];
+  context.req.set(FARM_INTEGRATION_SET_COOKIES_KEY, [...existing, ...cookies]);
+}
+__name(forwardIntegrationSetCookies, "forwardIntegrationSetCookies");
+function takeForwardedIntegrationSetCookies(context) {
+  const cookies = context.req.get(FARM_INTEGRATION_SET_COOKIES_KEY);
+  if (cookies && cookies.length > 0) {
+    context.req.delete(FARM_INTEGRATION_SET_COOKIES_KEY);
+    return cookies;
+  }
+  if (cookies) {
+    context.req.delete(FARM_INTEGRATION_SET_COOKIES_KEY);
+  }
+  return [];
+}
+__name(takeForwardedIntegrationSetCookies, "takeForwardedIntegrationSetCookies");
+function appendIntegrationForwardedCookies(response, cookies) {
+  if (cookies.length === 0) return response;
+  const headers = new Headers(response.headers);
+  for (const cookie of cookies) {
+    headers.append("set-cookie", cookie);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+__name(appendIntegrationForwardedCookies, "appendIntegrationForwardedCookies");
+var defineIntegrationSchema = defineSchema;
+var FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME = /* @__PURE__ */ Symbol.for(
+  "@farm.js/core/integration-plugin-server-runtime"
+);
+var FARM_INTEGRATION_PLUGIN_OWNER = /* @__PURE__ */ Symbol.for("@farm.js/core/integration-plugin-owner");
+function getFarmIntegrationPluginServerRuntime(plugin) {
+  const value = plugin[FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME];
+  return typeof value === "boolean" ? value : void 0;
+}
+__name(getFarmIntegrationPluginServerRuntime, "getFarmIntegrationPluginServerRuntime");
+function getFarmIntegrationPluginOwner(plugin) {
+  const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
+  return value && typeof value === "object" ? value : void 0;
+}
+__name(getFarmIntegrationPluginOwner, "getFarmIntegrationPluginOwner");
+function defineTypedIntegrationRoute(method, path, input) {
+  return {
+    path,
+    method,
+    middleware: input.middleware,
+    before: input.before,
+    after: input.after,
+    rawBody: input.rawBody,
+    bodyFormat: input.bodyFormat,
+    input: normalizeIntegrationRouteInputSchemas(input),
+    handler: input.handler,
+    __operation: defineIntegrationAPIOperation({
+      path,
+      method,
+      bodyFormat: input.bodyFormat,
+      responseFormat: input.responseFormat,
+      headers: input.headers,
+      credentials: input.credentials,
+      isServer: input.isServer
+    })
+  };
+}
+__name(defineTypedIntegrationRoute, "defineTypedIntegrationRoute");
+function createIntegrationRouteFactory() {
+  return {
+    get(path, input) {
+      return defineTypedIntegrationRoute(
+        "GET",
+        path,
+        input
+      );
+    },
+    post(path, input) {
+      return defineTypedIntegrationRoute(
+        "POST",
+        path,
+        {
+          bodyFormat: "json",
+          ...input
+        }
+      );
+    },
+    query(path, input) {
+      return defineTypedIntegrationRoute("QUERY", path, {
+        bodyFormat: "json",
+        ...input
+      });
+    },
+    put(path, input) {
+      return defineTypedIntegrationRoute(
+        "PUT",
+        path,
+        {
+          bodyFormat: "json",
+          ...input
+        }
+      );
+    },
+    patch(path, input) {
+      return defineTypedIntegrationRoute("PATCH", path, {
+        bodyFormat: "json",
+        ...input
+      });
+    },
+    delete(path, input) {
+      return defineTypedIntegrationRoute("DELETE", path, {
+        bodyFormat: "json",
+        ...input
+      });
+    },
+    options(path, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path, input);
+    },
+    head(path, input) {
+      return defineTypedIntegrationRoute(
+        "HEAD",
+        path,
+        input
+      );
+    }
+  };
+}
+__name(createIntegrationRouteFactory, "createIntegrationRouteFactory");
+function createIntegrationRoute(_schema) {
+  return createIntegrationRouteFactory();
+}
+__name(createIntegrationRoute, "createIntegrationRoute");
+var integrationRoute = createIntegrationRouteFactory();
+var INTEGRATION_RUNTIME_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRuntimeRegistry");
+var INTEGRATION_REQUEST_DISPATCHER_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRequestDispatcher");
+function getIntegrationRuntimeRegistry() {
+  const globalState = globalThis;
+  if (!globalState[INTEGRATION_RUNTIME_REGISTRY_KEY]) {
+    globalState[INTEGRATION_RUNTIME_REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  }
+  return globalState[INTEGRATION_RUNTIME_REGISTRY_KEY];
+}
+__name(getIntegrationRuntimeRegistry, "getIntegrationRuntimeRegistry");
+function isIntegrationEndpointRoute(value) {
+  return !!value && typeof value === "object" && typeof value.path === "string" && typeof value.handler === "function";
+}
+__name(isIntegrationEndpointRoute, "isIntegrationEndpointRoute");
+function flattenIntegrationEndpoints(endpoints) {
+  if (!endpoints) {
+    return [];
+  }
+  if (Array.isArray(endpoints)) {
+    return endpoints.flatMap((endpoint) => flattenIntegrationEndpoints(endpoint));
+  }
+  if (isIntegrationEndpointRoute(endpoints)) {
+    return [endpoints];
+  }
+  if (typeof endpoints === "object") {
+    return Object.values(endpoints).flatMap((endpoint) => flattenIntegrationEndpoints(endpoint));
+  }
+  return [];
+}
+__name(flattenIntegrationEndpoints, "flattenIntegrationEndpoints");
+function defineIntegration(integration) {
+  const category = integration.category ?? integration.slot;
+  if (!category) {
+    throw new Error("Integration category is required.");
+  }
+  if (integration.category && integration.slot && integration.category !== integration.slot) {
+    throw new Error("Integration category and slot must match when both are provided.");
+  }
+  const routeFactory = createIntegrationRoute(integration.schema);
+  const routes = typeof integration.routes === "function" ? integration.routes({
+    route: routeFactory,
+    integrationRoute: routeFactory
+  }) : integration.routes;
+  const endpoints = typeof integration.endpoints === "function" ? integration.endpoints({
+    endpoint: routeFactory,
+    route: routeFactory,
+    integrationRoute: routeFactory
+  }) : integration.endpoints;
+  const endpointRoutes = flattenIntegrationEndpoints(endpoints);
+  const allRoutes = routes?.length || endpointRoutes.length ? [...routes || [], ...endpointRoutes] : void 0;
+  for (const route of allRoutes || []) {
+    assertUniqueRouteParameters(route.path, "api");
+    validateConfigRouteSource(route.path, `Integration route "${route.path}"`);
+    assertTerminalCatchAll(route.path, "api");
+  }
+  const derivedApi = integration.api || (allRoutes?.length ? api.fromRoutes(
+    allRoutes
+  ) : void 0);
+  return {
+    kind: "farm-integration",
+    ...integration,
+    endpoints,
+    routes: allRoutes,
+    api: derivedApi,
+    category,
+    slot: category
+  };
+}
+__name(defineIntegration, "defineIntegration");
+function isFarmIntegration(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-integration";
+}
+__name(isFarmIntegration, "isFarmIntegration");
+function resolveIntegrationPlugins(integrations) {
+  if (!integrations) {
+    return [];
+  }
+  const plugins = [];
+  for (const [key, integration] of Object.entries(integrations)) {
+    if (!integration || !isFarmIntegration(integration)) {
+      continue;
+    }
+    const owner = createIntegrationPluginOwner(key, integration, "lifecycle");
+    plugins.push(withIntegrationPluginOwner(createIntegrationPlugin(key, integration), owner));
+    plugins.push(...resolveIntegrationPluginContributions(key, integration));
+  }
+  return plugins;
+}
+__name(resolveIntegrationPlugins, "resolveIntegrationPlugins");
+function resolveIntegrationPluginContributions(key, integration) {
+  const contributions = integration.plugins;
+  if (!contributions) return [];
+  if (!Array.isArray(contributions)) {
+    throw new TypeError(`Integration "${key}" plugins must be an array`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  return contributions.map((plugin, index) => {
+    if (!plugin || typeof plugin !== "object" || typeof plugin.name !== "string") {
+      throw new TypeError(`Integration "${key}" plugin at index ${index} is invalid`);
+    }
+    const name = plugin.name.trim();
+    if (!name) {
+      throw new TypeError(`Integration "${key}" plugin at index ${index} requires a name`);
+    }
+    if (names.has(name)) {
+      throw new Error(`Integration "${key}" contributes duplicate plugin name "${name}"`);
+    }
+    names.add(name);
+    return withIntegrationPluginOwner(
+      plugin,
+      createIntegrationPluginOwner(key, integration, "contribution"),
+      createIntegrationPluginContext(key, integration)
+    );
+  });
+}
+__name(resolveIntegrationPluginContributions, "resolveIntegrationPluginContributions");
+function createIntegrationPluginOwner(key, integration, source) {
+  return Object.freeze({
+    key,
+    category: integration.category,
+    type: integration.type,
+    source,
+    serverRuntime: integration.serverRuntime !== false
+  });
+}
+__name(createIntegrationPluginOwner, "createIntegrationPluginOwner");
+function createIntegrationPluginContext(key, integration) {
+  return Object.freeze({
+    key,
+    category: integration.category,
+    type: integration.type,
+    instance: integration.instance,
+    serverRuntime: integration.serverRuntime !== false
+  });
+}
+__name(createIntegrationPluginContext, "createIntegrationPluginContext");
+function withIntegrationPluginOwner(plugin, owner, integration) {
+  const descriptors = Object.getOwnPropertyDescriptors(plugin);
+  Reflect.deleteProperty(descriptors, FARM_INTEGRATION_PLUGIN_OWNER);
+  Reflect.deleteProperty(descriptors, FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME);
+  const ownedPlugin = Object.create(Object.getPrototypeOf(plugin), descriptors);
+  Object.defineProperty(ownedPlugin, FARM_INTEGRATION_PLUGIN_OWNER, { value: owner });
+  Object.defineProperty(ownedPlugin, FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME, {
+    value: owner.serverRuntime
+  });
+  if (integration) {
+    setFarmPluginIntegrationContext(ownedPlugin, integration);
+  }
+  return ownedPlugin;
+}
+__name(withIntegrationPluginOwner, "withIntegrationPluginOwner");
+function getIntegrationProviders(integrations) {
+  if (!integrations) {
+    return [];
+  }
+  const providers = [];
+  for (const integration of Object.values(integrations)) {
+    if (!integration || !isFarmIntegration(integration) || !integration.providers?.length) {
+      continue;
+    }
+    for (const provider of integration.providers) {
+      providers.push({
+        name: provider.name,
+        type: provider.type,
+        props: provider.props,
+        supportsIsolatedHydration: provider.supportsIsolatedHydration,
+        component: provider.component
+      });
+    }
+  }
+  return providers;
+}
+__name(getIntegrationProviders, "getIntegrationProviders");
+function isFarmIntegrationProviderComponentReference(value) {
+  return Boolean(
+    value && typeof value === "object" && "module" in value && typeof value.module === "string" && value.module.length > 0
+  );
+}
+__name(isFarmIntegrationProviderComponentReference, "isFarmIntegrationProviderComponentReference");
+function getIntegrationDocumentNavigationMatchers(integrations) {
+  if (!integrations) {
+    return [];
+  }
+  const matchers = [];
+  for (const integration of Object.values(integrations)) {
+    if (!integration || !isFarmIntegration(integration) || !integration.documentNavigations?.length) {
+      continue;
+    }
+    for (const navigation of integration.documentNavigations) {
+      const items = Array.isArray(navigation.matcher) ? navigation.matcher : [navigation.matcher];
+      for (const item of items) {
+        matchers.push(item);
+      }
+    }
+  }
+  return matchers;
+}
+__name(getIntegrationDocumentNavigationMatchers, "getIntegrationDocumentNavigationMatchers");
+function getIntegrationSchemas(integrations) {
+  if (!integrations) {
+    return {};
+  }
+  const schemaEntries = Object.entries(integrations).map(([key, integration]) => {
+    const schema = integration && isFarmIntegration(integration) ? integration.schema : void 0;
+    return schema ? [key, schema] : null;
+  }).filter((value) => value !== null);
+  return Object.fromEntries(schemaEntries);
+}
+__name(getIntegrationSchemas, "getIntegrationSchemas");
+function getRegisteredIntegrationRuntime(key) {
+  return getIntegrationRuntimeRegistry().get(key);
+}
+__name(getRegisteredIntegrationRuntime, "getRegisteredIntegrationRuntime");
+function getRegisteredIntegrations() {
+  return Object.fromEntries(
+    Array.from(getIntegrationRuntimeRegistry().entries()).map(([key, runtime]) => [
+      key,
+      runtime.integration
+    ])
+  );
+}
+__name(getRegisteredIntegrations, "getRegisteredIntegrations");
+function getRegisteredIntegrationSchemas() {
+  return getIntegrationSchemas(getRegisteredIntegrations());
+}
+__name(getRegisteredIntegrationSchemas, "getRegisteredIntegrationSchemas");
+function matchIntegrationRoute(integrations, input) {
+  if (!integrations) {
+    return null;
+  }
+  const method = normalizeIntegrationRequestMethod(input.method);
+  if (!method) {
+    return null;
+  }
+  const pathSegments = canonicalizeRequestPathSegments(input.pathname);
+  for (const [key, integration] of Object.entries(integrations)) {
+    if (!integration || !isFarmIntegration(integration)) {
+      continue;
+    }
+    const routes = normalizeIntegrationRoutes(integration.routes || []);
+    for (const route of routes) {
+      if (!matchesMethod(route.methods, method)) {
+        continue;
+      }
+      const params = matchPathSegments(route[INTEGRATION_ROUTE_SEGMENTS], pathSegments);
+      if (!params) {
+        continue;
+      }
+      return {
+        key,
+        integration,
+        route: {
+          path: route.path,
+          methods: route.methods
+        },
+        params
+      };
+    }
+  }
+  return null;
+}
+__name(matchIntegrationRoute, "matchIntegrationRoute");
+function matchRegisteredIntegrationRoute(input) {
+  return matchIntegrationRoute(getRegisteredIntegrations(), input);
+}
+__name(matchRegisteredIntegrationRoute, "matchRegisteredIntegrationRoute");
+function createClientSafeIntegrationAPI(api2) {
+  if (!api2) {
+    return void 0;
+  }
+  const entries = Object.entries(api2).map(([key, value]) => {
+    if (value && typeof value === "object" && value.kind === "farm-integration-api-operation") {
+      const operation = value;
+      return [
+        key,
+        defineIntegrationAPIOperation({
+          path: operation.path,
+          method: operation.method,
+          bodyFormat: operation.bodyFormat,
+          responseFormat: operation.responseFormat,
+          credentials: operation.credentials,
+          isServer: operation.isServer
+        })
+      ];
+    }
+    if (value && typeof value === "object") {
+      return [key, createClientSafeIntegrationAPI(value)];
+    }
+    return [key, value];
+  });
+  return Object.fromEntries(entries);
+}
+__name(createClientSafeIntegrationAPI, "createClientSafeIntegrationAPI");
+function getRegisteredIntegrationAPIManifest() {
+  const manifestEntries = Object.entries(getRegisteredIntegrations()).map(([key, integration]) => {
+    const api2 = createClientSafeIntegrationAPI(integration.api);
+    return api2 ? [key, api2] : null;
+  }).filter((value) => value !== null);
+  return Object.fromEntries(manifestEntries);
+}
+__name(getRegisteredIntegrationAPIManifest, "getRegisteredIntegrationAPIManifest");
+function getIntegrationRuntimeEnv() {
+  return typeof process !== "undefined" ? process.env : {};
+}
+__name(getIntegrationRuntimeEnv, "getIntegrationRuntimeEnv");
+function isIntegrationConfigDefinition(value) {
+  return !!value && typeof value === "object" && ("schema" in value || "env" in value || "defaults" in value || "input" in value || "resolve" in value);
+}
+__name(isIntegrationConfigDefinition, "isIntegrationConfigDefinition");
+function mergeIntegrationConfigValue(current, next) {
+  if (next === void 0) {
+    return current;
+  }
+  if (isPlainIntegrationConfigObject(current) && isPlainIntegrationConfigObject(next)) {
+    return {
+      ...current,
+      ...next
+    };
+  }
+  return next;
+}
+__name(mergeIntegrationConfigValue, "mergeIntegrationConfigValue");
+function isPlainIntegrationConfigObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainIntegrationConfigObject, "isPlainIntegrationConfigObject");
+async function resolveIntegrationConfigPart(value, context) {
+  if (typeof value === "function") {
+    return value(context);
+  }
+  return value;
+}
+__name(resolveIntegrationConfigPart, "resolveIntegrationConfigPart");
+function resolveIntegrationEnvConfig(env) {
+  if (!env) {
+    return void 0;
+  }
+  const runtimeEnv = getIntegrationRuntimeEnv();
+  const config = {};
+  for (const [key, names] of Object.entries(env)) {
+    const envNames = Array.isArray(names) ? names : [names];
+    const value = envNames.map((name) => runtimeEnv[name]).find((entry) => entry !== void 0);
+    if (value !== void 0) {
+      config[key] = value;
+    }
+  }
+  return config;
+}
+__name(resolveIntegrationEnvConfig, "resolveIntegrationEnvConfig");
+async function parseIntegrationConfigSchema(integration, schema, value) {
+  const parser = schema.safeParseAsync || schema.safeParse;
+  if (parser) {
+    const result = await parser.call(schema, value);
+    if (result.success) {
+      return result.data;
+    }
+    throw createIntegrationConfigValidationError(integration, result.error);
+  }
+  if (schema["~standard"]?.validate) {
+    const result = await schema["~standard"].validate(value);
+    if ("value" in result) {
+      return result.value;
+    }
+    throw createIntegrationConfigValidationError(integration, {
+      issues: result.issues
+    });
+  }
+  if (schema.parse) {
+    try {
+      return await schema.parse(value);
+    } catch (error) {
+      throw createIntegrationConfigValidationError(
+        integration,
+        normalizeIntegrationValidationError(error)
+      );
+    }
+  }
+  throw new Error(
+    `Integration "${integration.type}" config schema must expose safeParse, safeParseAsync, parse, or ~standard.validate.`
+  );
+}
+__name(parseIntegrationConfigSchema, "parseIntegrationConfigSchema");
+function createIntegrationConfigValidationError(integration, error) {
+  const issues = Array.isArray(error.issues) && error.issues.length > 0 ? error.issues.map((issue) => {
+    const normalizedPath = normalizeIntegrationValidationPath(issue.path);
+    const path = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path}${issue.message || "Invalid config"}`;
+  }).join("; ") : error.message || "Invalid config";
+  return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
+}
+__name(createIntegrationConfigValidationError, "createIntegrationConfigValidationError");
+async function resolveIntegrationConfig(integration, context) {
+  const config = integration.config;
+  if (!config) {
+    return void 0;
+  }
+  if (!isIntegrationConfigDefinition(config)) {
+    return parseIntegrationConfigSchema(integration, config, {});
+  }
+  let value = {};
+  value = mergeIntegrationConfigValue(
+    value,
+    await resolveIntegrationConfigPart(config.defaults, context)
+  );
+  value = mergeIntegrationConfigValue(value, resolveIntegrationEnvConfig(config.env));
+  value = mergeIntegrationConfigValue(
+    value,
+    await resolveIntegrationConfigPart(config.input, context)
+  );
+  value = mergeIntegrationConfigValue(value, await config.resolve?.(context));
+  return config.schema ? parseIntegrationConfigSchema(integration, config.schema, value) : value;
+}
+__name(resolveIntegrationConfig, "resolveIntegrationConfig");
+function createIntegrationLifecycleLogger(integration, phase) {
+  const write = /* @__PURE__ */ __name((level, message, meta) => {
+    if (!integration.log) {
+      return;
+    }
+    void Promise.resolve(
+      integration.log({
+        category: integration.category,
+        slot: integration.category,
+        type: integration.type,
+        phase,
+        level,
+        message,
+        meta,
+        context: /* @__PURE__ */ new Map()
+      })
+    ).catch(() => {
+    });
+  }, "write");
+  return {
+    info(message, meta) {
+      write("info", message, meta);
+    },
+    warn(message, meta) {
+      write("warn", message, meta);
+    },
+    error(message, meta) {
+      write("error", message, meta);
+    }
+  };
+}
+__name(createIntegrationLifecycleLogger, "createIntegrationLifecycleLogger");
+async function emitIntegrationLog(integration, event) {
+  try {
+    await integration.log?.(event);
+  } catch {
+  }
+}
+__name(emitIntegrationLog, "emitIntegrationLog");
+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 isFarmIntegrationData(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+__name(isFarmIntegrationData, "isFarmIntegrationData");
+function isPlainIntegrationDataObject(value) {
+  if (!isFarmIntegrationData(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainIntegrationDataObject, "isPlainIntegrationDataObject");
+function sanitizeIntegrationDataValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeIntegrationDataValue(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] = sanitizeIntegrationDataValue(item);
+  }
+  return sanitized;
+}
+__name(sanitizeIntegrationDataValue, "sanitizeIntegrationDataValue");
+function normalizeIntegrationData(value) {
+  if (!isFarmIntegrationData(value)) {
+    return {};
+  }
+  const sanitized = sanitizeIntegrationDataValue(value);
+  return isFarmIntegrationData(sanitized) ? sanitized : {};
+}
+__name(normalizeIntegrationData, "normalizeIntegrationData");
+function getIntegrationDataHeaderByteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+__name(getIntegrationDataHeaderByteLength, "getIntegrationDataHeaderByteLength");
+function parseIntegrationDataHeader(request) {
+  const raw = request.headers.get(INTEGRATION_DATA_HEADER);
+  if (!raw) {
+    return {};
+  }
+  if (getIntegrationDataHeaderByteLength(raw) > INTEGRATION_DATA_HEADER_MAX_LENGTH) {
+    return {};
+  }
+  try {
+    const value = JSON.parse(raw);
+    return normalizeIntegrationData(value);
+  } catch {
+    return {};
+  }
+}
+__name(parseIntegrationDataHeader, "parseIntegrationDataHeader");
+function resolveIntegrationData(request, data) {
+  return {
+    ...parseIntegrationDataHeader(request),
+    ...normalizeIntegrationData(data)
+  };
+}
+__name(resolveIntegrationData, "resolveIntegrationData");
+function createIntegrationPlugin(integrationKey, integration) {
+  const routes = normalizeIntegrationRoutes(integration.routes || []);
+  const middleware = [...integration.middleware || []];
+  const cleanupCallbacks = [];
+  let integrationConfigPromise;
+  const runCleanup = /* @__PURE__ */ __name(async () => {
+    const callbacks = cleanupCallbacks.splice(0).reverse();
+    for (const callback of callbacks) {
+      await callback();
+    }
+  }, "runCleanup");
+  const createLifecycleContext = /* @__PURE__ */ __name(async (context, phase, options = {}) => {
+    const args = createIntegrationRouteArgs({
+      integration,
+      config: context.config
+    });
+    const configContext = {
+      key: integrationKey,
+      integration,
+      appConfig: context.config,
+      config: context.config,
+      args,
+      env: getIntegrationRuntimeEnv(),
+      isDev: context.isDev,
+      isProd: context.isProd
+    };
+    integrationConfigPromise ?? (integrationConfigPromise = resolveIntegrationConfig(integration, configContext));
+    return {
+      ...configContext,
+      integrationConfig: await integrationConfigPromise,
+      log: createIntegrationLifecycleLogger(integration, phase),
+      reason: options.reason,
+      async cleanup(callback) {
+        if (callback) {
+          cleanupCallbacks.push(callback);
+          return;
+        }
+        await runCleanup();
+      }
+    };
+  }, "createLifecycleContext");
+  const plugin = {
+    name: `farm:integration:${integration.category}:${integration.type}`,
+    enforce: "pre",
+    async init(context) {
+      getIntegrationRuntimeRegistry().set(integrationKey, {
+        integration,
+        config: context.config,
+        isDev: context.isDev,
+        isProd: context.isProd
+      });
+      await createLifecycleContext(context, "validate");
+      if (integration.validate) {
+        await integration.validate(await createLifecycleContext(context, "validate"));
+      }
+      if (integration.setup) {
+        await integration.setup(await createLifecycleContext(context, "setup"));
+      }
+      if (!integration.log) {
+        return;
+      }
+      for (const route of routes) {
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "registered",
+          route: {
+            kind: "route",
+            path: route.path,
+            methods: route.methods
+          },
+          context: /* @__PURE__ */ new Map()
+        });
+      }
+      for (const entry of middleware) {
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "registered",
+          route: {
+            kind: "middleware",
+            path: normalizeMatcher(entry.matcher),
+            methods: ["ALL"]
+          },
+          context: /* @__PURE__ */ new Map()
+        });
+      }
+    },
+    async ready(context) {
+      if (integration.ready) {
+        await integration.ready(await createLifecycleContext(context, "ready"));
+      }
+    },
+    async shutdown(payload, context) {
+      try {
+        if (integration.dispose) {
+          await integration.dispose(
+            await createLifecycleContext(context, "dispose", {
+              reason: payload.reason
+            })
+          );
+        }
+      } finally {
+        await runCleanup();
+      }
+    },
+    async beforeRequest(req, res, context) {
+      const fullUrl = `http://${req.headers.host || "localhost"}${req.url || "/"}`;
+      const url = new URL(fullUrl);
+      const pathname = url.pathname;
+      const pathSegments = canonicalizeRequestPathSegments(pathname);
+      const method = normalizeIntegrationRequestMethod(req.method);
+      const requestId = getRequestId(req);
+      let bodyLoaded = false;
+      let requestBody;
+      const getRequestBody = /* @__PURE__ */ __name(async () => {
+        if (!bodyLoaded) {
+          bodyLoaded = true;
+          if (req.method && req.method !== "GET" && req.method !== "HEAD") {
+            requestBody = await readNodeRequestBody(
+              req,
+              resolveFarmServerConfig(context.config.server).bodySizeLimit
+            );
+          }
+        }
+        return requestBody;
+      }, "getRequestBody");
+      const createHandlerRequest = /* @__PURE__ */ __name(async () => {
+        try {
+          return createWebRequest(req, fullUrl, await getRequestBody());
+        } catch (error) {
+          const response = createFarmRequestBodyErrorResponse(error);
+          if (!response) throw error;
+          await sendWebResponse(res, response);
+          return null;
+        }
+      }, "createHandlerRequest");
+      for (const entry of middleware) {
+        const params = resolveIntegrationMiddlewareParams(entry, pathname, context.config);
+        if (!params) {
+          continue;
+        }
+        const request = await createHandlerRequest();
+        if (!request) return;
+        const handlerContext = createIntegrationHandlerContext({
+          integration,
+          route: {
+            kind: "middleware",
+            path: normalizeMatcher(entry.matcher),
+            methods: ["ALL"]
+          },
+          request,
+          rawRequest: req,
+          params,
+          pathname,
+          requestId,
+          pluginContext: context
+        });
+        const startedAt = Date.now();
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "request:start",
+          route: {
+            kind: "middleware",
+            path: normalizeMatcher(entry.matcher),
+            methods: ["ALL"]
+          },
+          request,
+          requestId,
+          context: handlerContext.req.snapshot()
+        });
+        try {
+          const response = await entry.handler(request, handlerContext);
+          const forwardedCookies = takeForwardedIntegrationSetCookies(handlerContext);
+          if (forwardedCookies.length > 0) {
+            const setCookieHeaders = new Headers();
+            for (const cookie of forwardedCookies) {
+              setCookieHeaders.append("set-cookie", cookie);
+            }
+            applyWebResponseHeaders(res, setCookieHeaders, { appendSetCookie: true });
+          }
+          if (response) {
+            await sendWebResponse(res, response);
+            await emitIntegrationLog(integration, {
+              category: integration.category,
+              slot: integration.category,
+              type: integration.type,
+              phase: "request:end",
+              route: {
+                kind: "middleware",
+                path: normalizeMatcher(entry.matcher),
+                methods: ["ALL"]
+              },
+              request,
+              response,
+              requestId,
+              durationMs: Date.now() - startedAt,
+              context: handlerContext.req.snapshot()
+            });
+            return;
+          }
+          await emitIntegrationLog(integration, {
+            category: integration.category,
+            slot: integration.category,
+            type: integration.type,
+            phase: "request:end",
+            route: {
+              kind: "middleware",
+              path: normalizeMatcher(entry.matcher),
+              methods: ["ALL"]
+            },
+            request,
+            requestId,
+            durationMs: Date.now() - startedAt,
+            context: handlerContext.req.snapshot()
+          });
+        } catch (error) {
+          await emitIntegrationLog(integration, {
+            category: integration.category,
+            slot: integration.category,
+            type: integration.type,
+            phase: "request:error",
+            route: {
+              kind: "middleware",
+              path: normalizeMatcher(entry.matcher),
+              methods: ["ALL"]
+            },
+            request,
+            requestId,
+            durationMs: Date.now() - startedAt,
+            error,
+            context: handlerContext.req.snapshot()
+          });
+          throw error;
+        }
+      }
+      for (const route of routes) {
+        const params = method && matchesMethod(route.methods, method) ? matchPathSegments(route[INTEGRATION_ROUTE_SEGMENTS], pathSegments) : null;
+        if (!params) {
+          continue;
+        }
+        const request = await createHandlerRequest();
+        if (!request) return;
+        const handlerContext = createIntegrationHandlerContext({
+          integration,
+          route: {
+            kind: "route",
+            path: route.path,
+            methods: route.methods
+          },
+          request,
+          rawRequest: req,
+          params,
+          pathname,
+          requestId,
+          pluginContext: context
+        });
+        const startedAt = Date.now();
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "request:start",
+          route: {
+            kind: "route",
+            path: route.path,
+            methods: route.methods
+          },
+          request,
+          requestId,
+          context: handlerContext.req.snapshot()
+        });
+        try {
+          const validation = await validateIntegrationRouteInput(route, request, url);
+          if (!validation.success) {
+            await sendWebResponse(res, validation.response);
+            await emitIntegrationLog(integration, {
+              category: integration.category,
+              slot: integration.category,
+              type: integration.type,
+              phase: "request:end",
+              route: {
+                kind: "route",
+                path: route.path,
+                methods: route.methods
+              },
+              request,
+              response: validation.response,
+              requestId,
+              durationMs: Date.now() - startedAt,
+              context: handlerContext.req.snapshot()
+            });
+            return;
+          }
+          handlerContext.input = validation.input;
+          for (const middlewareEntry of route.middleware || []) {
+            const middlewareResponse = await middlewareEntry.handler(request, handlerContext);
+            if (middlewareResponse) {
+              await sendWebResponse(res, middlewareResponse);
+              await emitIntegrationLog(integration, {
+                category: integration.category,
+                slot: integration.category,
+                type: integration.type,
+                phase: "request:end",
+                route: {
+                  kind: "route",
+                  path: route.path,
+                  methods: route.methods
+                },
+                request,
+                response: middlewareResponse,
+                requestId,
+                durationMs: Date.now() - startedAt,
+                context: handlerContext.req.snapshot()
+              });
+              return;
+            }
+          }
+          const beforeResponse = await runIntegrationRouteBeforeHooks(
+            route,
+            request,
+            handlerContext
+          );
+          if (beforeResponse) {
+            const response2 = await runIntegrationRouteAfterHooks(
+              route,
+              request,
+              handlerContext,
+              beforeResponse
+            );
+            await sendWebResponse(res, response2);
+            await emitIntegrationLog(integration, {
+              category: integration.category,
+              slot: integration.category,
+              type: integration.type,
+              phase: "request:end",
+              route: {
+                kind: "route",
+                path: route.path,
+                methods: route.methods
+              },
+              request,
+              response: response2,
+              requestId,
+              durationMs: Date.now() - startedAt,
+              context: handlerContext.req.snapshot()
+            });
+            return;
+          }
+          const handlerResponse = await route.handler(request, handlerContext);
+          const response = await runIntegrationRouteAfterHooks(
+            route,
+            request,
+            handlerContext,
+            handlerResponse
+          );
+          await sendWebResponse(res, response);
+          await emitIntegrationLog(integration, {
+            category: integration.category,
+            slot: integration.category,
+            type: integration.type,
+            phase: "request:end",
+            route: {
+              kind: "route",
+              path: route.path,
+              methods: route.methods
+            },
+            request,
+            response,
+            requestId,
+            durationMs: Date.now() - startedAt,
+            context: handlerContext.req.snapshot()
+          });
+          return;
+        } catch (error) {
+          await emitIntegrationLog(integration, {
+            category: integration.category,
+            slot: integration.category,
+            type: integration.type,
+            phase: "request:error",
+            route: {
+              kind: "route",
+              path: route.path,
+              methods: route.methods
+            },
+            request,
+            requestId,
+            durationMs: Date.now() - startedAt,
+            error,
+            context: handlerContext.req.snapshot()
+          });
+          throw error;
+        }
+      }
+    }
+  };
+  Object.defineProperty(plugin, FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME, {
+    value: integration.serverRuntime !== false
+  });
+  return plugin;
+}
+__name(createIntegrationPlugin, "createIntegrationPlugin");
+function createIntegrationHandlerContext(input) {
+  const req = createIntegrationRequestContextStore(
+    input.rawRequest,
+    input.request,
+    input.pluginContext
+  );
+  return {
+    request: input.request,
+    requestId: input.requestId,
+    url: new URL(input.request.url),
+    pathname: input.pathname,
+    method: input.request.method,
+    params: input.params,
+    input: {},
+    args: createIntegrationRouteArgs({
+      integration: input.integration,
+      config: input.pluginContext.config
+    }),
+    data: resolveIntegrationData(input.request),
+    integration: {
+      category: input.integration.category,
+      slot: input.integration.category,
+      type: input.integration.type,
+      instance: input.integration.instance
+    },
+    route: input.route,
+    req,
+    requestContext: req,
+    config: input.pluginContext.config,
+    isDev: input.pluginContext.isDev,
+    isProd: input.pluginContext.isProd
+  };
+}
+__name(createIntegrationHandlerContext, "createIntegrationHandlerContext");
+var INTEGRATION_ROUTE_SEGMENTS = /* @__PURE__ */ Symbol("farm.integrationRouteSegments");
+var EMPTY_NORMALIZED_INTEGRATION_ROUTES = [];
+var normalizedIntegrationRoutesCache = /* @__PURE__ */ new WeakMap();
+function normalizeIntegrationRoutes(routes) {
+  if (routes.length === 0) {
+    return EMPTY_NORMALIZED_INTEGRATION_ROUTES;
+  }
+  const cached = normalizedIntegrationRoutesCache.get(routes);
+  if (cached) {
+    return cached;
+  }
+  const normalized = routes.map((route, index) => {
+    assertUniqueRouteParameters(route.path, "api");
+    return {
+      index,
+      route: {
+        ...route,
+        methods: normalizeIntegrationRouteMethods(route),
+        input: normalizeIntegrationRouteInputSchemas(route),
+        [INTEGRATION_ROUTE_SEGMENTS]: splitPath(route.path)
+      },
+      specificity: getRoutePatternSpecificity(route.path, "api")
+    };
+  }).sort(
+    (left, right) => compareRouteSpecificity(left.specificity, right.specificity) || left.index - right.index
+  ).map(({ route }) => route);
+  normalizedIntegrationRoutesCache.set(routes, normalized);
+  return normalized;
+}
+__name(normalizeIntegrationRoutes, "normalizeIntegrationRoutes");
+function normalizeIntegrationRouteMethods(route) {
+  const input = route.methods && route.methods.length > 0 ? [...route.methods] : route.method ? [route.method] : ["ALL"];
+  return input.map((method) => String(method).toUpperCase());
+}
+__name(normalizeIntegrationRouteMethods, "normalizeIntegrationRouteMethods");
+function normalizeIntegrationRouteInputSchemas(route) {
+  const input = {
+    ...route.input
+  };
+  if (route.body) {
+    input.body = route.body;
+  }
+  if (route.query) {
+    input.query = route.query;
+  }
+  return input.body || input.query ? input : void 0;
+}
+__name(normalizeIntegrationRouteInputSchemas, "normalizeIntegrationRouteInputSchemas");
+async function validateIntegrationRouteInput(route, request, url) {
+  if (request.method.toUpperCase() === "QUERY" && !request.headers.has("content-type")) {
+    return {
+      success: false,
+      response: Response.json(
+        {
+          error: "Invalid QUERY request",
+          message: "QUERY requests must include a Content-Type header."
+        },
+        { status: 400 }
+      )
+    };
+  }
+  const schemas = route.input;
+  if (!schemas?.body && !schemas?.query) {
+    return {
+      success: true,
+      input: {}
+    };
+  }
+  const input = {};
+  const issues = [];
+  if (schemas.query) {
+    const queryResult = await parseIntegrationInputSchema(
+      "query",
+      schemas.query,
+      createQueryInput(url.searchParams)
+    );
+    if (queryResult.success) {
+      input.query = queryResult.data;
+    } else {
+      issues.push(...queryResult.issues);
+    }
+  }
+  if (schemas.body) {
+    const bodyInput = await readIntegrationValidationBody(
+      request,
+      getIntegrationRouteBodyFormat(route)
+    );
+    if (bodyInput.success) {
+      const bodyResult = await parseIntegrationInputSchema("body", schemas.body, bodyInput.data);
+      if (bodyResult.success) {
+        input.body = bodyResult.data;
+      } else {
+        issues.push(...bodyResult.issues);
+      }
+    } else {
+      issues.push(bodyInput.issue);
+    }
+  }
+  if (issues.length > 0) {
+    return {
+      success: false,
+      response: createIntegrationValidationResponse(issues)
+    };
+  }
+  return {
+    success: true,
+    input
+  };
+}
+__name(validateIntegrationRouteInput, "validateIntegrationRouteInput");
+async function parseIntegrationInputSchema(source, schema, value) {
+  const parser = schema.safeParseAsync || schema.safeParse;
+  if (parser) {
+    const result = await parser.call(schema, value);
+    if (result.success) {
+      return {
+        success: true,
+        data: result.data
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIntegrationValidationIssues(source, result.error)
+    };
+  }
+  if (schema["~standard"]?.validate) {
+    const result = await schema["~standard"].validate(value);
+    if ("value" in result) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIntegrationValidationIssues(source, {
+        issues: result.issues
+      })
+    };
+  }
+  if (schema.parse) {
+    try {
+      return {
+        success: true,
+        data: await schema.parse(value)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeIntegrationValidationIssues(
+          source,
+          normalizeIntegrationValidationError(error)
+        )
+      };
+    }
+  }
+  return {
+    success: false,
+    issues: [
+      {
+        source,
+        message: "Input schema must expose safeParse, safeParseAsync, parse, or ~standard.validate."
+      }
+    ]
+  };
+}
+__name(parseIntegrationInputSchema, "parseIntegrationInputSchema");
+function createIntegrationValidationResponse(issues) {
+  return Response.json(
+    {
+      error: "Integration route input validation failed",
+      issues
+    },
+    {
+      status: 400
+    }
+  );
+}
+__name(createIntegrationValidationResponse, "createIntegrationValidationResponse");
+function normalizeIntegrationValidationIssues(source, error) {
+  if (Array.isArray(error.issues) && error.issues.length > 0) {
+    return error.issues.map((issue) => ({
+      source,
+      path: normalizeIntegrationValidationPath(issue.path),
+      code: issue.code,
+      message: issue.message || "Invalid input"
+    }));
+  }
+  return [
+    {
+      source,
+      path: [],
+      message: error.message || "Invalid input"
+    }
+  ];
+}
+__name(normalizeIntegrationValidationIssues, "normalizeIntegrationValidationIssues");
+function normalizeIntegrationValidationPath(path) {
+  return (path || []).map((segment) => {
+    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
+    return typeof key === "symbol" ? key.description || key.toString() : key;
+  });
+}
+__name(normalizeIntegrationValidationPath, "normalizeIntegrationValidationPath");
+function normalizeIntegrationValidationError(error) {
+  if (error && typeof error === "object") {
+    return error;
+  }
+  return {
+    message: error instanceof Error ? error.message : String(error || "Invalid input")
+  };
+}
+__name(normalizeIntegrationValidationError, "normalizeIntegrationValidationError");
+async function readIntegrationValidationBody(request, format) {
+  if (request.method === "GET" || request.method === "HEAD" || format === "none") {
+    return {
+      success: true,
+      data: void 0
+    };
+  }
+  try {
+    if (format === "form") {
+      return {
+        success: true,
+        data: createFormInput(await request.clone().formData())
+      };
+    }
+    const text = await request.clone().text();
+    if (text.trim().length === 0) {
+      return {
+        success: true,
+        data: void 0
+      };
+    }
+    return {
+      success: true,
+      data: JSON.parse(text)
+    };
+  } catch (error) {
+    return {
+      success: false,
+      issue: {
+        source: "body",
+        path: [],
+        message: format === "json" ? "Expected a valid JSON request body." : error instanceof Error && error.message ? error.message : "Could not parse request body."
+      }
+    };
+  }
+}
+__name(readIntegrationValidationBody, "readIntegrationValidationBody");
+function getIntegrationRouteBodyFormat(route) {
+  return route.bodyFormat || route.__operation?.bodyFormat || "json";
+}
+__name(getIntegrationRouteBodyFormat, "getIntegrationRouteBodyFormat");
+function createIntegrationRouteArgs(input) {
+  let clientPromise;
+  let ormPromise;
+  const getClient = /* @__PURE__ */ __name(() => {
+    clientPromise ?? (clientPromise = import("./storage.mjs").then(
+      ({ resolveStorageRuntimeClient }) => resolveStorageRuntimeClient(input.config.storage)
+    ));
+    return clientPromise;
+  }, "getClient");
+  const getOrm = /* @__PURE__ */ __name(() => {
+    if (!input.integration.schema) {
+      throw new Error(
+        `Integration "${input.integration.type}" does not define a schema for ctx.args.db.`
+      );
+    }
+    ormPromise ?? (ormPromise = import("./integration-orm-KV5B3BGZ.mjs").then(
+      ({ createIntegrationOrm }) => createIntegrationOrm({
+        schema: input.integration.schema,
+        config: input.config
+      })
+    ));
+    return ormPromise;
+  }, "getOrm");
+  return {
+    db: createLazyIntegrationOrmClient(getOrm),
+    getDb: getOrm,
+    storage: {
+      getClient,
+      getOrm
+    }
+  };
+}
+__name(createIntegrationRouteArgs, "createIntegrationRouteArgs");
+function createLazyIntegrationOrmClient(resolveOrm) {
+  const modelProxyCache = /* @__PURE__ */ new Map();
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (prop === "then") {
+          return void 0;
+        }
+        if (prop === "transaction" || prop === "batch") {
+          return async (...args) => {
+            const orm = await resolveOrm();
+            const member = orm[prop];
+            if (typeof member !== "function") {
+              throw new Error(`Integration ORM does not expose "${String(prop)}".`);
+            }
+            return member.apply(orm, args);
+          };
+        }
+        if (prop === "$driver") {
+          return void 0;
+        }
+        if (!modelProxyCache.has(prop)) {
+          modelProxyCache.set(prop, createLazyIntegrationOrmModel(resolveOrm, prop));
+        }
+        return modelProxyCache.get(prop);
+      }
+    }
+  );
+}
+__name(createLazyIntegrationOrmClient, "createLazyIntegrationOrmClient");
+function createLazyIntegrationOrmModel(resolveOrm, modelName) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (prop === "then") {
+          return void 0;
+        }
+        return async (...args) => {
+          const orm = await resolveOrm();
+          const model = orm[modelName];
+          const member = model?.[prop];
+          if (typeof member !== "function") {
+            throw new Error(
+              `Integration ORM model "${String(modelName)}" does not expose "${String(prop)}".`
+            );
+          }
+          return member.apply(model, args);
+        };
+      }
+    }
+  );
+}
+__name(createLazyIntegrationOrmModel, "createLazyIntegrationOrmModel");
+async function runIntegrationRouteBeforeHooks(route, request, context) {
+  const hookContext = context;
+  hookContext.response = void 0;
+  for (const hook of route.before || []) {
+    const response = await hook(request, hookContext);
+    if (response) {
+      hookContext.response = response;
+      return response;
+    }
+    if (hookContext.response) {
+      return hookContext.response;
+    }
+  }
+  return void 0;
+}
+__name(runIntegrationRouteBeforeHooks, "runIntegrationRouteBeforeHooks");
+async function runIntegrationRouteAfterHooks(route, request, context, response) {
+  const hookContext = context;
+  let currentResponse = response;
+  for (const hook of route.after || []) {
+    hookContext.response = currentResponse;
+    const nextResponse = await hook(request, hookContext);
+    currentResponse = nextResponse || hookContext.response || currentResponse;
+  }
+  hookContext.response = currentResponse;
+  return currentResponse;
+}
+__name(runIntegrationRouteAfterHooks, "runIntegrationRouteAfterHooks");
+function createQueryInput(searchParams) {
+  const input = {};
+  searchParams.forEach((value, key) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
+    const existing = input[key];
+    if (existing === void 0) {
+      input[key] = value;
+      return;
+    }
+    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+  });
+  return input;
+}
+__name(createQueryInput, "createQueryInput");
+function createFormInput(formData) {
+  const input = {};
+  formData.forEach((value, key) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
+    const existing = input[key];
+    if (existing === void 0) {
+      input[key] = value;
+      return;
+    }
+    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+  });
+  return input;
+}
+__name(createFormInput, "createFormInput");
+async function dispatchIntegrationRequest(runtime, request, options = {}) {
+  try {
+    request = await bufferFarmRequestBody(
+      request,
+      resolveFarmServerConfig(runtime.config.server).bodySizeLimit
+    );
+  } catch (error) {
+    const response = createFarmRequestBodyErrorResponse(error);
+    if (response) return response;
+    throw error;
+  }
+  const integration = runtime.integration;
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  const requestId = request.headers.get("x-request-id") || options.currentRequest?.headers.get("x-request-id") || String(Date.now());
+  const routes = normalizeIntegrationRoutes(integration.routes || []);
+  const pathSegments = canonicalizeRequestPathSegments(pathname);
+  const method = normalizeIntegrationRequestMethod(request.method);
+  const middleware = [...integration.middleware || []];
+  const forwardedSetCookies = [];
+  for (const entry of middleware) {
+    if (options.ranMiddleware?.has(entry)) continue;
+    const params = resolveIntegrationMiddlewareParams(entry, pathname, runtime.config);
+    if (!params) {
+      continue;
+    }
+    options.ranMiddleware?.add(entry);
+    const handlerContext = createServerIntegrationHandlerContext({
+      runtime,
+      route: {
+        kind: "middleware",
+        path: normalizeMatcher(entry.matcher),
+        methods: ["ALL"]
+      },
+      request,
+      params,
+      pathname,
+      requestId,
+      currentRequest: options.currentRequest,
+      data: options.data,
+      internal: options.internal === true
+    });
+    const startedAt = Date.now();
+    await emitIntegrationLog(integration, {
+      category: integration.category,
+      slot: integration.category,
+      type: integration.type,
+      phase: "request:start",
+      route: {
+        kind: "middleware",
+        path: normalizeMatcher(entry.matcher),
+        methods: ["ALL"]
+      },
+      request,
+      requestId,
+      context: handlerContext.req.snapshot()
+    });
+    try {
+      const response = await entry.handler(request, handlerContext);
+      forwardedSetCookies.push(...takeForwardedIntegrationSetCookies(handlerContext));
+      if (response) {
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "request:end",
+          route: {
+            kind: "middleware",
+            path: normalizeMatcher(entry.matcher),
+            methods: ["ALL"]
+          },
+          request,
+          response,
+          requestId,
+          durationMs: Date.now() - startedAt,
+          context: handlerContext.req.snapshot()
+        });
+        return appendIntegrationForwardedCookies(response, forwardedSetCookies);
+      }
+      await emitIntegrationLog(integration, {
+        category: integration.category,
+        slot: integration.category,
+        type: integration.type,
+        phase: "request:end",
+        route: {
+          kind: "middleware",
+          path: normalizeMatcher(entry.matcher),
+          methods: ["ALL"]
+        },
+        request,
+        requestId,
+        durationMs: Date.now() - startedAt,
+        context: handlerContext.req.snapshot()
+      });
+    } catch (error) {
+      await emitIntegrationLog(integration, {
+        category: integration.category,
+        slot: integration.category,
+        type: integration.type,
+        phase: "request:error",
+        route: {
+          kind: "middleware",
+          path: normalizeMatcher(entry.matcher),
+          methods: ["ALL"]
+        },
+        request,
+        requestId,
+        durationMs: Date.now() - startedAt,
+        error,
+        context: handlerContext.req.snapshot()
+      });
+      throw error;
+    }
+  }
+  for (const route of routes) {
+    const params = method && matchesMethod(route.methods, method) ? matchPathSegments(route[INTEGRATION_ROUTE_SEGMENTS], pathSegments) : null;
+    if (!params) {
+      continue;
+    }
+    const handlerContext = createServerIntegrationHandlerContext({
+      runtime,
+      route: {
+        kind: "route",
+        path: route.path,
+        methods: route.methods
+      },
+      request,
+      params,
+      pathname,
+      requestId,
+      currentRequest: options.currentRequest,
+      data: options.data,
+      internal: options.internal === true
+    });
+    const startedAt = Date.now();
+    await emitIntegrationLog(integration, {
+      category: integration.category,
+      slot: integration.category,
+      type: integration.type,
+      phase: "request:start",
+      route: {
+        kind: "route",
+        path: route.path,
+        methods: route.methods
+      },
+      request,
+      requestId,
+      context: handlerContext.req.snapshot()
+    });
+    try {
+      const validation = await validateIntegrationRouteInput(route, request, url);
+      if (!validation.success) {
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "request:end",
+          route: {
+            kind: "route",
+            path: route.path,
+            methods: route.methods
+          },
+          request,
+          response: validation.response,
+          requestId,
+          durationMs: Date.now() - startedAt,
+          context: handlerContext.req.snapshot()
+        });
+        return appendIntegrationForwardedCookies(validation.response, forwardedSetCookies);
+      }
+      handlerContext.input = validation.input;
+      for (const middlewareEntry of route.middleware || []) {
+        const middlewareResponse = await middlewareEntry.handler(request, handlerContext);
+        forwardedSetCookies.push(...takeForwardedIntegrationSetCookies(handlerContext));
+        if (middlewareResponse) {
+          await emitIntegrationLog(integration, {
+            category: integration.category,
+            slot: integration.category,
+            type: integration.type,
+            phase: "request:end",
+            route: {
+              kind: "route",
+              path: route.path,
+              methods: route.methods
+            },
+            request,
+            response: middlewareResponse,
+            requestId,
+            durationMs: Date.now() - startedAt,
+            context: handlerContext.req.snapshot()
+          });
+          return appendIntegrationForwardedCookies(middlewareResponse, forwardedSetCookies);
+        }
+      }
+      const beforeResponse = await runIntegrationRouteBeforeHooks(route, request, handlerContext);
+      if (beforeResponse) {
+        const response2 = await runIntegrationRouteAfterHooks(
+          route,
+          request,
+          handlerContext,
+          beforeResponse
+        );
+        await emitIntegrationLog(integration, {
+          category: integration.category,
+          slot: integration.category,
+          type: integration.type,
+          phase: "request:end",
+          route: {
+            kind: "route",
+            path: route.path,
+            methods: route.methods
+          },
+          request,
+          response: response2,
+          requestId,
+          durationMs: Date.now() - startedAt,
+          context: handlerContext.req.snapshot()
+        });
+        return appendIntegrationForwardedCookies(response2, forwardedSetCookies);
+      }
+      const handlerResponse = await route.handler(request, handlerContext);
+      const response = await runIntegrationRouteAfterHooks(
+        route,
+        request,
+        handlerContext,
+        handlerResponse
+      );
+      await emitIntegrationLog(integration, {
+        category: integration.category,
+        slot: integration.category,
+        type: integration.type,
+        phase: "request:end",
+        route: {
+          kind: "route",
+          path: route.path,
+          methods: route.methods
+        },
+        request,
+        response,
+        requestId,
+        durationMs: Date.now() - startedAt,
+        context: handlerContext.req.snapshot()
+      });
+      return appendIntegrationForwardedCookies(response, forwardedSetCookies);
+    } catch (error) {
+      await emitIntegrationLog(integration, {
+        category: integration.category,
+        slot: integration.category,
+        type: integration.type,
+        phase: "request:error",
+        route: {
+          kind: "route",
+          path: route.path,
+          methods: route.methods
+        },
+        request,
+        requestId,
+        durationMs: Date.now() - startedAt,
+        error,
+        context: handlerContext.req.snapshot()
+      });
+      throw error;
+    }
+  }
+  if (forwardedSetCookies.length > 0) {
+    options.onForwardedCookies?.(forwardedSetCookies);
+  }
+  return null;
+}
+__name(dispatchIntegrationRequest, "dispatchIntegrationRequest");
+async function dispatchIntegrationRequests(integrations, runtime, request, options = {}) {
+  const setCookies = [];
+  if (!integrations) {
+    return { response: null, setCookies };
+  }
+  for (const integration of Object.values(integrations)) {
+    if (!integration || !isFarmIntegration(integration)) {
+      continue;
+    }
+    const hasMiddleware = (integration.middleware || []).length > 0;
+    const hasRoutes = normalizeIntegrationRoutes(integration.routes || []).length > 0;
+    if (!hasMiddleware && !hasRoutes) {
+      continue;
+    }
+    const response = await dispatchIntegrationRequest(
+      { ...runtime, integration },
+      // Each dispatch buffers the body it is given, so hand every integration
+      // its own clone rather than a Request another dispatch already read.
+      request.clone(),
+      {
+        currentRequest: options.currentRequest,
+        ranMiddleware: options.ranMiddleware,
+        onForwardedCookies: /* @__PURE__ */ __name((cookies) => setCookies.push(...cookies), "onForwardedCookies")
+      }
+    );
+    if (response) {
+      return {
+        response: appendIntegrationForwardedCookies(response, setCookies),
+        setCookies: []
+      };
+    }
+  }
+  return { response: null, setCookies };
+}
+__name(dispatchIntegrationRequests, "dispatchIntegrationRequests");
+globalThis[INTEGRATION_REQUEST_DISPATCHER_KEY] = dispatchIntegrationRequest;
+function createIntegrationRequestContextStore(rawRequest, request, pluginContext) {
+  return {
+    get(key) {
+      const requestValue = pluginContext.requestContext.get(request, key);
+      if (requestValue !== void 0) {
+        return requestValue;
+      }
+      return pluginContext.requestContext.get(rawRequest, key);
+    },
+    set(key, value, options) {
+      pluginContext.requestContext.set(rawRequest, key, value, options);
+      pluginContext.requestContext.set(request, key, value, options);
+    },
+    has(key) {
+      return pluginContext.requestContext.has(request, key) || pluginContext.requestContext.has(rawRequest, key);
+    },
+    delete(key) {
+      const deletedRequest = pluginContext.requestContext.delete(request, key);
+      const deletedRaw = pluginContext.requestContext.delete(rawRequest, key);
+      return deletedRequest || deletedRaw;
+    },
+    clear() {
+      pluginContext.requestContext.clear(rawRequest);
+      pluginContext.requestContext.clear(request);
+    },
+    snapshot(options) {
+      const merged = pluginContext.requestContext.getAll(rawRequest, options);
+      const requestSnapshot = pluginContext.requestContext.getAll(request, options);
+      for (const [key, value] of requestSnapshot) {
+        merged.set(key, value);
+      }
+      return merged;
+    }
+  };
+}
+__name(createIntegrationRequestContextStore, "createIntegrationRequestContextStore");
+function createServerIntegrationHandlerContext(input) {
+  const req = createServerIntegrationRequestContextStore(input.request, input.currentRequest);
+  if (input.internal) {
+    req.set(FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY, true);
+  }
+  return {
+    request: input.request,
+    requestId: input.requestId,
+    url: new URL(input.request.url),
+    pathname: input.pathname,
+    method: input.request.method,
+    params: input.params,
+    input: {},
+    args: createIntegrationRouteArgs({
+      integration: input.runtime.integration,
+      config: input.runtime.config
+    }),
+    data: resolveIntegrationData(input.request, input.data),
+    integration: {
+      category: input.runtime.integration.category,
+      slot: input.runtime.integration.category,
+      type: input.runtime.integration.type,
+      instance: input.runtime.integration.instance
+    },
+    route: input.route,
+    req,
+    requestContext: req,
+    config: input.runtime.config,
+    isDev: input.runtime.isDev,
+    isProd: input.runtime.isProd
+  };
+}
+__name(createServerIntegrationHandlerContext, "createServerIntegrationHandlerContext");
+function createServerIntegrationRequestContextStore(request, currentRequest) {
+  return {
+    get(key) {
+      const requestValue = getRequestContext(request, key);
+      if (requestValue !== void 0) {
+        return requestValue;
+      }
+      if (currentRequest) {
+        return getRequestContext(currentRequest, key);
+      }
+      return void 0;
+    },
+    set(key, value, options) {
+      setRequestContext(request, key, value, options);
+      if (currentRequest) {
+        setRequestContext(currentRequest, key, value, options);
+      }
+    },
+    has(key) {
+      return hasRequestContext(request, key) || !!currentRequest && hasRequestContext(currentRequest, key);
+    },
+    delete(key) {
+      const deletedRequest = deleteRequestContext(request, key);
+      const deletedCurrent = currentRequest ? deleteRequestContext(currentRequest, key) : false;
+      return deletedRequest || deletedCurrent;
+    },
+    clear() {
+      clearRequestContext(request);
+      if (currentRequest) {
+        clearRequestContext(currentRequest);
+      }
+    },
+    snapshot(options) {
+      const merged = currentRequest ? getRequestContextSnapshot(currentRequest, options) : /* @__PURE__ */ new Map();
+      const requestSnapshot = getRequestContextSnapshot(request, options);
+      for (const [key, value] of requestSnapshot) {
+        merged.set(key, value);
+      }
+      return merged;
+    }
+  };
+}
+__name(createServerIntegrationRequestContextStore, "createServerIntegrationRequestContextStore");
+function createWebRequest(req, fullUrl, body) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  return new Request(fullUrl, {
+    method: req.method,
+    headers,
+    body
+  });
+}
+__name(createWebRequest, "createWebRequest");
+function normalizeIntegrationRequestMethod(method) {
+  return method ? method.toUpperCase() : void 0;
+}
+__name(normalizeIntegrationRequestMethod, "normalizeIntegrationRequestMethod");
+function matchesMethod(methods, normalizedMethod) {
+  return methods.some((candidate) => candidate === "ALL" || candidate === normalizedMethod);
+}
+__name(matchesMethod, "matchesMethod");
+var compiledIntegrationGuards = /* @__PURE__ */ new WeakMap();
+var noMiddlewareContext = {};
+function resolveIntegrationMiddlewareParams(entry, pathname, config) {
+  const params = resolveMatcherParams(entry.matcher, pathname);
+  if (params || !entry.matcher) return params;
+  const routePathname = resolveIntegrationRoutePathname(pathname, config);
+  const candidates = [.../* @__PURE__ */ new Set([pathname, ...getIntegrationAPIPathnames(config)(routePathname)])];
+  for (const candidate of candidates) {
+    if (candidate === pathname) continue;
+    const routeParams = resolveMatcherParams(entry.matcher, candidate);
+    if (routeParams) return routeParams;
+  }
+  let compiled = compiledIntegrationGuards.get(entry);
+  if (!compiled) {
+    compiled = compileMiddlewareConfig({
+      matcher: typeof entry.matcher === "string" ? entry.matcher : [...entry.matcher]
+    });
+    compiledIntegrationGuards.set(entry, compiled);
+  }
+  for (const candidate of candidates) {
+    const result = matchesCompiledMiddlewareConfig(candidate, compiled, noMiddlewareContext);
+    if (result.matched) return result.params ?? {};
+  }
+  return null;
+}
+__name(resolveIntegrationMiddlewareParams, "resolveIntegrationMiddlewareParams");
+var FARM_INTEGRATION_API_BASE_PATH_KEY = "__farmAPIServerBasePath";
+var integrationAPIPathnames = /* @__PURE__ */ new WeakMap();
+function getIntegrationAPIPathnames(config) {
+  if (!config) return (pathname) => [pathname];
+  let toPathnames = integrationAPIPathnames.get(config);
+  if (!toPathnames) {
+    const recorded = config[FARM_INTEGRATION_API_BASE_PATH_KEY];
+    const api2 = config.api;
+    const serverBasePath = typeof recorded === "string" ? recorded : typeof api2?.baseURL === "string" && typeof api2.basePath === "string" ? resolveFarmAPIServerBasePath(api2) : void 0;
+    toPathnames = createFarmAPIMiddlewarePathnames(serverBasePath);
+    integrationAPIPathnames.set(config, toPathnames);
+  }
+  return toPathnames;
+}
+__name(getIntegrationAPIPathnames, "getIntegrationAPIPathnames");
+function resolveIntegrationRoutePathname(pathname, config) {
+  const basePath = typeof config?.basePath === "string" ? config.basePath : void 0;
+  let routePathname = basePath ? stripFarmBasePath(pathname, basePath) : pathname;
+  const i18n = config?.i18n;
+  if (i18n && Array.isArray(i18n.locales) && i18n.locales.length > 0) {
+    routePathname = resolveFarmLocalePath(routePathname, {
+      locales: i18n.locales,
+      defaultLocale: i18n.defaultLocale,
+      routing: i18n.routing || "prefix-except-default"
+    }).pathname;
+  }
+  return routePathname;
+}
+__name(resolveIntegrationRoutePathname, "resolveIntegrationRoutePathname");
+function resolveMatcherParams(matcher, pathname) {
+  if (!matcher) {
+    return {};
+  }
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  let canonicalPathname;
+  let canonicalSegments;
+  for (const item of list) {
+    if (item === "/(.*)" || item === "*") {
+      return {};
+    }
+    if (item.endsWith("(.*)")) {
+      canonicalPathname ?? (canonicalPathname = canonicalizeRequestPathname(pathname));
+      const prefix = item.slice(0, -4);
+      if (canonicalPathname === prefix || canonicalPathname.startsWith(`${prefix}/`)) {
+        return {};
+      }
+      continue;
+    }
+    canonicalSegments ?? (canonicalSegments = canonicalizeRequestPathSegments(pathname));
+    const params = matchPathSegments(splitPath(item), canonicalSegments);
+    if (params) {
+      return params;
+    }
+  }
+  return null;
+}
+__name(resolveMatcherParams, "resolveMatcherParams");
+function matchPathSegments(routeSegments, pathSegments) {
+  const params = {};
+  let routeIndex = 0;
+  let pathIndex = 0;
+  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
+    const routeSegment = routeSegments[routeIndex];
+    const pathSegment = pathSegments[pathIndex];
+    if (isCatchAllSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex);
+      return params;
+    }
+    if (isDynamicSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = pathSegment;
+      routeIndex += 1;
+      pathIndex += 1;
+      continue;
+    }
+    if (routeSegment !== pathSegment) {
+      return null;
+    }
+    routeIndex += 1;
+    pathIndex += 1;
+  }
+  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
+    return params;
+  }
+  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
+    params[getSegmentParamName(routeSegments[routeIndex])] = [];
+    return params;
+  }
+  return null;
+}
+__name(matchPathSegments, "matchPathSegments");
+function splitPath(value) {
+  return value.split("/").filter(Boolean);
+}
+__name(splitPath, "splitPath");
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") && segment.endsWith("]");
+}
+__name(isDynamicSegment, "isDynamicSegment");
+function isCatchAllSegment(segment) {
+  return segment.startsWith("[...") && segment.endsWith("]");
+}
+__name(isCatchAllSegment, "isCatchAllSegment");
+function getSegmentParamName(segment) {
+  if (isCatchAllSegment(segment)) {
+    return segment.slice(4, -1);
+  }
+  return segment.slice(1, -1);
+}
+__name(getSegmentParamName, "getSegmentParamName");
+function getRequestId(req) {
+  const headerValue = req.headers["x-request-id"];
+  if (Array.isArray(headerValue)) {
+    return headerValue[0] || String(Date.now());
+  }
+  return headerValue || String(Date.now());
+}
+__name(getRequestId, "getRequestId");
+function normalizeMatcher(matcher) {
+  if (!matcher) {
+    return "/(.*)";
+  }
+  return typeof matcher === "string" ? matcher : matcher.join(", ");
+}
+__name(normalizeMatcher, "normalizeMatcher");
+
+export {
+  getFarmPluginIntegrationContext,
+  FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY,
+  FARM_INTEGRATION_SET_COOKIES_KEY,
+  forwardIntegrationSetCookies,
+  defineIntegrationSchema,
+  getFarmIntegrationPluginServerRuntime,
+  getFarmIntegrationPluginOwner,
+  createIntegrationRoute,
+  integrationRoute,
+  defineIntegration,
+  isFarmIntegration,
+  resolveIntegrationPlugins,
+  getIntegrationProviders,
+  isFarmIntegrationProviderComponentReference,
+  getIntegrationDocumentNavigationMatchers,
+  getIntegrationSchemas,
+  getRegisteredIntegrationRuntime,
+  getRegisteredIntegrations,
+  getRegisteredIntegrationSchemas,
+  matchIntegrationRoute,
+  matchRegisteredIntegrationRoute,
+  getRegisteredIntegrationAPIManifest,
+  dispatchIntegrationRequest,
+  dispatchIntegrationRequests,
+  FARM_INTEGRATION_API_BASE_PATH_KEY
+};