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

package/dist/chunk-Y2G5SJFB.mjs

@@ -1,1964 +0,0 @@
-import {
-  setFarmPluginIntegrationContext
-} from "./chunk-H4WUWLQR.mjs";
-import {
-  isFarmIntegration,
-  matchPathSegments,
-  resolveIntegrationMiddlewareParams,
-  splitPath
-} from "./chunk-F6TLUMH7.mjs";
-import {
-  defineSchema
-} from "./chunk-46P5KNTE.mjs";
-import {
-  assertSupportedMiddlewareMatcher
-} from "./chunk-EDPENAVO.mjs";
-import {
-  toPublicValidationIssues
-} from "./chunk-TGSEVBPO.mjs";
-import {
-  applyWebResponseHeaders,
-  sendWebResponse
-} from "./chunk-CO6UYM2D.mjs";
-import {
-  bufferFarmRequestBody,
-  createFarmRequestBodyErrorResponse,
-  readNodeRequestBody,
-  resolveFarmServerConfig,
-  withFarmRequestClientAddress
-} from "./chunk-GFT5AHAT.mjs";
-import {
-  clearRequestContext,
-  deleteRequestContext,
-  getRequestContext,
-  getRequestContextSnapshot,
-  hasRequestContext,
-  setRequestContext
-} from "./chunk-D2LCAV6L.mjs";
-import {
-  api,
-  defineIntegrationAPIOperation
-} from "./chunk-GYMGK467.mjs";
-import {
-  validateConfigRouteSource
-} from "./chunk-ONG4RDW3.mjs";
-import {
-  canonicalizeRequestPathSegments
-} from "./chunk-OHWM2VI4.mjs";
-import {
-  assertTerminalCatchAll,
-  assertUniqueRouteParameters,
-  compareRouteSpecificity,
-  getRoutePatternSpecificity
-} from "./chunk-AYP2YFVN.mjs";
-
-// 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]);
-}
-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 [];
-}
-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
-  });
-}
-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;
-}
-function getFarmIntegrationPluginOwner(plugin) {
-  const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
-  return value && typeof value === "object" ? value : void 0;
-}
-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
-    })
-  };
-}
-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
-      );
-    }
-  };
-}
-function createIntegrationRoute(_schema) {
-  return createIntegrationRouteFactory();
-}
-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];
-}
-function isIntegrationEndpointRoute(value) {
-  return !!value && typeof value === "object" && typeof value.path === "string" && typeof value.handler === "function";
-}
-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 [];
-}
-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
-  };
-}
-function resolveIntegrationPlugins(integrations) {
-  if (!integrations) {
-    return [];
-  }
-  const plugins = [];
-  for (const [key, integration] of Object.entries(integrations)) {
-    if (!integration || !isFarmIntegration(integration)) {
-      continue;
-    }
-    for (const entry of integration.middleware || []) {
-      if (!entry.matcher) continue;
-      const matchers = Array.isArray(entry.matcher) ? entry.matcher : [entry.matcher];
-      try {
-        matchers.forEach(assertSupportedMiddlewareMatcher);
-      } catch (error) {
-        throw new Error(`Integration "${key}": ${error.message}`);
-      }
-    }
-    const owner = createIntegrationPluginOwner(key, integration, "lifecycle");
-    plugins.push(withIntegrationPluginOwner(createIntegrationPlugin(key, integration), owner));
-    plugins.push(...resolveIntegrationPluginContributions(key, integration));
-  }
-  return plugins;
-}
-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)
-    );
-  });
-}
-function createIntegrationPluginOwner(key, integration, source) {
-  return Object.freeze({
-    key,
-    category: integration.category,
-    type: integration.type,
-    source,
-    serverRuntime: integration.serverRuntime !== false
-  });
-}
-function createIntegrationPluginContext(key, integration) {
-  return Object.freeze({
-    key,
-    category: integration.category,
-    type: integration.type,
-    instance: integration.instance,
-    serverRuntime: integration.serverRuntime !== false
-  });
-}
-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;
-}
-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;
-}
-function isFarmIntegrationProviderComponentReference(value) {
-  return Boolean(
-    value && typeof value === "object" && "module" in value && typeof value.module === "string" && value.module.length > 0
-  );
-}
-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;
-}
-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);
-}
-function getRegisteredIntegrationRuntime(key) {
-  return getIntegrationRuntimeRegistry().get(key);
-}
-function getRegisteredIntegrations() {
-  return Object.fromEntries(
-    Array.from(getIntegrationRuntimeRegistry().entries()).map(([key, runtime]) => [
-      key,
-      runtime.integration
-    ])
-  );
-}
-function getRegisteredIntegrationSchemas() {
-  return getIntegrationSchemas(getRegisteredIntegrations());
-}
-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;
-}
-function matchRegisteredIntegrationRoute(input) {
-  return matchIntegrationRoute(getRegisteredIntegrations(), input);
-}
-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);
-}
-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);
-}
-function getIntegrationRuntimeEnv() {
-  return typeof process !== "undefined" ? process.env : {};
-}
-function isIntegrationConfigDefinition(value) {
-  return !!value && typeof value === "object" && ("schema" in value || "env" in value || "defaults" in value || "input" in value || "resolve" in value);
-}
-function mergeIntegrationConfigValue(current, next) {
-  if (next === void 0) {
-    return current;
-  }
-  if (isPlainIntegrationConfigObject(current) && isPlainIntegrationConfigObject(next)) {
-    return {
-      ...current,
-      ...next
-    };
-  }
-  return next;
-}
-function isPlainIntegrationConfigObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-async function resolveIntegrationConfigPart(value, context) {
-  if (typeof value === "function") {
-    return value(context);
-  }
-  return value;
-}
-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;
-}
-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.`
-  );
-}
-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}`);
-}
-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;
-}
-function createIntegrationLifecycleLogger(integration, phase) {
-  const write = (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(() => {
-    });
-  };
-  return {
-    info(message, meta) {
-      write("info", message, meta);
-    },
-    warn(message, meta) {
-      write("warn", message, meta);
-    },
-    error(message, meta) {
-      write("error", message, meta);
-    }
-  };
-}
-async function emitIntegrationLog(integration, event) {
-  try {
-    await integration.log?.(event);
-  } catch {
-  }
-}
-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);
-}
-function isPlainIntegrationDataObject(value) {
-  if (!isFarmIntegrationData(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-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;
-}
-function normalizeIntegrationData(value) {
-  if (!isFarmIntegrationData(value)) {
-    return {};
-  }
-  const sanitized = sanitizeIntegrationDataValue(value);
-  return isFarmIntegrationData(sanitized) ? sanitized : {};
-}
-function getIntegrationDataHeaderByteLength(value) {
-  return new TextEncoder().encode(value).byteLength;
-}
-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 {};
-  }
-}
-function resolveIntegrationData(request, data) {
-  return {
-    ...parseIntegrationDataHeader(request),
-    ...normalizeIntegrationData(data)
-  };
-}
-function createIntegrationPlugin(integrationKey, integration) {
-  const routes = normalizeIntegrationRoutes(integration.routes || []);
-  const middleware = [...integration.middleware || []];
-  const cleanupCallbacks = [];
-  let integrationConfigPromise;
-  const runCleanup = async () => {
-    const callbacks = cleanupCallbacks.splice(0).reverse();
-    for (const callback of callbacks) {
-      await callback();
-    }
-  };
-  const createLifecycleContext = 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();
-      }
-    };
-  };
-  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) {
-      if (req.url && !req.url.startsWith("/")) return;
-      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 = 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;
-      };
-      const createHandlerRequest = async () => {
-        try {
-          return withFarmRequestClientAddress(
-            createWebRequest(req, fullUrl, await getRequestBody()),
-            resolveFarmServerConfig(context.config.server).trustProxy,
-            req.socket?.remoteAddress
-          );
-        } catch (error) {
-          const response = createFarmRequestBodyErrorResponse(error);
-          if (!response) throw error;
-          await sendWebResponse(res, response);
-          return null;
-        }
-      };
-      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;
-}
-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
-  };
-}
-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;
-}
-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());
-}
-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;
-}
-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
-  };
-}
-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."
-      }
-    ]
-  };
-}
-function createIntegrationValidationResponse(issues) {
-  return Response.json(
-    {
-      error: "Integration route input validation failed",
-      issues
-    },
-    {
-      status: 400
-    }
-  );
-}
-function normalizeIntegrationValidationIssues(source, error) {
-  if (Array.isArray(error.issues) && error.issues.length > 0) {
-    return toPublicValidationIssues(error).map((issue) => ({ source, ...issue }));
-  }
-  return [
-    {
-      source,
-      path: [],
-      message: "Invalid input"
-    }
-  ];
-}
-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;
-  });
-}
-function normalizeIntegrationValidationError(error) {
-  if (error && typeof error === "object") {
-    return error;
-  }
-  return {
-    message: error instanceof Error ? error.message : String(error || "Invalid input")
-  };
-}
-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."
-      }
-    };
-  }
-}
-function getIntegrationRouteBodyFormat(route) {
-  return route.bodyFormat || route.__operation?.bodyFormat || "json";
-}
-function createIntegrationRouteArgs(input) {
-  let clientPromise;
-  let ormPromise;
-  const getClient = () => {
-    clientPromise ?? (clientPromise = import("./storage.mjs").then(
-      ({ resolveStorageRuntimeClient }) => resolveStorageRuntimeClient(input.config.storage)
-    ));
-    return clientPromise;
-  };
-  const getOrm = () => {
-    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-CO23MSFE.mjs").then(
-      ({ createIntegrationOrm }) => createIntegrationOrm({
-        schema: input.integration.schema,
-        config: input.config
-      })
-    ));
-    return ormPromise;
-  };
-  return {
-    db: createLazyIntegrationOrmClient(getOrm),
-    getDb: getOrm,
-    storage: {
-      getClient,
-      getOrm
-    }
-  };
-}
-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);
-      }
-    }
-  );
-}
-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);
-        };
-      }
-    }
-  );
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-async function dispatchIntegrationRequest(runtime, request, options = {}) {
-  const serverConfig = resolveFarmServerConfig(runtime.config.server);
-  try {
-    request = await bufferFarmRequestBody(request, serverConfig.bodySizeLimit);
-  } catch (error) {
-    const response = createFarmRequestBodyErrorResponse(error);
-    if (response) return response;
-    throw error;
-  }
-  request = withFarmRequestClientAddress(request, serverConfig.trustProxy, options.clientAddress);
-  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;
-}
-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,
-        clientAddress: options.clientAddress,
-        onForwardedCookies: (cookies) => setCookies.push(...cookies)
-      }
-    );
-    if (response) {
-      return {
-        response: appendIntegrationForwardedCookies(response, setCookies),
-        setCookies: []
-      };
-    }
-  }
-  return { response: null, setCookies };
-}
-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;
-    }
-  };
-}
-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
-  };
-}
-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;
-    }
-  };
-}
-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
-  });
-}
-function normalizeIntegrationRequestMethod(method) {
-  return method ? method.toUpperCase() : void 0;
-}
-function matchesMethod(methods, normalizedMethod) {
-  return methods.some((candidate) => candidate === "ALL" || candidate === normalizedMethod);
-}
-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());
-}
-function normalizeMatcher(matcher) {
-  if (!matcher) {
-    return "/(.*)";
-  }
-  return typeof matcher === "string" ? matcher : matcher.join(", ");
-}
-
-export {
-  FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY,
-  FARM_INTEGRATION_SET_COOKIES_KEY,
-  forwardIntegrationSetCookies,
-  defineIntegrationSchema,
-  getFarmIntegrationPluginServerRuntime,
-  getFarmIntegrationPluginOwner,
-  createIntegrationRoute,
-  integrationRoute,
-  defineIntegration,
-  resolveIntegrationPlugins,
-  getIntegrationProviders,
-  isFarmIntegrationProviderComponentReference,
-  getIntegrationDocumentNavigationMatchers,
-  getIntegrationSchemas,
-  getRegisteredIntegrationRuntime,
-  getRegisteredIntegrations,
-  getRegisteredIntegrationSchemas,
-  matchIntegrationRoute,
-  matchRegisteredIntegrationRoute,
-  getRegisteredIntegrationAPIManifest,
-  dispatchIntegrationRequest,
-  dispatchIntegrationRequests
-};