@farm.js/core 0.1.17 → 0.1.18

package/dist/integrations.cjs

@@ -1,4109 +1,74 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  createFarmStorage: () => createFarmStorage,
-  createStorageClient: () => createStorageClient,
-  databaseStorage: () => databaseStorage,
-  defineStorageClient: () => defineStorageClient,
-  disposeStorage: () => disposeStorage,
-  driverStorage: () => driverStorage,
-  getStorage: () => getStorage,
-  initStorage: () => initStorage,
-  libsqlStorage: () => libsqlStorage,
-  localStorage: () => localStorage,
-  memoryStorage: () => memoryStorage,
-  mongodbStorage: () => mongodbStorage,
-  mysql2Storage: () => mysql2Storage,
-  mysqlStorage: () => mysqlStorage,
-  netlifyBlobsStorage: () => netlifyBlobsStorage,
-  pgStorage: () => pgStorage,
-  pgliteStorage: () => pgliteStorage,
-  planetscaleStorage: () => planetscaleStorage,
-  postgresStorage: () => postgresStorage,
-  redisStorage: () => redisStorage,
-  resolveStorageRuntimeClient: () => resolveStorageRuntimeClient,
-  s3Storage: () => s3Storage,
-  sqliteStorage: () => sqliteStorage,
-  upstashStorage: () => upstashStorage,
-  vercelBlobStorage: () => vercelBlobStorage,
-  vercelKVStorage: () => vercelKVStorage
-});
-function createMemoryStorage() {
-  return (0, import_unstorage.createStorage)({
-    driver: (0, import_memory.default)()
-  });
-}
-function readGlobalStorage() {
-  return globalThis[GLOBAL_STORAGE_KEY];
-}
-function writeGlobalStorage(storage) {
-  globalThis[GLOBAL_STORAGE_KEY] = storage;
-  return storage;
-}
-function getActiveGlobalStorage() {
-  const existing = readGlobalStorage();
-  if (existing) {
-    return existing;
-  }
-  return writeGlobalStorage(createMemoryStorage());
-}
-function normalizeMountKey(base) {
-  return (base || "").trim().replace(/^[:/\\]+|[:/\\]+$/g, "").replace(/[\\/]+/g, ":");
-}
-function isDriverInstance(value) {
-  return !!value && typeof value === "object" && typeof value.getItem === "function" && typeof value.getKeys === "function";
-}
-function isStorageInstance(value) {
-  return !!value && typeof value === "object" && typeof value.mount === "function" && typeof value.getMount === "function";
-}
-function isStorageClient(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-storage-client" && typeof value.resolveDriver === "function" && typeof value.createStorage === "function";
-}
-function isDatabaseDriverName(name) {
-  return name in DATABASE_CONNECTORS;
-}
-function extractDriverOptions(config) {
-  const source = config;
-  const {
-    client: _client,
-    driver: _driver,
-    mounts: _mounts,
-    options,
-    tableName: _tableName,
-    ...inlineOptions
-  } = source;
-  const hasInlineOptions = Object.keys(inlineOptions).length > 0;
-  if (options && typeof options === "object" && !Array.isArray(options)) {
-    return hasInlineOptions ? { ...inlineOptions, ...options } : options;
-  }
-  if (hasInlineOptions) {
-    return inlineOptions;
-  }
-  return options;
-}
-async function loadBuiltinDriver(name, options) {
-  const modulePath = import_unstorage.builtinDrivers[name];
-  if (!modulePath) {
-    throw new Error(`Unsupported storage driver "${name}".`);
-  }
-  const module2 = await loadModule(modulePath);
-  return module2.default(options);
-}
-async function loadDatabaseDriver(config) {
-  const connectorEntry = DATABASE_CONNECTORS[config.driver];
-  const [{ createDatabase }, connectorModule, db0DriverModule] = await Promise.all([
-    loadModule("db0"),
-    connectorEntry.load(),
-    loadModule("unstorage/drivers/db0")
-  ]);
-  const database = createDatabase(connectorModule.default(extractDriverOptions(config) || {}));
-  const driver = db0DriverModule.default({
-    database,
-    tableName: config.tableName
-  });
-  return {
-    ...driver,
-    async dispose() {
-      await database.dispose();
-    }
-  };
-}
-async function resolveDriver(config) {
-  if (config && isStorageClient(config)) {
-    return config.resolveDriver();
-  }
-  const driverInput = config?.driver ?? "memory";
-  if (typeof driverInput === "function") {
-    return await driverInput();
-  }
-  if (isDriverInstance(driverInput)) {
-    return driverInput;
-  }
-  if (isDatabaseDriverName(driverInput)) {
-    return loadDatabaseDriver(config);
-  }
-  if (driverInput === "local") {
-    return loadBuiltinDriver("fs-lite", extractDriverOptions(config));
-  }
-  return loadBuiltinDriver(
-    driverInput,
-    extractDriverOptions(config)
-  );
-}
-function createStorageClientFromResolver(resolveDriver2) {
-  let driverPromise;
-  let storagePromise;
-  const ensureDriver = /* @__PURE__ */ __name(() => {
-    if (driverPromise) return driverPromise;
-    const pending = Promise.resolve().then(resolveDriver2);
-    driverPromise = pending;
-    void pending.catch(() => {
-      if (driverPromise === pending) {
-        driverPromise = void 0;
-        storagePromise = void 0;
-      }
-    });
-    return pending;
-  }, "ensureDriver");
-  const ensureStorage = /* @__PURE__ */ __name(() => {
-    if (storagePromise) return storagePromise;
-    const pending = ensureDriver().then(
-      (driver) => (0, import_unstorage.createStorage)({
-        driver
-      })
-    );
-    storagePromise = pending;
-    void pending.catch(() => {
-      if (storagePromise === pending) storagePromise = void 0;
-    });
-    return pending;
-  }, "ensureStorage");
-  const target = {
-    kind: "farm-storage-client",
-    ready: ensureStorage,
-    createStorage: ensureStorage,
-    resolveDriver: ensureDriver
-  };
-  return new Proxy(target, {
-    get(currentTarget, prop, receiver) {
-      if (prop === "then") {
-        return void 0;
-      }
-      if (Reflect.has(currentTarget, prop)) {
-        return Reflect.get(currentTarget, prop, receiver);
-      }
-      return (...args) => ensureStorage().then(async (storage) => {
-        const member = Reflect.get(storage, prop);
-        if (typeof member !== "function") {
-          return member;
-        }
-        const result = Reflect.apply(member, storage, args);
-        if (prop === "dispose") {
-          return Promise.resolve(result).finally(() => {
-            storagePromise = void 0;
-            driverPromise = void 0;
-          });
-        }
-        return result;
-      });
-    }
-  });
-}
-function defineStorageClient(resolveDriver2) {
-  return createStorageClientFromResolver(resolveDriver2);
-}
-function createStorageClient(config) {
-  return defineStorageClient(() => resolveDriver(config));
-}
-function driverStorage(driver) {
-  return defineStorageClient(() => typeof driver === "function" ? driver() : driver);
-}
-function databaseStorage(database, options = {}) {
-  return defineStorageClient(async () => {
-    const db0DriverModule = await loadModule("unstorage/drivers/db0");
-    const { dispose: _dispose, ...driver } = db0DriverModule.default({
-      database,
-      tableName: options.tableName
-    });
-    return driver;
-  });
-}
-function memoryStorage() {
-  return createStorageClient({ driver: "memory" });
-}
-function localStorage(options = {}) {
-  return createStorageClient({
-    driver: "local",
-    ...options
-  });
-}
-function sqliteStorage(options) {
-  return createStorageClient({
-    driver: "sqlite",
-    ...options
-  });
-}
-function mysqlStorage(options) {
-  return createStorageClient({
-    driver: "mysql",
-    ...options
-  });
-}
-function mysql2Storage(options) {
-  return mysqlStorage(options);
-}
-function postgresStorage(options) {
-  return createStorageClient({
-    driver: "postgres",
-    ...options
-  });
-}
-function pgStorage(options) {
-  return postgresStorage(options);
-}
-function pgliteStorage(options) {
-  return createStorageClient({
-    driver: "pglite",
-    ...options
-  });
-}
-function planetscaleStorage(options) {
-  return createStorageClient({
-    driver: "planetscale",
-    ...options
-  });
-}
-function libsqlStorage(options) {
-  return createStorageClient({
-    driver: "libsql",
-    ...options
-  });
-}
-function redisStorage(options) {
-  return createStorageClient({
-    driver: "redis",
-    ...options
-  });
-}
-function s3Storage(options) {
-  return createStorageClient({
-    driver: "s3",
-    ...options
-  });
-}
-function mongodbStorage(options) {
-  return createStorageClient({
-    driver: "mongodb",
-    ...options
-  });
-}
-function upstashStorage(options) {
-  return createStorageClient({
-    driver: "upstash",
-    ...options
-  });
-}
-function netlifyBlobsStorage(options) {
-  return createStorageClient({
-    driver: "netlify-blobs",
-    ...options
-  });
-}
-function vercelKVStorage(options) {
-  return createStorageClient({
-    driver: "vercel-kv",
-    ...options
-  });
-}
-function vercelBlobStorage(options) {
-  return createStorageClient({
-    driver: "vercel-blob",
-    ...options
-  });
-}
-async function mountNamespaces(storage, mounts) {
-  if (!mounts) {
-    return;
-  }
-  for (const [base, config] of Object.entries(mounts)) {
-    storage.mount(normalizeMountKey(base), await resolveDriver(config));
-  }
-}
-async function createFarmStorage(config = {}) {
-  if (isStorageInstance(config)) {
-    return config;
-  }
-  if (isStorageClient(config)) {
-    return config.createStorage();
-  }
-  const rootConfig = isStorageClient(config.client) ? config.client : config;
-  const storage = (0, import_unstorage.createStorage)({
-    driver: await resolveDriver(rootConfig)
-  });
-  try {
-    await mountNamespaces(storage, config.mounts);
-  } catch (error) {
-    await storage.dispose().catch(() => {
-    });
-    throw error;
-  }
-  return storage;
-}
-async function resolveStorageRuntimeClient(config) {
-  if (!config || isStorageInstance(config) || isStorageClient(config)) {
-    return void 0;
-  }
-  const client = config.client;
-  if (!client || isStorageInstance(client) || isStorageClient(client)) {
-    return void 0;
-  }
-  return typeof client === "function" ? await client() : client;
-}
-async function initStorage(config = {}) {
-  globalStorage = getActiveGlobalStorage();
-  const nextStorage = await createFarmStorage(config);
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(nextStorage);
-  if (previousStorage !== nextStorage) {
-    await previousStorage.dispose().catch(() => {
-    });
-  }
-  return globalStorage;
-}
-function getStorage(namespace) {
-  globalStorage = getActiveGlobalStorage();
-  const base = normalizeMountKey(namespace);
-  if (!base) {
-    return globalStorage;
-  }
-  const namespaced = (0, import_unstorage.prefixStorage)(globalStorage, base);
-  const store = globalStorage;
-  const prefix = `${base}:`;
-  const stripPrefix = /* @__PURE__ */ __name((key) => key.startsWith(prefix) ? key.slice(prefix.length) : key, "stripPrefix");
-  const viewUnwatchers = /* @__PURE__ */ new Set();
-  const releaseViewWatchers = /* @__PURE__ */ __name(async () => {
-    const current = [...viewUnwatchers];
-    viewUnwatchers.clear();
-    await Promise.all(current.map((unwatch) => unwatch()));
-  }, "releaseViewWatchers");
-  return {
-    ...namespaced,
-    // Scope the wipe to the namespace instead of the whole storage, and keep
-    // the caller's base so `clear("sessions")` cannot take unrelated keys with
-    // it. Dropping the argument silently widens a targeted clear into a
-    // namespace-wide delete.
-    async clear(base2, opts) {
-      const keys = await namespaced.getKeys(base2);
-      await Promise.all(keys.map((key) => namespaced.removeItem(key, opts)));
-    },
-    async watch(callback) {
-      const unwatch = await store.watch((event, key) => {
-        if (key.startsWith(prefix)) callback(event, stripPrefix(key));
-      });
-      viewUnwatchers.add(unwatch);
-      return async () => {
-        viewUnwatchers.delete(unwatch);
-        await unwatch();
-      };
-    },
-    async unwatch() {
-      await releaseViewWatchers();
-    },
-    async dispose() {
-      await releaseViewWatchers();
-    },
-    getMount(key = "") {
-      return store.getMount(prefix + key);
-    },
-    getMounts(base2 = "", options) {
-      return store.getMounts(prefix + base2, options).map((mount) => ({ ...mount, base: stripPrefix(mount.base) }));
-    }
-  };
-}
-async function disposeStorage() {
-  globalStorage = getActiveGlobalStorage();
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(createMemoryStorage());
-  await previousStorage.dispose().catch(() => {
-  });
-}
-var import_unstorage, import_memory, loadModule, DATABASE_CONNECTORS, GLOBAL_STORAGE_KEY, globalStorage;
-var init_storage = __esm({
-  "src/storage/index.ts"() {
-    "use strict";
-    import_unstorage = require("unstorage");
-    import_memory = __toESM(require("unstorage/drivers/memory"));
-    loadModule = /* @__PURE__ */ __name((specifier) => import(
-      /* @vite-ignore */
-      specifier
-    ), "loadModule");
-    DATABASE_CONNECTORS = {
-      sqlite: {
-        connector: "node-sqlite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-      },
-      "node-sqlite": {
-        connector: "node-sqlite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-      },
-      sqlite3: {
-        connector: "sqlite3",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/sqlite3"), "load")
-      },
-      "better-sqlite3": {
-        connector: "better-sqlite3",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/better-sqlite3"), "load")
-      },
-      postgres: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      postgresql: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      pg: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      mysql: {
-        connector: "mysql2",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-      },
-      mysql2: {
-        connector: "mysql2",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-      },
-      pglite: {
-        connector: "pglite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/pglite"), "load")
-      },
-      planetscale: {
-        connector: "planetscale",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/planetscale"), "load")
-      },
-      libsql: {
-        connector: "libsql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-      },
-      "libsql-node": {
-        connector: "libsql-node",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-      },
-      "libsql-http": {
-        connector: "libsql-http",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/http"), "load")
-      }
-    };
-    __name(createMemoryStorage, "createMemoryStorage");
-    GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
-    __name(readGlobalStorage, "readGlobalStorage");
-    __name(writeGlobalStorage, "writeGlobalStorage");
-    __name(getActiveGlobalStorage, "getActiveGlobalStorage");
-    globalStorage = getActiveGlobalStorage();
-    __name(normalizeMountKey, "normalizeMountKey");
-    __name(isDriverInstance, "isDriverInstance");
-    __name(isStorageInstance, "isStorageInstance");
-    __name(isStorageClient, "isStorageClient");
-    __name(isDatabaseDriverName, "isDatabaseDriverName");
-    __name(extractDriverOptions, "extractDriverOptions");
-    __name(loadBuiltinDriver, "loadBuiltinDriver");
-    __name(loadDatabaseDriver, "loadDatabaseDriver");
-    __name(resolveDriver, "resolveDriver");
-    __name(createStorageClientFromResolver, "createStorageClientFromResolver");
-    __name(defineStorageClient, "defineStorageClient");
-    __name(createStorageClient, "createStorageClient");
-    __name(driverStorage, "driverStorage");
-    __name(databaseStorage, "databaseStorage");
-    __name(memoryStorage, "memoryStorage");
-    __name(localStorage, "localStorage");
-    __name(sqliteStorage, "sqliteStorage");
-    __name(mysqlStorage, "mysqlStorage");
-    __name(mysql2Storage, "mysql2Storage");
-    __name(postgresStorage, "postgresStorage");
-    __name(pgStorage, "pgStorage");
-    __name(pgliteStorage, "pgliteStorage");
-    __name(planetscaleStorage, "planetscaleStorage");
-    __name(libsqlStorage, "libsqlStorage");
-    __name(redisStorage, "redisStorage");
-    __name(s3Storage, "s3Storage");
-    __name(mongodbStorage, "mongodbStorage");
-    __name(upstashStorage, "upstashStorage");
-    __name(netlifyBlobsStorage, "netlifyBlobsStorage");
-    __name(vercelKVStorage, "vercelKVStorage");
-    __name(vercelBlobStorage, "vercelBlobStorage");
-    __name(mountNamespaces, "mountNamespaces");
-    __name(createFarmStorage, "createFarmStorage");
-    __name(resolveStorageRuntimeClient, "resolveStorageRuntimeClient");
-    __name(initStorage, "initStorage");
-    __name(getStorage, "getStorage");
-    __name(disposeStorage, "disposeStorage");
-  }
-});
 
-// src/schema-capabilities.ts
-function assertNoSchemaListField(field, fieldPath, target) {
-  if (!field.list) {
-    return;
-  }
-  throw new Error(
-    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
-  );
-}
-var init_schema_capabilities = __esm({
-  "src/schema-capabilities.ts"() {
-    "use strict";
-    __name(assertNoSchemaListField, "assertNoSchemaListField");
-  }
-});
 
-// src/schema-primary-key.ts
-function assertSupportedPrimaryKeyField(location, field) {
-  if (!field.primaryKey || SUPPORTED_PRIMARY_KEY_TYPES.has(field.type)) {
-    return;
-  }
-  throw new Error(
-    `Schema primary-key field "${location}" uses unsupported type "${field.type}". Supported types are id, uuid, string, and integer.`
-  );
-}
-var SUPPORTED_PRIMARY_KEY_TYPES;
-var init_schema_primary_key = __esm({
-  "src/schema-primary-key.ts"() {
-    "use strict";
-    SUPPORTED_PRIMARY_KEY_TYPES = /* @__PURE__ */ new Set(["id", "uuid", "string", "integer"]);
-    __name(assertSupportedPrimaryKeyField, "assertSupportedPrimaryKeyField");
-  }
-});
 
-// src/schema-reference.ts
-function isDatabaseEnforcedReference(reference) {
-  return reference.enforced === void 0 || reference.enforced === "db";
-}
-var init_schema_reference = __esm({
-  "src/schema-reference.ts"() {
-    "use strict";
-    __name(isDatabaseEnforcedReference, "isDatabaseEnforcedReference");
-  }
-});
 
-// src/schema-resolve.ts
-function resolveSchemaModels(ownerKey, schema) {
-  const models = Object.fromEntries(
-    Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)])
-  );
-  for (const [modelKey, extension] of Object.entries(schema.extend || {})) {
-    const existing = models[modelKey];
-    models[modelKey] = {
-      ...existing || { fields: {} },
-      ...extension.name ? { name: extension.name } : {},
-      ...extension.description ? { description: extension.description } : {},
-      fields: {
-        ...existing?.fields,
-        ...extension.fields
-      },
-      constraints: [...existing?.constraints || [], ...extension.constraints || []],
-      meta: {
-        ...existing?.meta,
-        ...extension.meta
-      }
-    };
-  }
-  for (const [modelKey, override] of Object.entries(schema.override || {})) {
-    const existing = models[modelKey];
-    if (!existing) {
-      throw new Error(
-        `Schema override for "${ownerKey}.${modelKey}" is invalid because that model does not exist.`
-      );
-    }
-    const fields = {
-      ...existing.fields
-    };
-    for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {
-      const existingField = fields[fieldKey];
-      if (!existingField && !fieldOverride.type) {
-        throw new Error(
-          `Schema override for "${ownerKey}.${modelKey}.${fieldKey}" is missing a field type.`
-        );
-      }
-      fields[fieldKey] = {
-        ...existingField,
-        ...fieldOverride
-      };
-    }
-    models[modelKey] = {
-      ...existing,
-      ...override.name ? { name: override.name } : {},
-      ...override.description ? { description: override.description } : {},
-      fields,
-      constraints: override.constraints || existing.constraints,
-      meta: {
-        ...existing.meta,
-        ...override.meta
-      }
-    };
-  }
-  const resolvedModels = {};
-  for (const [modelKey, model] of Object.entries(models)) {
-    const modelName = model.name || modelKey;
-    const fieldNames = /* @__PURE__ */ new Set();
-    const resolvedFields = {};
-    for (const [fieldKey, field] of Object.entries(model.fields)) {
-      const fieldName = field.name || fieldKey;
-      assertSupportedPrimaryKeyField(`${ownerKey}.${modelKey}.${fieldKey}`, field);
-      if (fieldNames.has(fieldName)) {
-        throw new Error(
-          `Schema model "${ownerKey}.${modelKey}" contains duplicate field name "${fieldName}".`
-        );
-      }
-      fieldNames.add(fieldName);
-      resolvedFields[fieldKey] = {
-        ...field,
-        name: fieldName
-      };
-    }
-    const primaryKeyFields = Object.entries(resolvedFields).filter(([, field]) => field.primaryKey).map(([fieldKey]) => fieldKey);
-    if (primaryKeyFields.length > 1) {
-      throw new Error(
-        `Schema model "${ownerKey}.${modelKey}" defines multiple primary-key fields: ${primaryKeyFields.map((fieldKey) => `"${fieldKey}"`).join(", ")}. Composite primary keys are not supported.`
-      );
-    }
-    for (const constraint of model.constraints || []) {
-      for (const fieldKey of constraint.fields) {
-        if (!Object.prototype.hasOwnProperty.call(resolvedFields, fieldKey)) {
-          throw new Error(
-            `Schema ${constraint.type} constraint on "${ownerKey}.${modelKey}" references missing field "${fieldKey}".`
-          );
-        }
-      }
-    }
-    resolvedModels[modelKey] = {
-      ...model,
-      name: modelName,
-      fields: resolvedFields
-    };
-  }
-  for (const [modelKey, model] of Object.entries(resolvedModels)) {
-    for (const [fieldKey, field] of Object.entries(model.fields)) {
-      const reference = field.reference;
-      if (!reference || !Object.prototype.hasOwnProperty.call(resolvedModels, reference.model)) {
-        continue;
-      }
-      const referencedModel = resolvedModels[reference.model];
-      if (!Object.prototype.hasOwnProperty.call(referencedModel.fields, reference.field)) {
-        throw new Error(
-          `Schema reference "${ownerKey}.${modelKey}.${fieldKey}" targets missing field "${ownerKey}.${reference.model}.${reference.field}".`
-        );
-      }
-    }
-  }
-  return resolvedModels;
-}
-function cloneSchemaModel(model) {
-  return {
-    ...model,
-    fields: Object.fromEntries(
-      Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }])
-    ),
-    constraints: model.constraints ? [...model.constraints] : void 0,
-    meta: model.meta ? { ...model.meta } : void 0
-  };
-}
-var init_schema_resolve = __esm({
-  "src/schema-resolve.ts"() {
-    "use strict";
-    init_schema_primary_key();
-    __name(resolveSchemaModels, "resolveSchemaModels");
-    __name(cloneSchemaModel, "cloneSchemaModel");
-  }
-});
 
