@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-I32V5CZL.cjs

@@ -0,0 +1,1965 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkDUIP64BFcjs = require('./chunk-DUIP64BF.cjs');
+
+
+
+
+
+var _chunkZOYKJBP5cjs = require('./chunk-ZOYKJBP5.cjs');
+
+
+var _chunkZXK2EYQWcjs = require('./chunk-ZXK2EYQW.cjs');
+
+
+var _chunk5DX3O6TTcjs = require('./chunk-5DX3O6TT.cjs');
+
+
+var _chunkITV4QQL2cjs = require('./chunk-ITV4QQL2.cjs');
+
+
+
+var _chunkYIHRZBD7cjs = require('./chunk-YIHRZBD7.cjs');
+
+
+
+
+
+
+
+var _chunkCFG4QERRcjs = require('./chunk-CFG4QERR.cjs');
+
+
+
+
+
+
+
+var _chunkJYT7AN37cjs = require('./chunk-JYT7AN37.cjs');
+
+
+
+var _chunkHA7YRO53cjs = require('./chunk-HA7YRO53.cjs');
+
+
+var _chunk6XQSPIN6cjs = require('./chunk-6XQSPIN6.cjs');
+
+
+var _chunk6CTFVBATcjs = require('./chunk-6CTFVBAT.cjs');
+
+
+
+
+
+var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+
+// 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 = _nullishCoalesce(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 = _chunkZXK2EYQWcjs.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: _chunkHA7YRO53cjs.defineIntegrationAPIOperation.call(void 0, {
+      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 = _nullishCoalesce(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 = _optionalChain([routes, 'optionalAccess', _ => _.length]) || endpointRoutes.length ? [...routes || [], ...endpointRoutes] : void 0;
+  for (const route of allRoutes || []) {
+    _chunkYTVSWXEZcjs.assertUniqueRouteParameters.call(void 0, route.path, "api");
+    _chunk6XQSPIN6cjs.validateConfigRouteSource.call(void 0, route.path, `Integration route "${route.path}"`);
+    _chunkYTVSWXEZcjs.assertTerminalCatchAll.call(void 0, route.path, "api");
+  }
+  const derivedApi = integration.api || (_optionalChain([allRoutes, 'optionalAccess', _2 => _2.length]) ? _chunkHA7YRO53cjs.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 || !_chunkZOYKJBP5cjs.isFarmIntegration.call(void 0, 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(_chunk5DX3O6TTcjs.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) {
+    _chunkDUIP64BFcjs.setFarmPluginIntegrationContext.call(void 0, ownedPlugin, integration);
+  }
+  return ownedPlugin;
+}
+function getIntegrationProviders(integrations) {
+  if (!integrations) {
+    return [];
+  }
+  const providers = [];
+  for (const integration of Object.values(integrations)) {
+    if (!integration || !_chunkZOYKJBP5cjs.isFarmIntegration.call(void 0, integration) || !_optionalChain([integration, 'access', _3 => _3.providers, 'optionalAccess', _4 => _4.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 || !_chunkZOYKJBP5cjs.isFarmIntegration.call(void 0, integration) || !_optionalChain([integration, 'access', _5 => _5.documentNavigations, 'optionalAccess', _6 => _6.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 && _chunkZOYKJBP5cjs.isFarmIntegration.call(void 0, 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 = _chunk6CTFVBATcjs.canonicalizeRequestPathSegments.call(void 0, input.pathname);
+  for (const [key, integration] of Object.entries(integrations)) {
+    if (!integration || !_chunkZOYKJBP5cjs.isFarmIntegration.call(void 0, integration)) {
+      continue;
+    }
+    const routes = normalizeIntegrationRoutes(integration.routes || []);
+    for (const route of routes) {
+      if (!matchesMethod(route.methods, method)) {
+        continue;
+      }
+      const params = _chunkZOYKJBP5cjs.matchPathSegments.call(void 0, 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,
+        _chunkHA7YRO53cjs.defineIntegrationAPIOperation.call(void 0, {
+          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 (_optionalChain([schema, 'access', _7 => _7["~standard"], 'optionalAccess', _8 => _8.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 _optionalChain([config, 'access', _9 => _9.resolve, 'optionalCall', _10 => _10(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 _optionalChain([integration, 'access', _11 => _11.log, 'optionalCall', _12 => _12(event)]);
+  } catch (e) {
+  }
+}
+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 (e2) {
+    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
+    };
+    _nullishCoalesce(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 = _chunk6CTFVBATcjs.canonicalizeRequestPathSegments.call(void 0, 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 _chunkCFG4QERRcjs.readNodeRequestBody.call(void 0, 
+              req,
+              _chunkCFG4QERRcjs.resolveFarmServerConfig.call(void 0, context.config.server).bodySizeLimit
+            );
+          }
+        }
+        return requestBody;
+      };
+      const createHandlerRequest = async () => {
+        try {
+          return _chunkCFG4QERRcjs.withFarmRequestClientAddress.call(void 0, 
+            createWebRequest(req, fullUrl, await getRequestBody()),
+            _chunkCFG4QERRcjs.resolveFarmServerConfig.call(void 0, context.config.server).trustProxy,
+            _optionalChain([req, 'access', _13 => _13.socket, 'optionalAccess', _14 => _14.remoteAddress])
+          );
+        } catch (error) {
+          const response = _chunkCFG4QERRcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+          if (!response) throw error;
+          await _chunkYIHRZBD7cjs.sendWebResponse.call(void 0, res, response);
+          return null;
+        }
+      };
+      for (const entry of middleware) {
+        const params = _chunkZOYKJBP5cjs.resolveIntegrationMiddlewareParams.call(void 0, 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);
+            }
+            _chunkYIHRZBD7cjs.applyWebResponseHeaders.call(void 0, res, setCookieHeaders, { appendSetCookie: true });
+          }
+          if (response) {
+            await _chunkYIHRZBD7cjs.sendWebResponse.call(void 0, 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) ? _chunkZOYKJBP5cjs.matchPathSegments.call(void 0, 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 _chunkYIHRZBD7cjs.sendWebResponse.call(void 0, 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 _chunkYIHRZBD7cjs.sendWebResponse.call(void 0, 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 _chunkYIHRZBD7cjs.sendWebResponse.call(void 0, 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 _chunkYIHRZBD7cjs.sendWebResponse.call(void 0, 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) => {
+    _chunkYTVSWXEZcjs.assertUniqueRouteParameters.call(void 0, route.path, "api");
+    return {
+      index,
+      route: {
+        ...route,
+        methods: normalizeIntegrationRouteMethods(route),
+        input: normalizeIntegrationRouteInputSchemas(route),
+        [INTEGRATION_ROUTE_SEGMENTS]: _chunkZOYKJBP5cjs.splitPath.call(void 0, route.path)
+      },
+      specificity: _chunkYTVSWXEZcjs.getRoutePatternSpecificity.call(void 0, route.path, "api")
+    };
+  }).sort(
+    (left, right) => _chunkYTVSWXEZcjs.compareRouteSpecificity.call(void 0, 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 (!_optionalChain([schemas, 'optionalAccess', _15 => _15.body]) && !_optionalChain([schemas, 'optionalAccess', _16 => _16.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 (_optionalChain([schema, 'access', _17 => _17["~standard"], 'optionalAccess', _18 => _18.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 _chunkITV4QQL2cjs.toPublicValidationIssues.call(void 0, 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 _chunkCFG4QERRcjs.cloneFarmRequest.call(void 0, request).formData())
+      };
+    }
+    const text = await _chunkCFG4QERRcjs.cloneFarmRequest.call(void 0, request).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 || _optionalChain([route, 'access', _19 => _19.__operation, 'optionalAccess', _20 => _20.bodyFormat]) || "json";
+}
+function createIntegrationRouteArgs(input) {
+  let clientPromise;
+  let ormPromise;
+  const getClient = () => {
+    _nullishCoalesce(clientPromise, () => ( (clientPromise = import("./storage.cjs").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.`
+      );
+    }
+    _nullishCoalesce(ormPromise, () => ( (ormPromise = import("./integration-orm-52GPGTHO.cjs").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 = _optionalChain([model, 'optionalAccess', _21 => _21[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 = _chunkCFG4QERRcjs.resolveFarmServerConfig.call(void 0, runtime.config.server);
+  try {
+    request = await _chunkCFG4QERRcjs.bufferFarmRequestBody.call(void 0, request, serverConfig.bodySizeLimit);
+  } catch (error) {
+    const response = _chunkCFG4QERRcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+    if (response) return response;
+    throw error;
+  }
+  request = _chunkCFG4QERRcjs.withFarmRequestClientAddress.call(void 0, 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") || _optionalChain([options, 'access', _22 => _22.currentRequest, 'optionalAccess', _23 => _23.headers, 'access', _24 => _24.get, 'call', _25 => _25("x-request-id")]) || String(Date.now());
+  const routes = normalizeIntegrationRoutes(integration.routes || []);
+  const pathSegments = _chunk6CTFVBATcjs.canonicalizeRequestPathSegments.call(void 0, pathname);
+  const method = normalizeIntegrationRequestMethod(request.method);
+  const middleware = [...integration.middleware || []];
+  const forwardedSetCookies = [];
+  for (const entry of middleware) {
+    if (_optionalChain([options, 'access', _26 => _26.ranMiddleware, 'optionalAccess', _27 => _27.has, 'call', _28 => _28(entry)])) continue;
+    const params = _chunkZOYKJBP5cjs.resolveIntegrationMiddlewareParams.call(void 0, entry, pathname, runtime.config);
+    if (!params) {
+      continue;
+    }
+    _optionalChain([options, 'access', _29 => _29.ranMiddleware, 'optionalAccess', _30 => _30.add, 'call', _31 => _31(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) ? _chunkZOYKJBP5cjs.matchPathSegments.call(void 0, 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) {
+    _optionalChain([options, 'access', _32 => _32.onForwardedCookies, 'optionalCall', _33 => _33(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 || !_chunkZOYKJBP5cjs.isFarmIntegration.call(void 0, 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.
+      _chunkCFG4QERRcjs.cloneFarmRequest.call(void 0, request),
+      {
+        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 = _chunkJYT7AN37cjs.getRequestContext.call(void 0, request, key);
+      if (requestValue !== void 0) {
+        return requestValue;
+      }
+      if (currentRequest) {
+        return _chunkJYT7AN37cjs.getRequestContext.call(void 0, currentRequest, key);
+      }
+      return void 0;
+    },
+    set(key, value, options) {
+      _chunkJYT7AN37cjs.setRequestContext.call(void 0, request, key, value, options);
+      if (currentRequest) {
+        _chunkJYT7AN37cjs.setRequestContext.call(void 0, currentRequest, key, value, options);
+      }
+    },
+    has(key) {
+      return _chunkJYT7AN37cjs.hasRequestContext.call(void 0, request, key) || !!currentRequest && _chunkJYT7AN37cjs.hasRequestContext.call(void 0, currentRequest, key);
+    },
+    delete(key) {
+      const deletedRequest = _chunkJYT7AN37cjs.deleteRequestContext.call(void 0, request, key);
+      const deletedCurrent = currentRequest ? _chunkJYT7AN37cjs.deleteRequestContext.call(void 0, currentRequest, key) : false;
+      return deletedRequest || deletedCurrent;
+    },
+    clear() {
+      _chunkJYT7AN37cjs.clearRequestContext.call(void 0, request);
+      if (currentRequest) {
+        _chunkJYT7AN37cjs.clearRequestContext.call(void 0, currentRequest);
+      }
+    },
+    snapshot(options) {
+      const merged = currentRequest ? _chunkJYT7AN37cjs.getRequestContextSnapshot.call(void 0, currentRequest, options) : /* @__PURE__ */ new Map();
+      const requestSnapshot = _chunkJYT7AN37cjs.getRequestContextSnapshot.call(void 0, 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(", ");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY; exports.FARM_INTEGRATION_SET_COOKIES_KEY = FARM_INTEGRATION_SET_COOKIES_KEY; exports.forwardIntegrationSetCookies = forwardIntegrationSetCookies; exports.defineIntegrationSchema = defineIntegrationSchema; exports.getFarmIntegrationPluginServerRuntime = getFarmIntegrationPluginServerRuntime; exports.getFarmIntegrationPluginOwner = getFarmIntegrationPluginOwner; exports.createIntegrationRoute = createIntegrationRoute; exports.integrationRoute = integrationRoute; exports.defineIntegration = defineIntegration; exports.resolveIntegrationPlugins = resolveIntegrationPlugins; exports.getIntegrationProviders = getIntegrationProviders; exports.isFarmIntegrationProviderComponentReference = isFarmIntegrationProviderComponentReference; exports.getIntegrationDocumentNavigationMatchers = getIntegrationDocumentNavigationMatchers; exports.getIntegrationSchemas = getIntegrationSchemas; exports.getRegisteredIntegrationRuntime = getRegisteredIntegrationRuntime; exports.getRegisteredIntegrations = getRegisteredIntegrations; exports.getRegisteredIntegrationSchemas = getRegisteredIntegrationSchemas; exports.matchIntegrationRoute = matchIntegrationRoute; exports.matchRegisteredIntegrationRoute = matchRegisteredIntegrationRoute; exports.getRegisteredIntegrationAPIManifest = getRegisteredIntegrationAPIManifest; exports.dispatchIntegrationRequest = dispatchIntegrationRequest; exports.dispatchIntegrationRequests = dispatchIntegrationRequests;