@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/integrations.cjs

@@ -0,0 +1,2820 @@
+"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);
+
+// 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) || {}));
+  return db0DriverModule.default({
+    database,
+    tableName: config.tableName
+  });
+}
+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(async () => {
+    driverPromise ?? (driverPromise = Promise.resolve(resolveDriver2()));
+    return driverPromise;
+  }, "ensureDriver");
+  const ensureStorage = /* @__PURE__ */ __name(async () => {
+    storagePromise ?? (storagePromise = ensureDriver().then(
+      (driver) => (0, import_unstorage.createStorage)({
+        driver
+      })
+    ));
+    return storagePromise;
+  }, "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;
+          });
+        }
+        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");
+    return db0DriverModule.default({
+      database,
+      tableName: options.tableName
+    });
+  });
+}
+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)
+  });
+  await mountNamespaces(storage, config.mounts);
+  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);
+  return {
+    ...namespaced,
+    async clear() {
+      const keys = await namespaced.getKeys();
+      await Promise.all(keys.map((key) => namespaced.removeItem(key)));
+    }
+  };
+}
+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/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) {
+  const orm = await import("@farming-labs/orm");
+  const models = {};
+  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {
+    models[modelKey] = orm.model({
+      table: modelSchema.name ?? modelKey,
+      fields: createOrmModelFields(orm, modelSchema),
+      constraints: createOrmModelConstraints(modelSchema),
+      description: modelSchema.description
+    });
+  }
+  return orm.defineSchema(models);
+}
+function createOrmModelFields(orm, modelSchema) {
+  return Object.fromEntries(
+    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [
+      fieldKey,
+      createOrmField(orm, fieldKey, fieldSchema)
+    ])
+  );
+}
+function createOrmField(orm, fieldKey, field) {
+  let builder = createOrmFieldBuilder(orm, fieldKey, field);
+  if (field.unique) {
+    builder = builder.unique();
+  }
+  if (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) {
+    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) {
+  switch (field.type) {
+    case "id":
+    case "uuid":
+      return orm.id();
+    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_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,
+  api: () => api,
+  createIntegrationRoute: () => createIntegrationRoute,
+  defineIntegration: () => defineIntegration,
+  defineIntegrationAPI: () => defineIntegrationAPI,
+  defineIntegrationAPIOperation: () => defineIntegrationAPIOperation,
+  defineIntegrationSchema: () => defineIntegrationSchema,
+  dispatchIntegrationRequest: () => dispatchIntegrationRequest,
+  getFarmIntegrationPluginServerRuntime: () => getFarmIntegrationPluginServerRuntime,
+  getIntegrationDocumentNavigationMatchers: () => getIntegrationDocumentNavigationMatchers,
+  getIntegrationProviders: () => getIntegrationProviders,
+  getIntegrationSchemas: () => getIntegrationSchemas,
+  getRegisteredIntegrationAPIManifest: () => getRegisteredIntegrationAPIManifest,
+  getRegisteredIntegrationRuntime: () => getRegisteredIntegrationRuntime,
+  getRegisteredIntegrationSchemas: () => getRegisteredIntegrationSchemas,
+  getRegisteredIntegrations: () => getRegisteredIntegrations,
+  integrationRoute: () => integrationRoute,
+  isFarmIntegration: () => isFarmIntegration,
+  matchIntegrationRoute: () => matchIntegrationRoute,
+  matchRegisteredIntegrationRoute: () => matchRegisteredIntegrationRoute,
+  resolveIntegrationPlugins: () => resolveIntegrationPlugins
+});
+module.exports = __toCommonJS(integrations_exports);
+
+// 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,
+  post(pathOrOptions, maybeOptions = {}) {
+    return operation("POST", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  put(pathOrOptions, maybeOptions = {}) {
+    return operation("PUT", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  patch(pathOrOptions, maybeOptions = {}) {
+    return operation("PATCH", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  delete(pathOrOptions, maybeOptions = {}) {
+    return operation("DELETE", pathOrOptions, {
+      bodyFormat: "json",
+      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+    });
+  },
+  options(pathOrOptions, maybeOptions = {}) {
+    return operation(
+      "OPTIONS",
+      pathOrOptions,
+      maybeOptions
+    );
+  },
+  head(pathOrOptions, maybeOptions = {}) {
+    return operation(
+      "HEAD",
+      pathOrOptions,
+      maybeOptions
+    );
+  },
+  form: {
+    post(pathOrOptions, maybeOptions = {}) {
+      return operation("POST", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    },
+    put(pathOrOptions, maybeOptions = {}) {
+      return operation("PUT", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    },
+    patch(pathOrOptions, maybeOptions = {}) {
+      return operation("PATCH", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    },
+    delete(pathOrOptions, maybeOptions = {}) {
+      return operation("DELETE", pathOrOptions, {
+        bodyFormat: "form",
+        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
+      });
+    }
+  }
+};
+
+// 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");
+
+// src/server/response.ts
+var import_node_events = require("events");
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  const responseHeaders = response.headers;
+  const setCookies = responseHeaders.getSetCookie?.() || [];
+  if (setCookies.length > 0) {
+    res.setHeader("Set-Cookie", setCookies);
+  }
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie" && setCookies.length > 0) {
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  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();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (!value || value.byteLength === 0) {
+        continue;
+      }
+      if (!res.write(value)) {
+        await (0, import_node_events.once)(res, "drain");
+      }
+    }
+    res.end();
+  } catch (error) {
+    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 {
+    reader.releaseLock();
+  }
+}
+__name(sendWebResponse, "sendWebResponse");
+
+// src/integrations.ts
+var FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
+function defineIntegrationSchema(schema) {
+  return schema;
+}
+__name(defineIntegrationSchema, "defineIntegrationSchema");
+var FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME = /* @__PURE__ */ Symbol.for(
+  "@farm.js/core/integration-plugin-server-runtime"
+);
+function getFarmIntegrationPluginServerRuntime(plugin) {
+  const value = plugin[FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME];
+  return typeof value === "boolean" ? value : void 0;
+}
+__name(getFarmIntegrationPluginServerRuntime, "getFarmIntegrationPluginServerRuntime");
+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
+        }
+      );
+    },
+    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;
+  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;
+    }
+    plugins.push(createIntegrationPlugin(key, integration));
+    if (integration.plugins?.length) {
+      plugins.push(...integration.plugins);
+    }
+  }
+  return plugins;
+}
+__name(resolveIntegrationPlugins, "resolveIntegrationPlugins");
+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
+      });
+    }
+  }
+  return providers;
+}
+__name(getIntegrationProviders, "getIntegrationProviders");
+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;
+  }
+  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, input.method)) {
+        continue;
+      }
+      const params = extractPathParams(route2.path, input.pathname);
+      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");
+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 integration.log({
+          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 integration.log({
+          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 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 readRequestBody(req);
+          }
+        }
+        return requestBody;
+      }, "getRequestBody");
+      const createHandlerRequest = /* @__PURE__ */ __name(async () => {
+        return createWebRequest(req, fullUrl, await getRequestBody());
+      }, "createHandlerRequest");
+      for (const entry of middleware) {
+        const params = resolveMatcherParams(entry.matcher, pathname);
+        if (!params) {
+          continue;
+        }
+        const request = await createHandlerRequest();
+        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 integration.log?.({
+          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);
+          if (response) {
+            await sendWebResponse(res, response);
+            await integration.log?.({
+              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 integration.log?.({
+            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 integration.log?.({
+            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 = matchesMethod(route2.methods, req.method) ? extractPathParams(route2.path, pathname) : null;
+        if (!params) {
+          continue;
+        }
+        const request = await createHandlerRequest();
+        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 integration.log?.({
+          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 integration.log?.({
+              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 integration.log?.({
+                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 integration.log?.({
+              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 integration.log?.({
+            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 integration.log?.({
+            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");
+function normalizeIntegrationRoutes(routes) {
+  return routes.map((route2) => ({
+    ...route2,
+    methods: normalizeIntegrationRouteMethods(route2),
+    input: normalizeIntegrationRouteInputSchemas(route2)
+  }));
+}
+__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) {
+  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) => {
+    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) => {
+    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 = {}) {
+  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 middleware = [...integration.middleware || []];
+  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 integration.log?.({
+      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);
+      if (response) {
+        await integration.log?.({
+          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 response;
+      }
+      await integration.log?.({
+        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 integration.log?.({
+        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 = matchesMethod(route2.methods, request.method) ? extractPathParams(route2.path, pathname) : 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 integration.log?.({
+      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 integration.log?.({
+          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 validation.response;
+      }
+      handlerContext.input = validation.input;
+      for (const middlewareEntry of route2.middleware || []) {
+        const middlewareResponse = await middlewareEntry.handler(request, handlerContext);
+        if (middlewareResponse) {
+          await integration.log?.({
+            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 middlewareResponse;
+        }
+      }
+      const beforeResponse = await runIntegrationRouteBeforeHooks(route2, request, handlerContext);
+      if (beforeResponse) {
+        const response2 = await runIntegrationRouteAfterHooks(
+          route2,
+          request,
+          handlerContext,
+          beforeResponse
+        );
+        await integration.log?.({
+          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 response2;
+      }
+      const handlerResponse = await route2.handler(request, handlerContext);
+      const response = await runIntegrationRouteAfterHooks(
+        route2,
+        request,
+        handlerContext,
+        handlerResponse
+      );
+      await integration.log?.({
+        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 response;
+    } catch (error) {
+      await integration.log?.({
+        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;
+    }
+  }
+  return null;
+}
+__name(dispatchIntegrationRequest, "dispatchIntegrationRequest");
+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 matchesMethod(methods, method) {
+  if (!method) {
+    return false;
+  }
+  return methods.some((item) => item.toUpperCase() === method.toUpperCase());
+}
+__name(matchesMethod, "matchesMethod");
+function resolveMatcherParams(matcher, pathname) {
+  if (!matcher) {
+    return {};
+  }
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  for (const item of list) {
+    if (item === "/(.*)" || item === "*") {
+      return {};
+    }
+    if (item.endsWith("(.*)")) {
+      const prefix = item.slice(0, -4);
+      if (pathname === prefix || pathname.startsWith(`${prefix}/`)) {
+        return {};
+      }
+      continue;
+    }
+    const params = extractPathParams(item, pathname);
+    if (params) {
+      return params;
+    }
+  }
+  return null;
+}
+__name(resolveMatcherParams, "resolveMatcherParams");
+function extractPathParams(pattern, pathname) {
+  const routeSegments = splitPath(pattern);
+  const pathSegments = splitPath(pathname);
+  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).map((segment) => decodeURIComponent(segment));
+      return params;
+    }
+    if (isDynamicSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = decodeURIComponent(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(extractPathParams, "extractPathParams");
+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");
+async function readRequestBody(req) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    req.on("error", reject);
+  });
+}
+__name(readRequestBody, "readRequestBody");
+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,
+  api,
+  createIntegrationRoute,
+  defineIntegration,
+  defineIntegrationAPI,
+  defineIntegrationAPIOperation,
+  defineIntegrationSchema,
+  dispatchIntegrationRequest,
+  getFarmIntegrationPluginServerRuntime,
+  getIntegrationDocumentNavigationMatchers,
+  getIntegrationProviders,
+  getIntegrationSchemas,
+  getRegisteredIntegrationAPIManifest,
+  getRegisteredIntegrationRuntime,
+  getRegisteredIntegrationSchemas,
+  getRegisteredIntegrations,
+  integrationRoute,
+  isFarmIntegration,
+  matchIntegrationRoute,
+  matchRegisteredIntegrationRoute,
+  resolveIntegrationPlugins
+});
+//# sourceMappingURL=integrations.cjs.map