-// src/integration-orm.ts
-var integration_orm_exports = {};
-__export(integration_orm_exports, {
-  createIntegrationOrm: () => createIntegrationOrm,
-  farmIntegrationSchemaToOrmSchema: () => farmIntegrationSchemaToOrmSchema,
-  resolveIntegrationOrmRuntimeClient: () => resolveIntegrationOrmRuntimeClient
-});
-async function createIntegrationOrm(options) {
-  const [schema, client] = await Promise.all([
-    farmIntegrationSchemaToOrmSchema(options.schema),
-    resolveIntegrationOrmRuntimeClient(options)
-  ]);
-  if (!client) {
-    throw new Error(
-      "Schema-backed integration storage requires a runtime client at farm.config storage.client."
-    );
-  }
-  const { createOrmFromRuntime } = await import("@farming-labs/orm-runtime");
-  return createOrmFromRuntime({
-    schema,
-    client
-  });
-}
-async function resolveIntegrationOrmRuntimeClient(options) {
-  if (options.client !== void 0) {
-    return typeof options.client === "function" ? await options.client() : options.client;
-  }
-  return resolveStorageRuntimeClient(options.storage ?? options.config?.storage);
-}
-async function farmIntegrationSchemaToOrmSchema(schema) {
-  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {
-    for (const [fieldKey, fieldSchema] of Object.entries(modelSchema.fields)) {
-      assertNoSchemaListField(
-        fieldSchema,
-        `${modelKey}.${fieldKey}`,
-        "the Farm integration runtime ORM"
-      );
-    }
-  }
-  const orm = await import("@farming-labs/orm");
-  const models = {};
-  const resolvedModels = resolveSchemaModels("integration", schema);
-  for (const [modelKey, modelSchema] of Object.entries(resolvedModels)) {
-    models[modelKey] = orm.model({
-      table: modelSchema.name ?? modelKey,
-      fields: createOrmModelFields(orm, modelKey, modelSchema),
-      constraints: createOrmModelConstraints(modelSchema),
-      description: modelSchema.description
-    });
-  }
-  return orm.defineSchema(models);
-}
-function createOrmModelFields(orm, modelKey, modelSchema) {
-  return Object.fromEntries(
-    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [
-      fieldKey,
-      createOrmField(orm, modelKey, fieldKey, fieldSchema)
-    ])
-  );
-}
-function createOrmField(orm, modelKey, fieldKey, field) {
-  assertSupportedPrimaryKeyField(`integration.${modelKey}.${fieldKey}`, field);
-  let builder = createOrmFieldBuilder(orm, fieldKey, field);
-  if (!field.primaryKey && field.unique) {
-    builder = builder.unique();
-  }
-  if (!field.primaryKey && (field.nullable || field.required === false)) {
-    builder = builder.nullable();
-  }
-  if (field.default !== void 0) {
-    builder = field.type === "datetime" && field.default === "now" ? builder.defaultNow() : builder.default(field.default);
-  }
-  if (field.reference && isDatabaseEnforcedReference(field.reference)) {
-    builder = builder.references(`${field.reference.model}.${field.reference.field}`);
-  }
-  if (field.name && field.name !== fieldKey) {
-    builder = builder.map(field.name);
-  }
-  if (field.description) {
-    builder = builder.describe(field.description);
-  }
-  return builder;
-}
-function createOrmFieldBuilder(orm, fieldKey, field) {
-  if (field.primaryKey) {
-    if (field.type === "integer") {
-      return orm.id({ type: "integer" });
-    }
-    if (field.type === "string") {
-      return new orm.FieldBuilder({
-        kind: "id",
-        nullable: false,
-        unique: true,
-        idType: "string"
-      });
-    }
-    return orm.id();
-  }
-  switch (field.type) {
-    case "id":
-    case "uuid":
-      return orm.string();
-    case "string":
-    case "text":
-      return orm.string();
-    case "boolean":
-      return orm.boolean();
-    case "integer":
-      return orm.integer();
-    case "number":
-      return orm.decimal();
-    case "datetime":
-      return orm.datetime();
-    case "json":
-      return orm.json();
-    case "enum": {
-      if (!field.values?.length) {
-        throw new Error(`Integration schema enum field "${fieldKey}" must define values.`);
-      }
-      return orm.enumeration(field.values);
-    }
-    default:
-      throw new Error(
-        `Unsupported integration schema field type "${field.type}" for "${fieldKey}".`
-      );
-  }
-}
-function createOrmModelConstraints(modelSchema) {
-  const unique = [];
-  const indexes = [];
-  for (const constraint of modelSchema.constraints ?? []) {
-    if (!constraint.fields.length) {
-      continue;
-    }
-    const fields = constraint.fields;
-    if (constraint.type === "unique") {
-      unique.push(fields);
-    } else {
-      indexes.push(fields);
-    }
-  }
-  return {
-    unique,
-    indexes
-  };
-}
-var init_integration_orm = __esm({
-  "src/integration-orm.ts"() {
-    "use strict";
-    init_schema_capabilities();
-    init_schema_primary_key();
-    init_schema_reference();
-    init_schema_resolve();
-    init_storage();
-    __name(createIntegrationOrm, "createIntegrationOrm");
-    __name(resolveIntegrationOrmRuntimeClient, "resolveIntegrationOrmRuntimeClient");
-    __name(farmIntegrationSchemaToOrmSchema, "farmIntegrationSchemaToOrmSchema");
-    __name(createOrmModelFields, "createOrmModelFields");
-    __name(createOrmField, "createOrmField");
-    __name(createOrmFieldBuilder, "createOrmFieldBuilder");
-    __name(createOrmModelConstraints, "createOrmModelConstraints");
-  }
-});
 
-// src/integrations.ts
-var integrations_exports = {};
-__export(integrations_exports, {
-  FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY: () => FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY,
-  FARM_INTEGRATION_SET_COOKIES_KEY: () => FARM_INTEGRATION_SET_COOKIES_KEY,
-  api: () => api,
-  createIntegrationRoute: () => createIntegrationRoute,
-  defineIntegration: () => defineIntegration,
-  defineIntegrationAPI: () => defineIntegrationAPI,
-  defineIntegrationAPIOperation: () => defineIntegrationAPIOperation,
-  defineIntegrationSchema: () => defineIntegrationSchema,
-  describeIntegrationOriginRejection: () => describeIntegrationOriginRejection,
-  dispatchIntegrationRequest: () => dispatchIntegrationRequest,
-  dispatchIntegrationRequests: () => dispatchIntegrationRequests,
-  forwardIntegrationSetCookies: () => forwardIntegrationSetCookies,
-  getFarmIntegrationPluginOwner: () => getFarmIntegrationPluginOwner,
-  getFarmIntegrationPluginServerRuntime: () => getFarmIntegrationPluginServerRuntime,
-  getIntegrationDocumentNavigationMatchers: () => getIntegrationDocumentNavigationMatchers,
-  getIntegrationProviders: () => getIntegrationProviders,
-  getIntegrationSchemas: () => getIntegrationSchemas,
-  getRegisteredIntegrationAPIManifest: () => getRegisteredIntegrationAPIManifest,
-  getRegisteredIntegrationRuntime: () => getRegisteredIntegrationRuntime,
-  getRegisteredIntegrationSchemas: () => getRegisteredIntegrationSchemas,
-  getRegisteredIntegrations: () => getRegisteredIntegrations,
-  integrationRoute: () => integrationRoute,
-  isFarmIntegration: () => isFarmIntegration,
-  isFarmIntegrationProviderComponentReference: () => isFarmIntegrationProviderComponentReference,
-  matchIntegrationRoute: () => matchIntegrationRoute,
-  matchRegisteredIntegrationRoute: () => matchRegisteredIntegrationRoute,
-  resolveIntegrationAllowedOrigins: () => resolveIntegrationAllowedOrigins,
-  resolveIntegrationPlugins: () => resolveIntegrationPlugins,
-  validateIntegrationRequestOrigin: () => validateIntegrationRequestOrigin
-});
-module.exports = __toCommonJS(integrations_exports);
 
-// src/routing/specificity.ts
-var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AmbiguousRouteError";
-  }
-};
-__name(_AmbiguousRouteError, "AmbiguousRouteError");
-var AmbiguousRouteError = _AmbiguousRouteError;
-var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "NonTerminalCatchAllRouteError";
-  }
-};
-__name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "DuplicateRouteParameterError";
-  }
-};
-__name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-var DuplicateRouteParameterError = _DuplicateRouteParameterError;
-var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "ReservedRouteParameterError";
-  }
-};
-__name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-var ReservedRouteParameterError = _ReservedRouteParameterError;
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-var SEGMENT_RANK = {
-  static: 4,
-  dynamic: 3,
-  "catch-all": 1,
-  "optional-catch-all": 0
-};
-var ROUTE_END_RANK = 2;
-function compareRouteSpecificity(left, right) {
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
-    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
-    if (leftRank !== rightRank) return rightRank - leftRank;
-  }
-  return 0;
-}
-__name(compareRouteSpecificity, "compareRouteSpecificity");
-var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
-function assertUniqueRouteParameters(pattern, syntax = "page") {
-  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
-  const names = /* @__PURE__ */ new Set();
-  for (const segment of splitRoutePattern(pattern, syntax)) {
-    const match = parameterPattern.exec(segment);
-    const name = match?.slice(1).find(Boolean);
-    if (!name) continue;
-    if (RESERVED_PARAMETER_NAMES.has(name)) {
-      throw new ReservedRouteParameterError(
-        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
-      );
-    }
-    if (names.has(name)) {
-      throw new DuplicateRouteParameterError(
-        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
-      );
-    }
-    names.add(name);
-  }
-}
-__name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-__name(splitRoutePattern, "splitRoutePattern");
-function assertTerminalCatchAll(pattern, syntax = "page") {
-  const segments = splitRoutePattern(pattern, syntax);
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const catchAllPattern = new RegExp(
-    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
-  );
-  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
-  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
-    throw new NonTerminalCatchAllRouteError(
-      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
-    );
-  }
-}
-__name(assertTerminalCatchAll, "assertTerminalCatchAll");
-function getRoutePatternSpecificity(pattern, syntax = "page") {
-  assertTerminalCatchAll(pattern, syntax);
-  return splitRoutePattern(pattern, syntax).map(
-    (segment) => getPatternSegmentSpecificity(segment, syntax)
-  );
-}
-__name(getRoutePatternSpecificity, "getRoutePatternSpecificity");
-function getPatternSegmentSpecificity(segment, syntax) {
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const supportsColonAndStar = syntax === "router";
-  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
-    return "optional-catch-all";
-  }
-  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
-    return "catch-all";
-  }
-  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
-    return "dynamic";
-  }
-  return "static";
-}
-__name(getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
 
-// src/utils/decode.ts
-function decodeRouteSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodeRouteSegment, "decodeRouteSegment");
-function canonicalizeRequestPathSegments(pathname) {
-  const segments = pathname.split("/").filter(Boolean);
-  if (!pathname.includes("%")) return segments;
-  return segments.map(decodeRouteSegment);
-}
-__name(canonicalizeRequestPathSegments, "canonicalizeRequestPathSegments");
-function canonicalizeRequestPathname(pathname) {
-  const encoded = pathname.includes("%");
-  if (!encoded && !pathname.includes("//")) return pathname;
-  const collapsed = pathname.replace(/\/{2,}/g, "/");
-  if (!encoded) return collapsed;
-  return collapsed.split("/").map((segment) => {
-    const decoded = decodeRouteSegment(segment);
-    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
-  }).join("/");
-}
-__name(canonicalizeRequestPathname, "canonicalizeRequestPathname");
 
-// src/plugins/route-pattern.ts
-function validateConfigRouteSource(source, field = "Config route source") {
-  if (typeof source !== "string" || source.length === 0) {
-    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
-  }
-  if (source.trim() !== source) {
-    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
-  }
-  if (!source.startsWith("/")) {
-    throw new Error(`${field} must start with "/".`);
-  }
-  if (source.includes("?") || source.includes("#")) {
-    throw new Error(`${field} must be a pathname without a query string or hash.`);
-  }
-  if (source.includes("\\") || Array.from(source).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  })) {
-    throw new Error(`${field} cannot contain backslashes or control characters.`);
-  }
-  assertBrowserStableRoutePath(source);
-  return source;
-}
-__name(validateConfigRouteSource, "validateConfigRouteSource");
 
-// src/schema.ts
-function defineSchema(schema) {
-  return schema;
-}
-__name(defineSchema, "defineSchema");
 
-// src/request-origin.ts
-function getRequestSourceOrigin(request) {
-  const origin = request.headers.get("origin")?.trim();
-  if (origin) {
-    return parseSourceOrigin(origin);
-  }
-  const referer = request.headers.get("referer")?.trim();
-  if (referer) {
-    return parseSourceOrigin(referer);
-  }
-  return { ok: true, origin: null };
-}
-__name(getRequestSourceOrigin, "getRequestSourceOrigin");
-function parseSourceOrigin(value) {
-  if (value === "null") {
-    return { ok: false, reason: "opaque-origin" };
-  }
-  try {
-    const parsed = new URL(value);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      return { ok: false, reason: "invalid-origin" };
-    }
-    return { ok: true, origin: parsed.origin };
-  } catch {
-    return { ok: false, reason: "invalid-origin" };
-  }
-}
-__name(parseSourceOrigin, "parseSourceOrigin");
-function matchesHostHeader(sourceOrigin, request) {
-  const host = request.headers.get("host")?.trim().toLowerCase();
-  if (!host) return false;
-  try {
-    const source = new URL(sourceOrigin);
-    const target = new URL(request.url);
-    return source.protocol === target.protocol && source.host.toLowerCase() === host;
-  } catch {
-    return false;
-  }
-}
-__name(matchesHostHeader, "matchesHostHeader");
-function matchesAllowedOrigin(sourceOrigin, pattern) {
-  const source = new URL(sourceOrigin);
-  if (!pattern.includes("*")) {
-    return pattern.includes("://") ? source.origin === pattern : source.host === pattern;
-  }
-  const schemeEnd = pattern.indexOf("://");
-  const scheme = schemeEnd === -1 ? null : pattern.slice(0, schemeEnd + 1);
-  const hostPattern = pattern.slice(schemeEnd === -1 ? 0 : schemeEnd + 3);
-  const [wildcardHost, port] = splitHostAndPort(hostPattern);
-  const baseHost = wildcardHost.slice(2);
-  if (scheme && source.protocol !== scheme) return false;
-  if (port && getEffectivePort(source) !== port) return false;
-  if (!port && source.port) return false;
-  return source.hostname.endsWith(`.${baseHost}`) && source.hostname !== baseHost;
-}
-__name(matchesAllowedOrigin, "matchesAllowedOrigin");
-function normalizeAllowedOriginPattern(value, label) {
-  const pattern = value.trim().toLowerCase();
-  if (!pattern) {
-    throw new TypeError(`${label} cannot contain empty values`);
-  }
-  if (pattern.includes("*")) {
-    if (!/^(?:https?:\/\/)?\*\.[a-z0-9.-]+(?::\d+)?$/.test(pattern)) {
-      throw new TypeError(`Invalid ${label} pattern: ${JSON.stringify(value)}`);
-    }
-    return pattern;
-  }
-  if (pattern.includes("://")) {
-    let parsed;
-    try {
-      parsed = new URL(pattern);
-    } catch {
-      throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
-      throw new TypeError(`${label} must contain origins without paths: ${JSON.stringify(value)}`);
-    }
-    return parsed.origin;
-  }
-  if (/[/@?#]/.test(pattern)) {
-    throw new TypeError(`${label} must contain origins or hosts: ${JSON.stringify(value)}`);
-  }
-  try {
-    return new URL(`http://${pattern}`).host;
-  } catch {
-    throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
-  }
-}
-__name(normalizeAllowedOriginPattern, "normalizeAllowedOriginPattern");
-function splitHostAndPort(value) {
-  const separator = value.lastIndexOf(":");
-  if (separator === -1) return [value, null];
-  return [value.slice(0, separator), value.slice(separator + 1)];
-}
-__name(splitHostAndPort, "splitHostAndPort");
-function getEffectivePort(url) {
-  if (url.port) return url.port;
-  if (url.protocol === "https:") return "443";
-  if (url.protocol === "http:") return "80";
-  return "";
-}
-__name(getEffectivePort, "getEffectivePort");
 
-// src/integration-request-security.ts
-function resolveIntegrationAllowedOrigins(values, label) {
-  return Object.freeze((values ?? []).map((value) => normalizeAllowedOriginPattern(value, label)));
-}
-__name(resolveIntegrationAllowedOrigins, "resolveIntegrationAllowedOrigins");
-function validateIntegrationRequestOrigin(request, policy = {}) {
-  const allowedOrigins = policy.allowedOrigins ?? [];
-  const requireOriginMetadata = policy.requireOriginMetadata ?? true;
-  const fetchSite = request.headers.get("sec-fetch-site")?.trim().toLowerCase();
-  const source = getRequestSourceOrigin(request);
-  if (!source.ok) {
-    return { ok: false, reason: source.reason };
-  }
-  if (source.origin === null) {
-    if (fetchSite === "same-origin") {
-      return { ok: true };
-    }
-    if (requireOriginMetadata) {
-      return { ok: false, reason: fetchSite === "cross-site" ? "cross-site" : "missing-origin" };
-    }
-    return fetchSite === "cross-site" ? { ok: false, reason: "cross-site" } : { ok: true };
-  }
-  const requestUrl = new URL(request.url);
-  const matchesConfiguredOrigin = allowedOrigins.some(
-    (pattern) => matchesAllowedOrigin(source.origin, pattern)
-  );
-  const matchesRequest = source.origin === requestUrl.origin || matchesHostHeader(source.origin, request);
-  if (!matchesRequest && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  return { ok: true };
-}
-__name(validateIntegrationRequestOrigin, "validateIntegrationRequestOrigin");
-function describeIntegrationOriginRejection(reason) {
-  switch (reason) {
-    case "missing-origin":
-      return "Request is missing same-origin metadata.";
-    case "opaque-origin":
-      return "Opaque origins are not allowed.";
-    case "invalid-origin":
-      return "Invalid request origin.";
-    case "cross-site":
-      return "Cross-site request was rejected.";
-  }
-}
-__name(describeIntegrationOriginRejection, "describeIntegrationOriginRejection");
 
-// src/integration-api.ts
-function defineIntegrationAPIOperation(operation2) {
-  return {
-    kind: "farm-integration-api-operation",
-    ...operation2
-  };
-}
-__name(defineIntegrationAPIOperation, "defineIntegrationAPIOperation");
-function defineIntegrationAPI(api2) {
-  return api2;
-}
-__name(defineIntegrationAPI, "defineIntegrationAPI");
-function operation(method, pathOrOptions, maybeOptions = {}) {
-  const hasExplicitPath = typeof pathOrOptions === "string";
-  const path = hasExplicitPath ? pathOrOptions : "";
-  const options = hasExplicitPath ? maybeOptions : {
-    ...maybeOptions,
-    ...pathOrOptions
-  };
-  return defineIntegrationAPIOperation({
-    path,
-    method,
-    __pathless: !hasExplicitPath,
-    ...options
-  });
-}
-__name(operation, "operation");
-function get(pathOrOptions, maybeOptions = {}) {
-  return operation("GET", pathOrOptions, maybeOptions);
-}
-__name(get, "get");
-function isOperation(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
-}
-__name(isOperation, "isOperation");
-function bindRoutePath(path, api2) {
-  const entries = Object.entries(api2).map(([key, value]) => {
-    if (isOperation(value)) {
-      return [
-        key,
-        {
-          ...value,
-          path,
-          __pathless: false
-        }
-      ];
-    }
-    if (value && typeof value === "object") {
-      return [key, bindRoutePath(path, value)];
-    }
-    return [key, value];
-  });
-  return Object.fromEntries(entries);
-}
-__name(bindRoutePath, "bindRoutePath");
-function route(path, definitionOrOperation, ...operations) {
-  if (isOperation(definitionOrOperation)) {
-    const allOperations = [definitionOrOperation, ...operations];
-    return Object.fromEntries(
-      allOperations.map((operation2) => [
-        operation2.method.toLowerCase(),
-        {
-          ...operation2,
-          path,
-          __pathless: false
-        }
-      ])
-    );
-  }
-  return bindRoutePath(path, definitionOrOperation);
-}
-__name(route, "route");
-function normalizeRouteSegment(segment) {
-  if (!segment) {
-    return "index";
-  }
-  if (segment.startsWith("[...") && segment.endsWith("]")) {
-    return segment.slice(4, -1) || "index";
-  }
-  if (segment.startsWith("[") && segment.endsWith("]")) {
-    return segment.slice(1, -1) || "index";
-  }
-  const matcherIndex = segment.indexOf("(");
-  if (matcherIndex > 0) {
-    return segment.slice(0, matcherIndex);
-  }
-  return camelCaseRouteSegment(segment);
-}
-__name(normalizeRouteSegment, "normalizeRouteSegment");
-function camelCaseRouteSegment(segment) {
-  return segment.replace(/-([a-zA-Z0-9])/g, (_match, value) => value.toUpperCase());
-}
-__name(camelCaseRouteSegment, "camelCaseRouteSegment");
-function getRouteClientSegments(path) {
-  const segments = path.split("/").filter(Boolean);
-  if (segments.length === 0) {
-    return ["index"];
-  }
-  const stripped = segments[0] === "api" && segments.length > 2 ? segments.slice(2) : segments.length > 1 ? segments.slice(1) : [segments[segments.length - 1]];
-  return stripped.map(normalizeRouteSegment).filter(Boolean);
-}
-__name(getRouteClientSegments, "getRouteClientSegments");
-function setRouteOperation(target, pathSegments, operation2) {
-  const [head, ...tail] = pathSegments;
-  if (!head) {
-    return;
-  }
-  if (tail.length === 0) {
-    const leaf = target[head] || {};
-    leaf[operation2.method.toLowerCase()] = {
-      ...operation2,
-      path: operation2.path,
-      __pathless: false
-    };
-    target[head] = leaf;
-    return;
-  }
-  const branch = target[head] || {};
-  target[head] = branch;
-  setRouteOperation(branch, tail, operation2);
-}
-__name(setRouteOperation, "setRouteOperation");
-function fromRoutes(routes) {
-  const definition = {};
-  for (const route2 of routes) {
-    if (!isOperation(route2.__operation)) {
-      continue;
-    }
-    setRouteOperation(definition, getRouteClientSegments(route2.path), {
-      ...route2.__operation,
-      path: route2.path,
-      __pathless: false
-    });
-  }
-  return definition;
-}
-__name(fromRoutes, "fromRoutes");
-var api = {
-  get,
-  route,
-  fromRoutes,
-  query(pathOrOptions, maybeOptions = {}) {
-    return operation("QUERY", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  post(pathOrOptions, maybeOptions = {}) {
-    return operation("POST", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  put(pathOrOptions, maybeOptions = {}) {
-    return operation("PUT", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  patch(pathOrOptions, maybeOptions = {}) {
-    return operation("PATCH", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  delete(pathOrOptions, maybeOptions = {}) {
-    return operation("DELETE", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  options(pathOrOptions, maybeOptions = {}) {
-    return operation(
-      "OPTIONS",
-      pathOrOptions,
-      maybeOptions
-    );
-  },
-  head(pathOrOptions, maybeOptions = {}) {
-    return operation(
-      "HEAD",
-      pathOrOptions,
-      maybeOptions
-    );
-  },
-  form: {
-    query(pathOrOptions, maybeOptions = {}) {
-      return operation("QUERY", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    post(pathOrOptions, maybeOptions = {}) {
-      return operation("POST", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    put(pathOrOptions, maybeOptions = {}) {
-      return operation("PUT", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    patch(pathOrOptions, maybeOptions = {}) {
-      return operation("PATCH", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    delete(pathOrOptions, maybeOptions = {}) {
-      return operation("DELETE", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    }
-  }
-};
 
-// src/plugin-integration-context.ts
-var FARM_PLUGIN_INTEGRATION_CONTEXT = /* @__PURE__ */ Symbol.for("@farm.js/core/plugin-integration-context");
-function setFarmPluginIntegrationContext(plugin, integration) {
-  Object.defineProperty(plugin, FARM_PLUGIN_INTEGRATION_CONTEXT, {
-    value: integration
-  });
-}
-__name(setFarmPluginIntegrationContext, "setFarmPluginIntegrationContext");
 
-// src/request-context.ts
-var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
-function getRequestContextStore() {
-  const globalState = globalThis;
-  if (!globalState[REQUEST_CONTEXT_STORE_KEY]) {
-    globalState[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
-  }
-  return globalState[REQUEST_CONTEXT_STORE_KEY];
-}
-__name(getRequestContextStore, "getRequestContextStore");
-function getBucket(target) {
-  const requestContextStore = getRequestContextStore();
-  let bucket = requestContextStore.get(target);
-  if (!bucket) {
-    bucket = {
-      privateData: /* @__PURE__ */ new Map(),
-      exposedData: /* @__PURE__ */ new Map()
-    };
-    requestContextStore.set(target, bucket);
-  }
-  return bucket;
-}
-__name(getBucket, "getBucket");
-function setRequestContext(target, key, value, options = {}) {
-  const bucket = getBucket(target);
-  bucket.privateData.set(key, value);
-  if (options.exposeToPage) {
-    bucket.exposedData.set(key, value);
-  }
-}
-__name(setRequestContext, "setRequestContext");
-function getRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return bucket?.privateData.get(key);
-}
-__name(getRequestContext, "getRequestContext");
-function hasRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return bucket?.privateData.has(key) ?? false;
-}
-__name(hasRequestContext, "hasRequestContext");
-function deleteRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return false;
-  const removedPrivate = bucket.privateData.delete(key);
-  bucket.exposedData.delete(key);
-  return removedPrivate;
-}
-__name(deleteRequestContext, "deleteRequestContext");
-function clearRequestContext(target) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return;
-  bucket.privateData.clear();
-  bucket.exposedData.clear();
-}
-__name(clearRequestContext, "clearRequestContext");
-function getRequestContextSnapshot(target, options = {}) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return /* @__PURE__ */ new Map();
-  if (options.exposedOnly) {
-    return new Map(bucket.exposedData);
-  }
-  return new Map(bucket.privateData);
-}
-__name(getRequestContextSnapshot, "getRequestContextSnapshot");
-function copyRequestContext(source, target) {
-  const bucket = getRequestContextStore().get(source);
-  if (!bucket || source === target) return;
-  for (const [key, value] of bucket.privateData) {
-    setRequestContext(target, key, value, { exposeToPage: bucket.exposedData.has(key) });
-  }
-}
-__name(copyRequestContext, "copyRequestContext");
 
-// src/server/response.ts
-function watchResponseEvent(res, events) {
-  if (typeof res.once !== "function" || typeof res.removeListener !== "function") {
-    return null;
-  }
-  let settled = false;
-  const listeners = events.map(([event, value]) => {
-    const listener = /* @__PURE__ */ __name(() => {
-      if (settled) return;
-      settled = true;
-      dispose();
-      resolvePromise(value);
-    }, "listener");
-    return { event, listener };
-  });
-  let resolvePromise;
-  const promise = new Promise((resolve) => {
-    resolvePromise = resolve;
-    for (const { event, listener } of listeners) {
-      res.once(event, listener);
-    }
-  });
-  const dispose = /* @__PURE__ */ __name(() => {
-    for (const { event, listener } of listeners) {
-      res.removeListener(event, listener);
-    }
-  }, "dispose");
-  return { promise, dispose };
-}
-__name(watchResponseEvent, "watchResponseEvent");
-async function waitForWritable(res) {
-  if (res.writableEnded || res.destroyed) {
-    return false;
-  }
-  const watcher = watchResponseEvent(res, [
-    ["drain", true],
-    ["close", false],
-    ["error", false]
-  ]);
-  if (!watcher) {
-    return false;
-  }
-  try {
-    return await watcher.promise;
-  } finally {
-    watcher.dispose();
-  }
-}
-__name(waitForWritable, "waitForWritable");
-function splitSetCookieHeader(value) {
-  const cookies = [];
-  let start = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    if (value[index] !== ",") continue;
-    let next = index + 1;
-    while (value[next] === " " || value[next] === "	") next += 1;
-    const equals = value.indexOf("=", next);
-    if (equals === -1) continue;
-    const separator = value.slice(next, equals);
-    if (separator.length === 0 || /[;,\s]/.test(separator)) continue;
-    cookies.push(value.slice(start, index).trim());
-    start = next;
-    index = next - 1;
-  }
-  cookies.push(value.slice(start).trim());
-  return cookies.filter(Boolean);
-}
-__name(splitSetCookieHeader, "splitSetCookieHeader");
-function applyWebResponseHeaders(res, headers, options = {}) {
-  const responseHeaders = headers;
-  const rawSetCookies = responseHeaders.raw?.()["set-cookie"];
-  const setCookies = responseHeaders.getSetCookie?.() || rawSetCookies || [];
-  const existing = options.appendSetCookie && typeof res.getHeader === "function" ? res.getHeader("Set-Cookie") : void 0;
-  const existingCookies = Array.isArray(existing) ? existing.map(String) : existing === void 0 ? [] : [String(existing)];
-  let fallbackSetCookie = "";
-  headers.forEach((value, key) => {
-    if (key.toLowerCase() === "set-cookie") {
-      fallbackSetCookie = value;
-      return;
-    }
-    res.setHeader(key, value);
-  });
-  const cookies = setCookies.length > 0 ? setCookies : fallbackSetCookie ? splitSetCookieHeader(fallbackSetCookie) : [];
-  if (cookies.length > 0) {
-    res.setHeader("Set-Cookie", [...existingCookies, ...cookies]);
-  }
-}
-__name(applyWebResponseHeaders, "applyWebResponseHeaders");
-async function sendWebResponse(res, response) {
-  res.statusCode = response.status;
-  applyWebResponseHeaders(res, response.headers, { appendSetCookie: true });
-  if (!response.body) {
-    res.end();
-    return;
-  }
-  if (typeof res.write !== "function") {
-    const body = await response.arrayBuffer();
-    res.end(Buffer.from(body));
-    return;
-  }
-  const reader = response.body.getReader();
-  const disconnectWatcher = watchResponseEvent(res, [
-    ["close", true],
-    ["error", true]
-  ]);
-  try {
-    while (true) {
-      if (res.destroyed) {
-        void reader.cancel().catch(() => {
-        });
-        return;
-      }
-      const read = reader.read().then((result) => ({ type: "read", result }));
-      const next = disconnectWatcher ? await Promise.race([
-        read,
-        disconnectWatcher.promise.then(() => ({ type: "disconnect" }))
-      ]) : await read;
-      if (next.type === "disconnect") {
-        void reader.cancel().catch(() => {
-        });
-        return;
-      }
-      const { done, value } = next.result;
-      if (done) {
-        break;
-      }
-      if (!value || value.byteLength === 0) {
-        continue;
-      }
-      if (!res.write(value)) {
-        if (!await waitForWritable(res)) {
-          void reader.cancel().catch(() => {
-          });
-          return;
-        }
-      }
-    }
-    res.end();
-  } catch (error) {
-    void reader.cancel(error).catch(() => {
-    });
-    if (!res.writableEnded) {
-      const responseError = error instanceof Error ? error : new Error(String(error));
-      if (typeof res.destroy === "function") {
-        res.destroy(responseError);
-      } else {
-        res.end();
-      }
-    }
-    throw error;
-  } finally {
-    disconnectWatcher?.dispose();
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-__name(sendWebResponse, "sendWebResponse");
 
-// src/server-http.ts
-var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
-var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
-var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
-var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
-var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
-var MAX_FARM_SERVER_TIMEOUT = 2147483647;
-var _FarmRequestBodyError = class _FarmRequestBodyError extends Error {
-  constructor(code, status, message) {
-    super(message);
-    this.name = "FarmRequestBodyError";
-    this.code = code;
-    this.status = status;
-  }
-};
-__name(_FarmRequestBodyError, "FarmRequestBodyError");
-var FarmRequestBodyError = _FarmRequestBodyError;
-function resolveFarmServerConfig(config) {
-  const headersTimeout = parseFarmServerDuration(
-    config?.headersTimeout ?? DEFAULT_FARM_SERVER_HEADERS_TIMEOUT,
-    "server.headersTimeout"
-  );
-  const requestTimeout = parseFarmServerDuration(
-    config?.requestTimeout ?? DEFAULT_FARM_SERVER_REQUEST_TIMEOUT,
-    "server.requestTimeout"
-  );
-  if (headersTimeout > requestTimeout) {
-    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
-  }
-  return Object.freeze({
-    bodySizeLimit: parseBodySizeLimit(
-      config?.bodySizeLimit ?? DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
-      "server.bodySizeLimit"
-    ),
-    trustProxy: config?.trustProxy === true,
-    headersTimeout,
-    requestTimeout,
-    keepAliveTimeout: parseFarmServerDuration(
-      config?.keepAliveTimeout ?? DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT,
-      "server.keepAliveTimeout"
-    ),
-    gracefulShutdownTimeout: parseFarmServerDuration(
-      config?.gracefulShutdownTimeout ?? DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT,
-      "server.gracefulShutdownTimeout"
-    ),
-    health: resolveFarmServerHealthConfig(config?.health)
-  });
-}
-__name(resolveFarmServerConfig, "resolveFarmServerConfig");
-function parseFarmServerDuration(value, optionName = "duration") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    if (value > MAX_FARM_SERVER_TIMEOUT) {
-      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2];
-  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
-  const milliseconds = Math.floor(amount * multiplier);
-  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
-    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-  }
-  return milliseconds;
-}
-__name(parseFarmServerDuration, "parseFarmServerDuration");
-function resolveFarmServerHealthConfig(config) {
-  if (config === false || config && "enabled" in config && config.enabled === false) {
-    return Object.freeze({
-      enabled: false,
-      livenessPath: "/_farm/health/live",
-      readinessPath: "/_farm/health/ready"
-    });
-  }
-  const livenessPath = normalizeHealthPath(
-    config?.livenessPath ?? "/_farm/health/live",
-    "server.health.livenessPath"
-  );
-  const readinessPath = normalizeHealthPath(
-    config?.readinessPath ?? "/_farm/health/ready",
-    "server.health.readinessPath"
-  );
-  if (livenessPath === readinessPath) {
-    throw new TypeError("server.health livenessPath and readinessPath must be different");
-  }
-  return Object.freeze({ enabled: true, livenessPath, readinessPath });
-}
-__name(resolveFarmServerHealthConfig, "resolveFarmServerHealthConfig");
-function normalizeHealthPath(value, optionName) {
-  const path = value.trim();
-  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
-    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
-  }
-  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
-  assertBrowserStableRoutePath(normalized);
-  return normalized;
-}
-__name(normalizeHealthPath, "normalizeHealthPath");
-function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2] ?? "b";
-  const multiplier = {
-    b: 1,
-    kb: 1e3,
-    mb: 1e6,
-    gb: 1e9,
-    kib: 1024,
-    mib: 1048576,
-    gib: 1073741824
-  };
-  const bytes = Math.floor(amount * multiplier[unit]);
-  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  return bytes;
-}
-__name(parseBodySizeLimit, "parseBodySizeLimit");
-async function bufferFarmRequestBody(request, limit) {
-  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
-    return request;
-  }
-  const bytes = await readFarmRequestBody(request, limit);
-  const body = new Uint8Array(bytes.byteLength);
-  body.set(bytes);
-  const buffered = new Request(request, {
-    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
-    body: body.buffer
-  });
-  copyRequestContext(request, buffered);
-  return buffered;
-}
-__name(bufferFarmRequestBody, "bufferFarmRequestBody");
-async function readFarmRequestBody(request, limit) {
-  try {
-    validateContentLength(request.headers.get("content-length"), limit);
-  } catch (error) {
-    void request.body?.cancel(error).catch(() => {
-    });
-    throw error;
-  }
-  throwIfAborted(request.signal);
-  if (!request.body) return new Uint8Array();
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  const cancelBodyRead = /* @__PURE__ */ __name(() => {
-    void reader.cancel(request.signal.reason).catch(() => {
-    });
-  }, "cancelBodyRead");
-  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
-  try {
-    while (true) {
-      throwIfAborted(request.signal);
-      const { done, value } = await reader.read();
-      throwIfAborted(request.signal);
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-        void reader.cancel(error).catch(() => {
-        });
-        throw error;
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    if (request.signal.aborted) throwIfAborted(request.signal);
-    throw error;
-  } finally {
-    request.signal.removeEventListener("abort", cancelBodyRead);
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-__name(readFarmRequestBody, "readFarmRequestBody");
-async function readNodeRequestBody(request, limit) {
-  const rawContentLength = request.headers["content-length"];
-  const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
-  try {
-    validateContentLength(contentLength, limit);
-  } catch (error) {
-    request.resume?.();
-    throw error;
-  }
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    let total = 0;
-    let settled = false;
-    const cleanup = /* @__PURE__ */ __name(() => {
-      request.removeListener?.("data", onData);
-      request.removeListener?.("end", onEnd);
-      request.removeListener?.("error", onError);
-    }, "cleanup");
-    const rejectOnce = /* @__PURE__ */ __name((error) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      request.resume?.();
-      reject(error);
-    }, "rejectOnce");
-    const onData = /* @__PURE__ */ __name((chunk) => {
-      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      total += bytes.byteLength;
-      if (total > limit) {
-        rejectOnce(new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large"));
-        return;
-      }
-      chunks.push(bytes);
-    }, "onData");
-    const onEnd = /* @__PURE__ */ __name(() => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(Buffer.concat(chunks, total));
-    }, "onEnd");
-    const onError = /* @__PURE__ */ __name((error) => rejectOnce(error), "onError");
-    request.on("data", onData);
-    request.on("end", onEnd);
-    request.on("error", onError);
-  });
-}
-__name(readNodeRequestBody, "readNodeRequestBody");
-function createFarmRequestBodyErrorResponse(error) {
-  if (!(error instanceof FarmRequestBodyError)) return null;
-  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
-    status: error.status,
-    headers: {
-      "cache-control": "no-store",
-      "content-type": "text/plain; charset=utf-8",
-      "x-content-type-options": "nosniff"
-    }
-  });
-}
-__name(createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
-function validateContentLength(value, limit) {
-  const contentLength = value?.trim();
-  if (!contentLength) return;
-  if (!/^\d+$/.test(contentLength)) {
-    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
-  }
-  if (Number(contentLength) > limit) {
-    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-  }
-}
-__name(validateContentLength, "validateContentLength");
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-__name(throwIfAborted, "throwIfAborted");
 
-// src/integrations.ts
-var FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
-var FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
-function forwardIntegrationSetCookies(context, cookies) {
-  if (cookies.length === 0) return;
-  const existing = context.req.get(FARM_INTEGRATION_SET_COOKIES_KEY) ?? [];
-  context.req.set(FARM_INTEGRATION_SET_COOKIES_KEY, [...existing, ...cookies]);
-}
-__name(forwardIntegrationSetCookies, "forwardIntegrationSetCookies");
-function takeForwardedIntegrationSetCookies(context) {
-  const cookies = context.req.get(FARM_INTEGRATION_SET_COOKIES_KEY);
-  if (cookies && cookies.length > 0) {
-    context.req.delete(FARM_INTEGRATION_SET_COOKIES_KEY);
-    return cookies;
-  }
-  if (cookies) {
-    context.req.delete(FARM_INTEGRATION_SET_COOKIES_KEY);
-  }
-  return [];
-}
-__name(takeForwardedIntegrationSetCookies, "takeForwardedIntegrationSetCookies");
-function appendIntegrationForwardedCookies(response, cookies) {
-  if (cookies.length === 0) return response;
-  const headers = new Headers(response.headers);
-  for (const cookie of cookies) {
-    headers.append("set-cookie", cookie);
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(appendIntegrationForwardedCookies, "appendIntegrationForwardedCookies");
-var defineIntegrationSchema = defineSchema;
-var FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME = /* @__PURE__ */ Symbol.for(
-  "@farm.js/core/integration-plugin-server-runtime"
-);
-var FARM_INTEGRATION_PLUGIN_OWNER = /* @__PURE__ */ Symbol.for("@farm.js/core/integration-plugin-owner");
-function getFarmIntegrationPluginServerRuntime(plugin) {
-  const value = plugin[FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME];
-  return typeof value === "boolean" ? value : void 0;
-}
-__name(getFarmIntegrationPluginServerRuntime, "getFarmIntegrationPluginServerRuntime");
-function getFarmIntegrationPluginOwner(plugin) {
-  const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
-  return value && typeof value === "object" ? value : void 0;
-}
-__name(getFarmIntegrationPluginOwner, "getFarmIntegrationPluginOwner");
-function defineTypedIntegrationRoute(method, path, input) {
-  return {
-    path,
-    method,
-    middleware: input.middleware,
-    before: input.before,
-    after: input.after,
-    rawBody: input.rawBody,
-    bodyFormat: input.bodyFormat,
-    input: normalizeIntegrationRouteInputSchemas(input),
-    handler: input.handler,
-    __operation: defineIntegrationAPIOperation({
-      path,
-      method,
-      bodyFormat: input.bodyFormat,
-      responseFormat: input.responseFormat,
-      headers: input.headers,
-      credentials: input.credentials,
-      isServer: input.isServer
-    })
-  };
-}
-__name(defineTypedIntegrationRoute, "defineTypedIntegrationRoute");
-function createIntegrationRouteFactory() {
-  return {
-    get(path, input) {
-      return defineTypedIntegrationRoute(
-        "GET",
-        path,
-        input
-      );
-    },
-    post(path, input) {
-      return defineTypedIntegrationRoute(
-        "POST",
-        path,
-        {
-          bodyFormat: "json",
-          ...input
-        }
-      );
-    },
-    query(path, input) {
-      return defineTypedIntegrationRoute("QUERY", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    put(path, input) {
-      return defineTypedIntegrationRoute(
-        "PUT",
-        path,
-        {
-          bodyFormat: "json",
-          ...input
-        }
-      );
-    },
-    patch(path, input) {
-      return defineTypedIntegrationRoute("PATCH", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    delete(path, input) {
-      return defineTypedIntegrationRoute("DELETE", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    options(path, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path, input);
-    },
-    head(path, input) {
-      return defineTypedIntegrationRoute(
-        "HEAD",
-        path,
-        input
-      );
-    }
-  };
-}
-__name(createIntegrationRouteFactory, "createIntegrationRouteFactory");
-function createIntegrationRoute(_schema) {
-  return createIntegrationRouteFactory();
-}
-__name(createIntegrationRoute, "createIntegrationRoute");
-var integrationRoute = createIntegrationRouteFactory();
-var INTEGRATION_RUNTIME_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRuntimeRegistry");
-var INTEGRATION_REQUEST_DISPATCHER_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRequestDispatcher");
-function getIntegrationRuntimeRegistry() {
-  const globalState = globalThis;
-  if (!globalState[INTEGRATION_RUNTIME_REGISTRY_KEY]) {
-    globalState[INTEGRATION_RUNTIME_REGISTRY_KEY] = /* @__PURE__ */ new Map();
-  }
-  return globalState[INTEGRATION_RUNTIME_REGISTRY_KEY];
-}
-__name(getIntegrationRuntimeRegistry, "getIntegrationRuntimeRegistry");
-function isIntegrationEndpointRoute(value) {
-  return !!value && typeof value === "object" && typeof value.path === "string" && typeof value.handler === "function";
-}
-__name(isIntegrationEndpointRoute, "isIntegrationEndpointRoute");
-function flattenIntegrationEndpoints(endpoints) {
-  if (!endpoints) {
-    return [];
-  }
-  if (Array.isArray(endpoints)) {
-    return endpoints.flatMap((endpoint) => flattenIntegrationEndpoints(endpoint));
-  }
-  if (isIntegrationEndpointRoute(endpoints)) {
-    return [endpoints];
-  }
-  if (typeof endpoints === "object") {
-    return Object.values(endpoints).flatMap((endpoint) => flattenIntegrationEndpoints(endpoint));
-  }
-  return [];
-}
-__name(flattenIntegrationEndpoints, "flattenIntegrationEndpoints");
-function defineIntegration(integration) {
-  const category = integration.category ?? integration.slot;
-  if (!category) {
-    throw new Error("Integration category is required.");
-  }
-  if (integration.category && integration.slot && integration.category !== integration.slot) {
-    throw new Error("Integration category and slot must match when both are provided.");
-  }
-  const routeFactory = createIntegrationRoute(integration.schema);
-  const routes = typeof integration.routes === "function" ? integration.routes({
-    route: routeFactory,
-    integrationRoute: routeFactory
-  }) : integration.routes;
-  const endpoints = typeof integration.endpoints === "function" ? integration.endpoints({
-    endpoint: routeFactory,
-    route: routeFactory,
-    integrationRoute: routeFactory
-  }) : integration.endpoints;
-  const endpointRoutes = flattenIntegrationEndpoints(endpoints);
-  const allRoutes = routes?.length || endpointRoutes.length ? [...routes || [], ...endpointRoutes] : void 0;
-  for (const route2 of allRoutes || []) {
-    assertUniqueRouteParameters(route2.path, "api");
-    validateConfigRouteSource(route2.path, `Integration route "${route2.path}"`);
-    assertTerminalCatchAll(route2.path, "api");
-  }
-  const derivedApi = integration.api || (allRoutes?.length ? api.fromRoutes(
-    allRoutes
-  ) : void 0);
-  return {
-    kind: "farm-integration",
-    ...integration,
-    endpoints,
-    routes: allRoutes,
-    api: derivedApi,
-    category,
-    slot: category
-  };
-}
-__name(defineIntegration, "defineIntegration");
-function isFarmIntegration(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-integration";
-}
-__name(isFarmIntegration, "isFarmIntegration");
-function resolveIntegrationPlugins(integrations) {
-  if (!integrations) {
-    return [];
-  }
-  const plugins = [];
-  for (const [key, integration] of Object.entries(integrations)) {
-    if (!integration || !isFarmIntegration(integration)) {
-      continue;
-    }
-    const owner = createIntegrationPluginOwner(key, integration, "lifecycle");
-    plugins.push(withIntegrationPluginOwner(createIntegrationPlugin(key, integration), owner));
-    plugins.push(...resolveIntegrationPluginContributions(key, integration));
-  }
-  return plugins;
-}
-__name(resolveIntegrationPlugins, "resolveIntegrationPlugins");
-function resolveIntegrationPluginContributions(key, integration) {
-  const contributions = integration.plugins;
-  if (!contributions) return [];
-  if (!Array.isArray(contributions)) {
-    throw new TypeError(`Integration "${key}" plugins must be an array`);
-  }
-  const names = /* @__PURE__ */ new Set();
-  return contributions.map((plugin, index) => {
-    if (!plugin || typeof plugin !== "object" || typeof plugin.name !== "string") {
-      throw new TypeError(`Integration "${key}" plugin at index ${index} is invalid`);
-    }
-    const name = plugin.name.trim();
-    if (!name) {
-      throw new TypeError(`Integration "${key}" plugin at index ${index} requires a name`);
-    }
-    if (names.has(name)) {
-      throw new Error(`Integration "${key}" contributes duplicate plugin name "${name}"`);
-    }
-    names.add(name);
-    return withIntegrationPluginOwner(
-      plugin,
-      createIntegrationPluginOwner(key, integration, "contribution"),
-      createIntegrationPluginContext(key, integration)
-    );
-  });
-}
-__name(resolveIntegrationPluginContributions, "resolveIntegrationPluginContributions");
-function createIntegrationPluginOwner(key, integration, source) {
-  return Object.freeze({
-    key,
-    category: integration.category,
-    type: integration.type,
-    source,
-    serverRuntime: integration.serverRuntime !== false
-  });
-}
-__name(createIntegrationPluginOwner, "createIntegrationPluginOwner");
-function createIntegrationPluginContext(key, integration) {
-  return Object.freeze({
-    key,
-    category: integration.category,
-    type: integration.type,
-    instance: integration.instance,
-    serverRuntime: integration.serverRuntime !== false
-  });
-}
-__name(createIntegrationPluginContext, "createIntegrationPluginContext");
-function withIntegrationPluginOwner(plugin, owner, integration) {
-  const descriptors = Object.getOwnPropertyDescriptors(plugin);
-  Reflect.deleteProperty(descriptors, FARM_INTEGRATION_PLUGIN_OWNER);
-  Reflect.deleteProperty(descriptors, FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME);
-  const ownedPlugin = Object.create(Object.getPrototypeOf(plugin), descriptors);
-  Object.defineProperty(ownedPlugin, FARM_INTEGRATION_PLUGIN_OWNER, { value: owner });
-  Object.defineProperty(ownedPlugin, FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME, {
-    value: owner.serverRuntime
-  });
-  if (integration) {
-    setFarmPluginIntegrationContext(ownedPlugin, integration);
-  }
-  return ownedPlugin;
-}
-__name(withIntegrationPluginOwner, "withIntegrationPluginOwner");
-function getIntegrationProviders(integrations) {
-  if (!integrations) {
-    return [];
-  }
-  const providers = [];
-  for (const integration of Object.values(integrations)) {
-    if (!integration || !isFarmIntegration(integration) || !integration.providers?.length) {
-      continue;
-    }
-    for (const provider of integration.providers) {
-      providers.push({
-        name: provider.name,
-        type: provider.type,
-        props: provider.props,
-        supportsIsolatedHydration: provider.supportsIsolatedHydration,
-        component: provider.component
-      });
-    }
-  }
-  return providers;
-}
-__name(getIntegrationProviders, "getIntegrationProviders");
-function isFarmIntegrationProviderComponentReference(value) {
-  return Boolean(
-    value && typeof value === "object" && "module" in value && typeof value.module === "string" && value.module.length > 0
-  );
-}
-__name(isFarmIntegrationProviderComponentReference, "isFarmIntegrationProviderComponentReference");
-function getIntegrationDocumentNavigationMatchers(integrations) {
-  if (!integrations) {
-    return [];
-  }
-  const matchers = [];
-  for (const integration of Object.values(integrations)) {
-    if (!integration || !isFarmIntegration(integration) || !integration.documentNavigations?.length) {
-      continue;
-    }
-    for (const navigation of integration.documentNavigations) {
-      const items = Array.isArray(navigation.matcher) ? navigation.matcher : [navigation.matcher];
-      for (const item of items) {
-        matchers.push(item);
-      }
-    }
-  }
-  return matchers;
-}
-__name(getIntegrationDocumentNavigationMatchers, "getIntegrationDocumentNavigationMatchers");
-function getIntegrationSchemas(integrations) {
-  if (!integrations) {
-    return {};
-  }
-  const schemaEntries = Object.entries(integrations).map(([key, integration]) => {
-    const schema = integration && isFarmIntegration(integration) ? integration.schema : void 0;
-    return schema ? [key, schema] : null;
-  }).filter((value) => value !== null);
-  return Object.fromEntries(schemaEntries);
-}
-__name(getIntegrationSchemas, "getIntegrationSchemas");
-function getRegisteredIntegrationRuntime(key) {
-  return getIntegrationRuntimeRegistry().get(key);
-}
-__name(getRegisteredIntegrationRuntime, "getRegisteredIntegrationRuntime");
-function getRegisteredIntegrations() {
-  return Object.fromEntries(
-    Array.from(getIntegrationRuntimeRegistry().entries()).map(([key, runtime]) => [
-      key,
-      runtime.integration
-    ])
-  );
-}
-__name(getRegisteredIntegrations, "getRegisteredIntegrations");
-function getRegisteredIntegrationSchemas() {
-  return getIntegrationSchemas(getRegisteredIntegrations());
-}
-__name(getRegisteredIntegrationSchemas, "getRegisteredIntegrationSchemas");
-function matchIntegrationRoute(integrations, input) {
-  if (!integrations) {
-    return null;
-  }
-  const method = normalizeIntegrationRequestMethod(input.method);
-  if (!method) {
-    return null;
-  }
-  const pathSegments = canonicalizeRequestPathSegments(input.pathname);
-  for (const [key, integration] of Object.entries(integrations)) {
-    if (!integration || !isFarmIntegration(integration)) {
-      continue;
-    }
-    const routes = normalizeIntegrationRoutes(integration.routes || []);
-    for (const route2 of routes) {
-      if (!matchesMethod(route2.methods, method)) {
-        continue;
-      }
-      const params = matchPathSegments(route2[INTEGRATION_ROUTE_SEGMENTS], pathSegments);
-      if (!params) {
-        continue;
-      }
-      return {
-        key,
-        integration,
-        route: {
-          path: route2.path,
-          methods: route2.methods
-        },
-        params
-      };
-    }
-  }
-  return null;
-}
-__name(matchIntegrationRoute, "matchIntegrationRoute");
-function matchRegisteredIntegrationRoute(input) {
-  return matchIntegrationRoute(getRegisteredIntegrations(), input);
-}
-__name(matchRegisteredIntegrationRoute, "matchRegisteredIntegrationRoute");
-function createClientSafeIntegrationAPI(api2) {
-  if (!api2) {
-    return void 0;
-  }
-  const entries = Object.entries(api2).map(([key, value]) => {
-    if (value && typeof value === "object" && value.kind === "farm-integration-api-operation") {
-      const operation2 = value;
-      return [
-        key,
-        defineIntegrationAPIOperation({
-          path: operation2.path,
-          method: operation2.method,
-          bodyFormat: operation2.bodyFormat,
-          responseFormat: operation2.responseFormat,
-          credentials: operation2.credentials,
-          isServer: operation2.isServer
-        })
-      ];
-    }
-    if (value && typeof value === "object") {
-      return [key, createClientSafeIntegrationAPI(value)];
-    }
-    return [key, value];
-  });
-  return Object.fromEntries(entries);
-}
-__name(createClientSafeIntegrationAPI, "createClientSafeIntegrationAPI");
-function getRegisteredIntegrationAPIManifest() {
-  const manifestEntries = Object.entries(getRegisteredIntegrations()).map(([key, integration]) => {
-    const api2 = createClientSafeIntegrationAPI(integration.api);
-    return api2 ? [key, api2] : null;
-  }).filter((value) => value !== null);
-  return Object.fromEntries(manifestEntries);
-}
-__name(getRegisteredIntegrationAPIManifest, "getRegisteredIntegrationAPIManifest");
-function getIntegrationRuntimeEnv() {
-  return typeof process !== "undefined" ? process.env : {};
-}
-__name(getIntegrationRuntimeEnv, "getIntegrationRuntimeEnv");
-function isIntegrationConfigDefinition(value) {
-  return !!value && typeof value === "object" && ("schema" in value || "env" in value || "defaults" in value || "input" in value || "resolve" in value);
-}
-__name(isIntegrationConfigDefinition, "isIntegrationConfigDefinition");
-function mergeIntegrationConfigValue(current, next) {
-  if (next === void 0) {
-    return current;
-  }
-  if (isPlainIntegrationConfigObject(current) && isPlainIntegrationConfigObject(next)) {
-    return {
-      ...current,
-      ...next
-    };
-  }
-  return next;
-}
-__name(mergeIntegrationConfigValue, "mergeIntegrationConfigValue");
-function isPlainIntegrationConfigObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isPlainIntegrationConfigObject, "isPlainIntegrationConfigObject");
-async function resolveIntegrationConfigPart(value, context) {
-  if (typeof value === "function") {
-    return value(context);
-  }
-  return value;
-}
-__name(resolveIntegrationConfigPart, "resolveIntegrationConfigPart");
-function resolveIntegrationEnvConfig(env) {
-  if (!env) {
-    return void 0;
-  }
-  const runtimeEnv = getIntegrationRuntimeEnv();
-  const config = {};
-  for (const [key, names] of Object.entries(env)) {
-    const envNames = Array.isArray(names) ? names : [names];
-    const value = envNames.map((name) => runtimeEnv[name]).find((entry) => entry !== void 0);
-    if (value !== void 0) {
-      config[key] = value;
-    }
-  }
-  return config;
-}
-__name(resolveIntegrationEnvConfig, "resolveIntegrationEnvConfig");
-async function parseIntegrationConfigSchema(integration, schema, value) {
-  const parser = schema.safeParseAsync || schema.safeParse;
-  if (parser) {
-    const result = await parser.call(schema, value);
-    if (result.success) {
-      return result.data;
-    }
-    throw createIntegrationConfigValidationError(integration, result.error);
-  }
-  if (schema["~standard"]?.validate) {
-    const result = await schema["~standard"].validate(value);
-    if ("value" in result) {
-      return result.value;
-    }
-    throw createIntegrationConfigValidationError(integration, {
-      issues: result.issues
-    });
-  }
-  if (schema.parse) {
-    try {
-      return await schema.parse(value);
-    } catch (error) {
-      throw createIntegrationConfigValidationError(
-        integration,
-        normalizeIntegrationValidationError(error)
-      );
-    }
-  }
-  throw new Error(
-    `Integration "${integration.type}" config schema must expose safeParse, safeParseAsync, parse, or ~standard.validate.`
-  );
-}
-__name(parseIntegrationConfigSchema, "parseIntegrationConfigSchema");
-function createIntegrationConfigValidationError(integration, error) {
-  const issues = Array.isArray(error.issues) && error.issues.length > 0 ? error.issues.map((issue) => {
-    const normalizedPath = normalizeIntegrationValidationPath(issue.path);
-    const path = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path}${issue.message || "Invalid config"}`;
-  }).join("; ") : error.message || "Invalid config";
-  return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
-}
-__name(createIntegrationConfigValidationError, "createIntegrationConfigValidationError");
-async function resolveIntegrationConfig(integration, context) {
-  const config = integration.config;
-  if (!config) {
-    return void 0;
-  }
-  if (!isIntegrationConfigDefinition(config)) {
-    return parseIntegrationConfigSchema(integration, config, {});
-  }
-  let value = {};
-  value = mergeIntegrationConfigValue(
-    value,
-    await resolveIntegrationConfigPart(config.defaults, context)
-  );
-  value = mergeIntegrationConfigValue(value, resolveIntegrationEnvConfig(config.env));
-  value = mergeIntegrationConfigValue(
-    value,
-    await resolveIntegrationConfigPart(config.input, context)
-  );
-  value = mergeIntegrationConfigValue(value, await config.resolve?.(context));
-  return config.schema ? parseIntegrationConfigSchema(integration, config.schema, value) : value;
-}
-__name(resolveIntegrationConfig, "resolveIntegrationConfig");
-function createIntegrationLifecycleLogger(integration, phase) {
-  const write = /* @__PURE__ */ __name((level, message, meta) => {
-    if (!integration.log) {
-      return;
-    }
-    void Promise.resolve(
-      integration.log({
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase,
-        level,
-        message,
-        meta,
-        context: /* @__PURE__ */ new Map()
-      })
-    ).catch(() => {
-    });
-  }, "write");
-  return {
-    info(message, meta) {
-      write("info", message, meta);
-    },
-    warn(message, meta) {
-      write("warn", message, meta);
-    },
-    error(message, meta) {
-      write("error", message, meta);
-    }
-  };
-}
-__name(createIntegrationLifecycleLogger, "createIntegrationLifecycleLogger");
-async function emitIntegrationLog(integration, event) {
-  try {
-    await integration.log?.(event);
-  } catch {
-  }
-}
-__name(emitIntegrationLog, "emitIntegrationLog");
-var INTEGRATION_DATA_HEADER = "x-farm-integration-data";
-var INTEGRATION_DATA_HEADER_MAX_LENGTH = 16 * 1024;
-var BLOCKED_INTEGRATION_DATA_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function isFarmIntegrationData(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isFarmIntegrationData, "isFarmIntegrationData");
-function isPlainIntegrationDataObject(value) {
-  if (!isFarmIntegrationData(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-__name(isPlainIntegrationDataObject, "isPlainIntegrationDataObject");
-function sanitizeIntegrationDataValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeIntegrationDataValue(item));
-  }
-  if (!isPlainIntegrationDataObject(value)) {
-    return value;
-  }
-  const sanitized = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (BLOCKED_INTEGRATION_DATA_KEYS.has(key)) {
-      continue;
-    }
-    sanitized[key] = sanitizeIntegrationDataValue(item);
-  }
-  return sanitized;
-}
-__name(sanitizeIntegrationDataValue, "sanitizeIntegrationDataValue");
-function normalizeIntegrationData(value) {
-  if (!isFarmIntegrationData(value)) {
-    return {};
-  }
-  const sanitized = sanitizeIntegrationDataValue(value);
-  return isFarmIntegrationData(sanitized) ? sanitized : {};
-}
-__name(normalizeIntegrationData, "normalizeIntegrationData");
-function getIntegrationDataHeaderByteLength(value) {
-  return new TextEncoder().encode(value).byteLength;
-}
-__name(getIntegrationDataHeaderByteLength, "getIntegrationDataHeaderByteLength");
-function parseIntegrationDataHeader(request) {
-  const raw = request.headers.get(INTEGRATION_DATA_HEADER);
-  if (!raw) {
-    return {};
-  }
-  if (getIntegrationDataHeaderByteLength(raw) > INTEGRATION_DATA_HEADER_MAX_LENGTH) {
-    return {};
-  }
-  try {
-    const value = JSON.parse(raw);
-    return normalizeIntegrationData(value);
-  } catch {
-    return {};
-  }
-}
-__name(parseIntegrationDataHeader, "parseIntegrationDataHeader");
-function resolveIntegrationData(request, data) {
-  return {
-    ...parseIntegrationDataHeader(request),
-    ...normalizeIntegrationData(data)
-  };
-}
-__name(resolveIntegrationData, "resolveIntegrationData");
-function createIntegrationPlugin(integrationKey, integration) {
-  const routes = normalizeIntegrationRoutes(integration.routes || []);
-  const middleware = [...integration.middleware || []];
-  const cleanupCallbacks = [];
-  let integrationConfigPromise;
-  const runCleanup = /* @__PURE__ */ __name(async () => {
-    const callbacks = cleanupCallbacks.splice(0).reverse();
-    for (const callback of callbacks) {
-      await callback();
-    }
-  }, "runCleanup");
-  const createLifecycleContext = /* @__PURE__ */ __name(async (context, phase, options = {}) => {
-    const args = createIntegrationRouteArgs({
-      integration,
-      config: context.config
-    });
-    const configContext = {
-      key: integrationKey,
-      integration,
-      appConfig: context.config,
-      config: context.config,
-      args,
-      env: getIntegrationRuntimeEnv(),
-      isDev: context.isDev,
-      isProd: context.isProd
-    };
-    integrationConfigPromise ?? (integrationConfigPromise = resolveIntegrationConfig(integration, configContext));
-    return {
-      ...configContext,
-      integrationConfig: await integrationConfigPromise,
-      log: createIntegrationLifecycleLogger(integration, phase),
-      reason: options.reason,
-      async cleanup(callback) {
-        if (callback) {
-          cleanupCallbacks.push(callback);
-          return;
-        }
-        await runCleanup();
-      }
-    };
-  }, "createLifecycleContext");
-  const plugin = {
-    name: `farm:integration:${integration.category}:${integration.type}`,
-    enforce: "pre",
-    async init(context) {
-      getIntegrationRuntimeRegistry().set(integrationKey, {
-        integration,
-        config: context.config,
-        isDev: context.isDev,
-        isProd: context.isProd
-      });
-      await createLifecycleContext(context, "validate");
-      if (integration.validate) {
-        await integration.validate(await createLifecycleContext(context, "validate"));
-      }
-      if (integration.setup) {
-        await integration.setup(await createLifecycleContext(context, "setup"));
-      }
-      if (!integration.log) {
-        return;
-      }
-      for (const route2 of routes) {
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "registered",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.methods
-          },
-          context: /* @__PURE__ */ new Map()
-        });
-      }
-      for (const entry of middleware) {
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "registered",
-          route: {
-            kind: "middleware",
-            path: normalizeMatcher(entry.matcher),
-            methods: ["ALL"]
-          },
-          context: /* @__PURE__ */ new Map()
-        });
-      }
-    },
-    async ready(context) {
-      if (integration.ready) {
-        await integration.ready(await createLifecycleContext(context, "ready"));
-      }
-    },
-    async shutdown(payload, context) {
-      try {
-        if (integration.dispose) {
-          await integration.dispose(
-            await createLifecycleContext(context, "dispose", {
-              reason: payload.reason
-            })
-          );
-        }
-      } finally {
-        await runCleanup();
-      }
-    },
-    async beforeRequest(req, res, context) {
-      const fullUrl = `http://${req.headers.host || "localhost"}${req.url || "/"}`;
-      const url = new URL(fullUrl);
-      const pathname = url.pathname;
-      const pathSegments = canonicalizeRequestPathSegments(pathname);
-      const method = normalizeIntegrationRequestMethod(req.method);
-      const requestId = getRequestId(req);
-      let bodyLoaded = false;
-      let requestBody;
-      const getRequestBody = /* @__PURE__ */ __name(async () => {
-        if (!bodyLoaded) {
-          bodyLoaded = true;
-          if (req.method && req.method !== "GET" && req.method !== "HEAD") {
-            requestBody = await readNodeRequestBody(
-              req,
-              resolveFarmServerConfig(context.config.server).bodySizeLimit
-            );
-          }
-        }
-        return requestBody;
-      }, "getRequestBody");
-      const createHandlerRequest = /* @__PURE__ */ __name(async () => {
-        try {
-          return createWebRequest(req, fullUrl, await getRequestBody());
-        } catch (error) {
-          const response = createFarmRequestBodyErrorResponse(error);
-          if (!response) throw error;
-          await sendWebResponse(res, response);
-          return null;
-        }
-      }, "createHandlerRequest");
-      for (const entry of middleware) {
-        const params = resolveMatcherParams(entry.matcher, pathname);
-        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 route2 of routes) {
-        const params = method && matchesMethod(route2.methods, method) ? matchPathSegments(route2[INTEGRATION_ROUTE_SEGMENTS], pathSegments) : null;
-        if (!params) {
-          continue;
-        }
-        const request = await createHandlerRequest();
-        if (!request) return;
-        const handlerContext = createIntegrationHandlerContext({
-          integration,
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.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: route2.path,
-            methods: route2.methods
-          },
-          request,
-          requestId,
-          context: handlerContext.req.snapshot()
-        });
-        try {
-          const validation = await validateIntegrationRouteInput(route2, 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: route2.path,
-                methods: route2.methods
-              },
-              request,
-              response: validation.response,
-              requestId,
-              durationMs: Date.now() - startedAt,
-              context: handlerContext.req.snapshot()
-            });
-            return;
-          }
-          handlerContext.input = validation.input;
-          for (const middlewareEntry of route2.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: route2.path,
-                  methods: route2.methods
-                },
-                request,
-                response: middlewareResponse,
-                requestId,
-                durationMs: Date.now() - startedAt,
-                context: handlerContext.req.snapshot()
-              });
-              return;
-            }
-          }
-          const beforeResponse = await runIntegrationRouteBeforeHooks(
-            route2,
-            request,
-            handlerContext
-          );
-          if (beforeResponse) {
-            const response2 = await runIntegrationRouteAfterHooks(
-              route2,
-              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: route2.path,
-                methods: route2.methods
-              },
-              request,
-              response: response2,
-              requestId,
-              durationMs: Date.now() - startedAt,
-              context: handlerContext.req.snapshot()
-            });
-            return;
-          }
-          const handlerResponse = await route2.handler(request, handlerContext);
-          const response = await runIntegrationRouteAfterHooks(
-            route2,
-            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: route2.path,
-              methods: route2.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: route2.path,
-              methods: route2.methods
-            },
-            request,
-            requestId,
-            durationMs: Date.now() - startedAt,
-            error,
-            context: handlerContext.req.snapshot()
-          });
-          throw error;
-        }
-      }
-    }
-  };
-  Object.defineProperty(plugin, FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME, {
-    value: integration.serverRuntime !== false
-  });
-  return plugin;
-}
-__name(createIntegrationPlugin, "createIntegrationPlugin");
-function createIntegrationHandlerContext(input) {
-  const req = createIntegrationRequestContextStore(
-    input.rawRequest,
-    input.request,
-    input.pluginContext
-  );
-  return {
-    request: input.request,
-    requestId: input.requestId,
-    url: new URL(input.request.url),
-    pathname: input.pathname,
-    method: input.request.method,
-    params: input.params,
-    input: {},
-    args: createIntegrationRouteArgs({
-      integration: input.integration,
-      config: input.pluginContext.config
-    }),
-    data: resolveIntegrationData(input.request),
-    integration: {
-      category: input.integration.category,
-      slot: input.integration.category,
-      type: input.integration.type,
-      instance: input.integration.instance
-    },
-    route: input.route,
-    req,
-    requestContext: req,
-    config: input.pluginContext.config,
-    isDev: input.pluginContext.isDev,
-    isProd: input.pluginContext.isProd
-  };
-}
-__name(createIntegrationHandlerContext, "createIntegrationHandlerContext");
-var INTEGRATION_ROUTE_SEGMENTS = /* @__PURE__ */ Symbol("farm.integrationRouteSegments");
-var EMPTY_NORMALIZED_INTEGRATION_ROUTES = [];
-var normalizedIntegrationRoutesCache = /* @__PURE__ */ new WeakMap();
-function normalizeIntegrationRoutes(routes) {
-  if (routes.length === 0) {
-    return EMPTY_NORMALIZED_INTEGRATION_ROUTES;
-  }
-  const cached = normalizedIntegrationRoutesCache.get(routes);
-  if (cached) {
-    return cached;
-  }
-  const normalized = routes.map((route2, index) => {
-    assertUniqueRouteParameters(route2.path, "api");
-    return {
-      index,
-      route: {
-        ...route2,
-        methods: normalizeIntegrationRouteMethods(route2),
-        input: normalizeIntegrationRouteInputSchemas(route2),
-        [INTEGRATION_ROUTE_SEGMENTS]: splitPath(route2.path)
-      },
-      specificity: getRoutePatternSpecificity(route2.path, "api")
-    };
-  }).sort(
-    (left, right) => compareRouteSpecificity(left.specificity, right.specificity) || left.index - right.index
-  ).map(({ route: route2 }) => route2);
-  normalizedIntegrationRoutesCache.set(routes, normalized);
-  return normalized;
-}
-__name(normalizeIntegrationRoutes, "normalizeIntegrationRoutes");
-function normalizeIntegrationRouteMethods(route2) {
-  const input = route2.methods && route2.methods.length > 0 ? [...route2.methods] : route2.method ? [route2.method] : ["ALL"];
-  return input.map((method) => String(method).toUpperCase());
-}
-__name(normalizeIntegrationRouteMethods, "normalizeIntegrationRouteMethods");
-function normalizeIntegrationRouteInputSchemas(route2) {
-  const input = {
-    ...route2.input
-  };
-  if (route2.body) {
-    input.body = route2.body;
-  }
-  if (route2.query) {
-    input.query = route2.query;
-  }
-  return input.body || input.query ? input : void 0;
-}
-__name(normalizeIntegrationRouteInputSchemas, "normalizeIntegrationRouteInputSchemas");
-async function validateIntegrationRouteInput(route2, 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 = route2.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(route2)
-    );
-    if (bodyInput.success) {
-      const bodyResult = await parseIntegrationInputSchema("body", schemas.body, bodyInput.data);
-      if (bodyResult.success) {
-        input.body = bodyResult.data;
-      } else {
-        issues.push(...bodyResult.issues);
-      }
-    } else {
-      issues.push(bodyInput.issue);
-    }
-  }
-  if (issues.length > 0) {
-    return {
-      success: false,
-      response: createIntegrationValidationResponse(issues)
-    };
-  }
-  return {
-    success: true,
-    input
-  };
-}
-__name(validateIntegrationRouteInput, "validateIntegrationRouteInput");
-async function parseIntegrationInputSchema(source, schema, value) {
-  const parser = schema.safeParseAsync || schema.safeParse;
-  if (parser) {
-    const result = await parser.call(schema, value);
-    if (result.success) {
-      return {
-        success: true,
-        data: result.data
-      };
-    }
-    return {
-      success: false,
-      issues: normalizeIntegrationValidationIssues(source, result.error)
-    };
-  }
-  if (schema["~standard"]?.validate) {
-    const result = await schema["~standard"].validate(value);
-    if ("value" in result) {
-      return {
-        success: true,
-        data: result.value
-      };
-    }
-    return {
-      success: false,
-      issues: normalizeIntegrationValidationIssues(source, {
-        issues: result.issues
-      })
-    };
-  }
-  if (schema.parse) {
-    try {
-      return {
-        success: true,
-        data: await schema.parse(value)
-      };
-    } catch (error) {
-      return {
-        success: false,
-        issues: normalizeIntegrationValidationIssues(
-          source,
-          normalizeIntegrationValidationError(error)
-        )
-      };
-    }
-  }
-  return {
-    success: false,
-    issues: [
-      {
-        source,
-        message: "Input schema must expose safeParse, safeParseAsync, parse, or ~standard.validate."
-      }
-    ]
-  };
-}
-__name(parseIntegrationInputSchema, "parseIntegrationInputSchema");
-function createIntegrationValidationResponse(issues) {
-  return Response.json(
-    {
-      error: "Integration route input validation failed",
-      issues
-    },
-    {
-      status: 400
-    }
-  );
-}
-__name(createIntegrationValidationResponse, "createIntegrationValidationResponse");
-function normalizeIntegrationValidationIssues(source, error) {
-  if (Array.isArray(error.issues) && error.issues.length > 0) {
-    return error.issues.map((issue) => ({
-      source,
-      path: normalizeIntegrationValidationPath(issue.path),
-      code: issue.code,
-      message: issue.message || "Invalid input"
-    }));
-  }
-  return [
-    {
-      source,
-      path: [],
-      message: error.message || "Invalid input"
-    }
-  ];
-}
-__name(normalizeIntegrationValidationIssues, "normalizeIntegrationValidationIssues");
-function normalizeIntegrationValidationPath(path) {
-  return (path || []).map((segment) => {
-    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
-    return typeof key === "symbol" ? key.description || key.toString() : key;
-  });
-}
-__name(normalizeIntegrationValidationPath, "normalizeIntegrationValidationPath");
-function normalizeIntegrationValidationError(error) {
-  if (error && typeof error === "object") {
-    return error;
-  }
-  return {
-    message: error instanceof Error ? error.message : String(error || "Invalid input")
-  };
-}
-__name(normalizeIntegrationValidationError, "normalizeIntegrationValidationError");
-async function readIntegrationValidationBody(request, format) {
-  if (request.method === "GET" || request.method === "HEAD" || format === "none") {
-    return {
-      success: true,
-      data: void 0
-    };
-  }
-  try {
-    if (format === "form") {
-      return {
-        success: true,
-        data: createFormInput(await request.clone().formData())
-      };
-    }
-    const text = await request.clone().text();
-    if (text.trim().length === 0) {
-      return {
-        success: true,
-        data: void 0
-      };
-    }
-    return {
-      success: true,
-      data: JSON.parse(text)
-    };
-  } catch (error) {
-    return {
-      success: false,
-      issue: {
-        source: "body",
-        path: [],
-        message: format === "json" ? "Expected a valid JSON request body." : error instanceof Error && error.message ? error.message : "Could not parse request body."
-      }
-    };
-  }
-}
-__name(readIntegrationValidationBody, "readIntegrationValidationBody");
-function getIntegrationRouteBodyFormat(route2) {
-  return route2.bodyFormat || route2.__operation?.bodyFormat || "json";
-}
-__name(getIntegrationRouteBodyFormat, "getIntegrationRouteBodyFormat");
-function createIntegrationRouteArgs(input) {
-  let clientPromise;
-  let ormPromise;
-  const getClient = /* @__PURE__ */ __name(() => {
-    clientPromise ?? (clientPromise = Promise.resolve().then(() => (init_storage(), storage_exports)).then(
-      ({ resolveStorageRuntimeClient: resolveStorageRuntimeClient2 }) => resolveStorageRuntimeClient2(input.config.storage)
-    ));
-    return clientPromise;
-  }, "getClient");
-  const getOrm = /* @__PURE__ */ __name(() => {
-    if (!input.integration.schema) {
-      throw new Error(
-        `Integration "${input.integration.type}" does not define a schema for ctx.args.db.`
-      );
-    }
-    ormPromise ?? (ormPromise = Promise.resolve().then(() => (init_integration_orm(), integration_orm_exports)).then(
-      ({ createIntegrationOrm: createIntegrationOrm2 }) => createIntegrationOrm2({
-        schema: input.integration.schema,
-        config: input.config
-      })
-    ));
-    return ormPromise;
-  }, "getOrm");
-  return {
-    db: createLazyIntegrationOrmClient(getOrm),
-    getDb: getOrm,
-    storage: {
-      getClient,
-      getOrm
-    }
-  };
-}
-__name(createIntegrationRouteArgs, "createIntegrationRouteArgs");
-function createLazyIntegrationOrmClient(resolveOrm) {
-  const modelProxyCache = /* @__PURE__ */ new Map();
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "then") {
-          return void 0;
-        }
-        if (prop === "transaction" || prop === "batch") {
-          return async (...args) => {
-            const orm = await resolveOrm();
-            const member = orm[prop];
-            if (typeof member !== "function") {
-              throw new Error(`Integration ORM does not expose "${String(prop)}".`);
-            }
-            return member.apply(orm, args);
-          };
-        }
-        if (prop === "$driver") {
-          return void 0;
-        }
-        if (!modelProxyCache.has(prop)) {
-          modelProxyCache.set(prop, createLazyIntegrationOrmModel(resolveOrm, prop));
-        }
-        return modelProxyCache.get(prop);
-      }
-    }
-  );
-}
-__name(createLazyIntegrationOrmClient, "createLazyIntegrationOrmClient");
-function createLazyIntegrationOrmModel(resolveOrm, modelName) {
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "then") {
-          return void 0;
-        }
-        return async (...args) => {
-          const orm = await resolveOrm();
-          const model = orm[modelName];
-          const member = model?.[prop];
-          if (typeof member !== "function") {
-            throw new Error(
-              `Integration ORM model "${String(modelName)}" does not expose "${String(prop)}".`
-            );
-          }
-          return member.apply(model, args);
-        };
-      }
-    }
-  );
-}
-__name(createLazyIntegrationOrmModel, "createLazyIntegrationOrmModel");
-async function runIntegrationRouteBeforeHooks(route2, request, context) {
-  const hookContext = context;
-  hookContext.response = void 0;
-  for (const hook of route2.before || []) {
-    const response = await hook(request, hookContext);
-    if (response) {
-      hookContext.response = response;
-      return response;
-    }
-    if (hookContext.response) {
-      return hookContext.response;
-    }
-  }
-  return void 0;
-}
-__name(runIntegrationRouteBeforeHooks, "runIntegrationRouteBeforeHooks");
-async function runIntegrationRouteAfterHooks(route2, request, context, response) {
-  const hookContext = context;
-  let currentResponse = response;
-  for (const hook of route2.after || []) {
-    hookContext.response = currentResponse;
-    const nextResponse = await hook(request, hookContext);
-    currentResponse = nextResponse || hookContext.response || currentResponse;
-  }
-  hookContext.response = currentResponse;
-  return currentResponse;
-}
-__name(runIntegrationRouteAfterHooks, "runIntegrationRouteAfterHooks");
-function createQueryInput(searchParams) {
-  const input = {};
-  searchParams.forEach((value, key) => {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
-    const existing = input[key];
-    if (existing === void 0) {
-      input[key] = value;
-      return;
-    }
-    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-  });
-  return input;
-}
-__name(createQueryInput, "createQueryInput");
-function createFormInput(formData) {
-  const input = {};
-  formData.forEach((value, key) => {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
-    const existing = input[key];
-    if (existing === void 0) {
-      input[key] = value;
-      return;
-    }
-    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-  });
-  return input;
-}
-__name(createFormInput, "createFormInput");
-async function dispatchIntegrationRequest(runtime, request, options = {}) {
-  try {
-    request = await bufferFarmRequestBody(
-      request,
-      resolveFarmServerConfig(runtime.config.server).bodySizeLimit
-    );
-  } catch (error) {
-    const response = createFarmRequestBodyErrorResponse(error);
-    if (response) return response;
-    throw error;
-  }
-  const integration = runtime.integration;
-  const url = new URL(request.url);
-  const pathname = url.pathname;
-  const requestId = request.headers.get("x-request-id") || options.currentRequest?.headers.get("x-request-id") || String(Date.now());
-  const routes = normalizeIntegrationRoutes(integration.routes || []);
-  const pathSegments = canonicalizeRequestPathSegments(pathname);
-  const method = normalizeIntegrationRequestMethod(request.method);
-  const middleware = [...integration.middleware || []];
-  const forwardedSetCookies = [];
-  for (const entry of middleware) {
-    const params = resolveMatcherParams(entry.matcher, pathname);
-    if (!params) {
-      continue;
-    }
-    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 route2 of routes) {
-    const params = method && matchesMethod(route2.methods, method) ? matchPathSegments(route2[INTEGRATION_ROUTE_SEGMENTS], pathSegments) : null;
-    if (!params) {
-      continue;
-    }
-    const handlerContext = createServerIntegrationHandlerContext({
-      runtime,
-      route: {
-        kind: "route",
-        path: route2.path,
-        methods: route2.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: route2.path,
-        methods: route2.methods
-      },
-      request,
-      requestId,
-      context: handlerContext.req.snapshot()
-    });
-    try {
-      const validation = await validateIntegrationRouteInput(route2, request, url);
-      if (!validation.success) {
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.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 route2.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: route2.path,
-              methods: route2.methods
-            },
-            request,
-            response: middlewareResponse,
-            requestId,
-            durationMs: Date.now() - startedAt,
-            context: handlerContext.req.snapshot()
-          });
-          return appendIntegrationForwardedCookies(middlewareResponse, forwardedSetCookies);
-        }
-      }
-      const beforeResponse = await runIntegrationRouteBeforeHooks(route2, request, handlerContext);
-      if (beforeResponse) {
-        const response2 = await runIntegrationRouteAfterHooks(
-          route2,
-          request,
-          handlerContext,
-          beforeResponse
-        );
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.methods
-          },
-          request,
-          response: response2,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return appendIntegrationForwardedCookies(response2, forwardedSetCookies);
-      }
-      const handlerResponse = await route2.handler(request, handlerContext);
-      const response = await runIntegrationRouteAfterHooks(
-        route2,
-        request,
-        handlerContext,
-        handlerResponse
-      );
-      await emitIntegrationLog(integration, {
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:end",
-        route: {
-          kind: "route",
-          path: route2.path,
-          methods: route2.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: route2.path,
-          methods: route2.methods
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        error,
-        context: handlerContext.req.snapshot()
-      });
-      throw error;
-    }
-  }
-  if (forwardedSetCookies.length > 0) {
-    options.onForwardedCookies?.(forwardedSetCookies);
-  }
-  return null;
-}
-__name(dispatchIntegrationRequest, "dispatchIntegrationRequest");
-async function dispatchIntegrationRequests(integrations, runtime, request, options = {}) {
-  const setCookies = [];
-  if (!integrations) {
-    return { response: null, setCookies };
-  }
-  for (const integration of Object.values(integrations)) {
-    if (!integration || !isFarmIntegration(integration)) {
-      continue;
-    }
-    const hasMiddleware = (integration.middleware || []).length > 0;
-    const hasRoutes = normalizeIntegrationRoutes(integration.routes || []).length > 0;
-    if (!hasMiddleware && !hasRoutes) {
-      continue;
-    }
-    const response = await dispatchIntegrationRequest(
-      { ...runtime, integration },
-      // Each dispatch buffers the body it is given, so hand every integration
-      // its own clone rather than a Request another dispatch already read.
-      request.clone(),
-      {
-        currentRequest: options.currentRequest,
-        onForwardedCookies: /* @__PURE__ */ __name((cookies) => setCookies.push(...cookies), "onForwardedCookies")
-      }
-    );
-    if (response) {
-      return {
-        response: appendIntegrationForwardedCookies(response, setCookies),
-        setCookies: []
-      };
-    }
-  }
-  return { response: null, setCookies };
-}
-__name(dispatchIntegrationRequests, "dispatchIntegrationRequests");
-globalThis[INTEGRATION_REQUEST_DISPATCHER_KEY] = dispatchIntegrationRequest;
-function createIntegrationRequestContextStore(rawRequest, request, pluginContext) {
-  return {
-    get(key) {
-      const requestValue = pluginContext.requestContext.get(request, key);
-      if (requestValue !== void 0) {
-        return requestValue;
-      }
-      return pluginContext.requestContext.get(rawRequest, key);
-    },
-    set(key, value, options) {
-      pluginContext.requestContext.set(rawRequest, key, value, options);
-      pluginContext.requestContext.set(request, key, value, options);
-    },
-    has(key) {
-      return pluginContext.requestContext.has(request, key) || pluginContext.requestContext.has(rawRequest, key);
-    },
-    delete(key) {
-      const deletedRequest = pluginContext.requestContext.delete(request, key);
-      const deletedRaw = pluginContext.requestContext.delete(rawRequest, key);
-      return deletedRequest || deletedRaw;
-    },
-    clear() {
-      pluginContext.requestContext.clear(rawRequest);
-      pluginContext.requestContext.clear(request);
-    },
-    snapshot(options) {
-      const merged = pluginContext.requestContext.getAll(rawRequest, options);
-      const requestSnapshot = pluginContext.requestContext.getAll(request, options);
-      for (const [key, value] of requestSnapshot) {
-        merged.set(key, value);
-      }
-      return merged;
-    }
-  };
-}
-__name(createIntegrationRequestContextStore, "createIntegrationRequestContextStore");
-function createServerIntegrationHandlerContext(input) {
-  const req = createServerIntegrationRequestContextStore(input.request, input.currentRequest);
-  if (input.internal) {
-    req.set(FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY, true);
-  }
-  return {
-    request: input.request,
-    requestId: input.requestId,
-    url: new URL(input.request.url),
-    pathname: input.pathname,
-    method: input.request.method,
-    params: input.params,
-    input: {},
-    args: createIntegrationRouteArgs({
-      integration: input.runtime.integration,
-      config: input.runtime.config
-    }),
-    data: resolveIntegrationData(input.request, input.data),
-    integration: {
-      category: input.runtime.integration.category,
-      slot: input.runtime.integration.category,
-      type: input.runtime.integration.type,
-      instance: input.runtime.integration.instance
-    },
-    route: input.route,
-    req,
-    requestContext: req,
-    config: input.runtime.config,
-    isDev: input.runtime.isDev,
-    isProd: input.runtime.isProd
-  };
-}
-__name(createServerIntegrationHandlerContext, "createServerIntegrationHandlerContext");
-function createServerIntegrationRequestContextStore(request, currentRequest) {
-  return {
-    get(key) {
-      const requestValue = getRequestContext(request, key);
-      if (requestValue !== void 0) {
-        return requestValue;
-      }
-      if (currentRequest) {
-        return getRequestContext(currentRequest, key);
-      }
-      return void 0;
-    },
-    set(key, value, options) {
-      setRequestContext(request, key, value, options);
-      if (currentRequest) {
-        setRequestContext(currentRequest, key, value, options);
-      }
-    },
-    has(key) {
-      return hasRequestContext(request, key) || !!currentRequest && hasRequestContext(currentRequest, key);
-    },
-    delete(key) {
-      const deletedRequest = deleteRequestContext(request, key);
-      const deletedCurrent = currentRequest ? deleteRequestContext(currentRequest, key) : false;
-      return deletedRequest || deletedCurrent;
-    },
-    clear() {
-      clearRequestContext(request);
-      if (currentRequest) {
-        clearRequestContext(currentRequest);
-      }
-    },
-    snapshot(options) {
-      const merged = currentRequest ? getRequestContextSnapshot(currentRequest, options) : /* @__PURE__ */ new Map();
-      const requestSnapshot = getRequestContextSnapshot(request, options);
-      for (const [key, value] of requestSnapshot) {
-        merged.set(key, value);
-      }
-      return merged;
-    }
-  };
-}
-__name(createServerIntegrationRequestContextStore, "createServerIntegrationRequestContextStore");
-function createWebRequest(req, fullUrl, body) {
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value == null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(key, item);
-      }
-      continue;
-    }
-    headers.set(key, value);
-  }
-  return new Request(fullUrl, {
-    method: req.method,
-    headers,
-    body
-  });
-}
-__name(createWebRequest, "createWebRequest");
-function normalizeIntegrationRequestMethod(method) {
-  return method ? method.toUpperCase() : void 0;
-}
-__name(normalizeIntegrationRequestMethod, "normalizeIntegrationRequestMethod");
-function matchesMethod(methods, normalizedMethod) {
-  return methods.some((candidate) => candidate === "ALL" || candidate === normalizedMethod);
-}
-__name(matchesMethod, "matchesMethod");
-function resolveMatcherParams(matcher, pathname) {
-  if (!matcher) {
-    return {};
-  }
-  const list = Array.isArray(matcher) ? matcher : [matcher];
-  let canonicalPathname;
-  let canonicalSegments;
-  for (const item of list) {
-    if (item === "/(.*)" || item === "*") {
-      return {};
-    }
-    if (item.endsWith("(.*)")) {
-      canonicalPathname ?? (canonicalPathname = canonicalizeRequestPathname(pathname));
-      const prefix = item.slice(0, -4);
-      if (canonicalPathname === prefix || canonicalPathname.startsWith(`${prefix}/`)) {
-        return {};
-      }
-      continue;
-    }
-    canonicalSegments ?? (canonicalSegments = canonicalizeRequestPathSegments(pathname));
-    const params = matchPathSegments(splitPath(item), canonicalSegments);
-    if (params) {
-      return params;
-    }
-  }
-  return null;
-}
-__name(resolveMatcherParams, "resolveMatcherParams");
-function matchPathSegments(routeSegments, pathSegments) {
-  const params = {};
-  let routeIndex = 0;
-  let pathIndex = 0;
-  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
-    const routeSegment = routeSegments[routeIndex];
-    const pathSegment = pathSegments[pathIndex];
-    if (isCatchAllSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex);
-      return params;
-    }
-    if (isDynamicSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegment;
-      routeIndex += 1;
-      pathIndex += 1;
-      continue;
-    }
-    if (routeSegment !== pathSegment) {
-      return null;
-    }
-    routeIndex += 1;
-    pathIndex += 1;
-  }
-  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
-    return params;
-  }
-  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
-    params[getSegmentParamName(routeSegments[routeIndex])] = [];
-    return params;
-  }
-  return null;
-}
-__name(matchPathSegments, "matchPathSegments");
-function splitPath(value) {
-  return value.split("/").filter(Boolean);
-}
-__name(splitPath, "splitPath");
-function isDynamicSegment(segment) {
-  return segment.startsWith("[") && segment.endsWith("]");
-}
-__name(isDynamicSegment, "isDynamicSegment");
-function isCatchAllSegment(segment) {
-  return segment.startsWith("[...") && segment.endsWith("]");
-}
-__name(isCatchAllSegment, "isCatchAllSegment");
-function getSegmentParamName(segment) {
-  if (isCatchAllSegment(segment)) {
-    return segment.slice(4, -1);
-  }
-  return segment.slice(1, -1);
-}
-__name(getSegmentParamName, "getSegmentParamName");
-function getRequestId(req) {
-  const headerValue = req.headers["x-request-id"];
-  if (Array.isArray(headerValue)) {
-    return headerValue[0] || String(Date.now());
-  }
-  return headerValue || String(Date.now());
-}
-__name(getRequestId, "getRequestId");
-function normalizeMatcher(matcher) {
-  if (!matcher) {
-    return "/(.*)";
-  }
-  return typeof matcher === "string" ? matcher : matcher.join(", ");
-}
-__name(normalizeMatcher, "normalizeMatcher");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY,
-  FARM_INTEGRATION_SET_COOKIES_KEY,
-  api,
-  createIntegrationRoute,
-  defineIntegration,
-  defineIntegrationAPI,
-  defineIntegrationAPIOperation,
-  defineIntegrationSchema,
-  describeIntegrationOriginRejection,
-  dispatchIntegrationRequest,
-  dispatchIntegrationRequests,
-  forwardIntegrationSetCookies,
-  getFarmIntegrationPluginOwner,
-  getFarmIntegrationPluginServerRuntime,
-  getIntegrationDocumentNavigationMatchers,
-  getIntegrationProviders,
-  getIntegrationSchemas,
-  getRegisteredIntegrationAPIManifest,
-  getRegisteredIntegrationRuntime,
-  getRegisteredIntegrationSchemas,
-  getRegisteredIntegrations,
-  integrationRoute,
-  isFarmIntegration,
-  isFarmIntegrationProviderComponentReference,
-  matchIntegrationRoute,
-  matchRegisteredIntegrationRoute,
-  resolveIntegrationAllowedOrigins,
-  resolveIntegrationPlugins,
-  validateIntegrationRequestOrigin
-});
+
+
+
+
+
+
+
+var _chunkZ5HIWVDPcjs = require('./chunk-Z5HIWVDP.cjs');
+require('./chunk-SVRTJOUF.cjs');
+require('./chunk-G643DQCH.cjs');
+require('./chunk-EM6SBQKM.cjs');
+require('./chunk-UQZ4AYTH.cjs');
+
+
+
+
+var _chunkNZKJGRB3cjs = require('./chunk-NZKJGRB3.cjs');
+require('./chunk-DVM4FKZL.cjs');
+require('./chunk-US2QVW3E.cjs');
+require('./chunk-BIDYX3SL.cjs');
+require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = _chunkZ5HIWVDPcjs.FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY; exports.FARM_INTEGRATION_SET_COOKIES_KEY = _chunkZ5HIWVDPcjs.FARM_INTEGRATION_SET_COOKIES_KEY; exports.api = _chunkNZKJGRB3cjs.api; exports.createIntegrationRoute = _chunkZ5HIWVDPcjs.createIntegrationRoute; exports.defineIntegration = _chunkZ5HIWVDPcjs.defineIntegration; exports.defineIntegrationAPI = _chunkNZKJGRB3cjs.defineIntegrationAPI; exports.defineIntegrationAPIOperation = _chunkNZKJGRB3cjs.defineIntegrationAPIOperation; exports.defineIntegrationSchema = _chunkZ5HIWVDPcjs.defineIntegrationSchema; exports.describeIntegrationOriginRejection = _chunkZ5HIWVDPcjs.describeIntegrationOriginRejection; exports.dispatchIntegrationRequest = _chunkZ5HIWVDPcjs.dispatchIntegrationRequest; exports.dispatchIntegrationRequests = _chunkZ5HIWVDPcjs.dispatchIntegrationRequests; exports.forwardIntegrationSetCookies = _chunkZ5HIWVDPcjs.forwardIntegrationSetCookies; exports.getFarmIntegrationPluginOwner = _chunkZ5HIWVDPcjs.getFarmIntegrationPluginOwner; exports.getFarmIntegrationPluginServerRuntime = _chunkZ5HIWVDPcjs.getFarmIntegrationPluginServerRuntime; exports.getIntegrationDocumentNavigationMatchers = _chunkZ5HIWVDPcjs.getIntegrationDocumentNavigationMatchers; exports.getIntegrationProviders = _chunkZ5HIWVDPcjs.getIntegrationProviders; exports.getIntegrationSchemas = _chunkZ5HIWVDPcjs.getIntegrationSchemas; exports.getRegisteredIntegrationAPIManifest = _chunkZ5HIWVDPcjs.getRegisteredIntegrationAPIManifest; exports.getRegisteredIntegrationRuntime = _chunkZ5HIWVDPcjs.getRegisteredIntegrationRuntime; exports.getRegisteredIntegrationSchemas = _chunkZ5HIWVDPcjs.getRegisteredIntegrationSchemas; exports.getRegisteredIntegrations = _chunkZ5HIWVDPcjs.getRegisteredIntegrations; exports.integrationRoute = _chunkZ5HIWVDPcjs.integrationRoute; exports.isFarmIntegration = _chunkZ5HIWVDPcjs.isFarmIntegration; exports.isFarmIntegrationProviderComponentReference = _chunkZ5HIWVDPcjs.isFarmIntegrationProviderComponentReference; exports.matchIntegrationRoute = _chunkZ5HIWVDPcjs.matchIntegrationRoute; exports.matchRegisteredIntegrationRoute = _chunkZ5HIWVDPcjs.matchRegisteredIntegrationRoute; exports.resolveIntegrationAllowedOrigins = _chunkZ5HIWVDPcjs.resolveIntegrationAllowedOrigins; exports.resolveIntegrationPlugins = _chunkZ5HIWVDPcjs.resolveIntegrationPlugins; exports.validateIntegrationRequestOrigin = _chunkZ5HIWVDPcjs.validateIntegrationRequestOrigin;