@farm.js/core 0.1.17 → 0.1.19

package/dist/agent-runtime.cjs

@@ -1,2742 +1,26 @@
-"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) || {}));
-  const driver = db0DriverModule.default({
-    database,
-    tableName: config.tableName
-  });
-  return {
-    ...driver,
-    async dispose() {
-      await database.dispose();
-    }
-  };
-}
-async function resolveDriver(config) {
-  if (config && isStorageClient(config)) {
-    return config.resolveDriver();
-  }
-  const driverInput = config?.driver ?? "memory";
-  if (typeof driverInput === "function") {
-    return await driverInput();
-  }
-  if (isDriverInstance(driverInput)) {
-    return driverInput;
-  }
-  if (isDatabaseDriverName(driverInput)) {
-    return loadDatabaseDriver(config);
-  }
-  if (driverInput === "local") {
-    return loadBuiltinDriver("fs-lite", extractDriverOptions(config));
-  }
-  return loadBuiltinDriver(
-    driverInput,
-    extractDriverOptions(config)
-  );
-}
-function createStorageClientFromResolver(resolveDriver2) {
-  let driverPromise;
-  let storagePromise;
-  const ensureDriver = /* @__PURE__ */ __name(() => {
-    if (driverPromise) return driverPromise;
-    const pending = Promise.resolve().then(resolveDriver2);
-    driverPromise = pending;
-    void pending.catch(() => {
-      if (driverPromise === pending) {
-        driverPromise = void 0;
-        storagePromise = void 0;
-      }
-    });
-    return pending;
-  }, "ensureDriver");
-  const ensureStorage = /* @__PURE__ */ __name(() => {
-    if (storagePromise) return storagePromise;
-    const pending = ensureDriver().then(
-      (driver) => (0, import_unstorage.createStorage)({
-        driver
-      })
-    );
-    storagePromise = pending;
-    void pending.catch(() => {
-      if (storagePromise === pending) storagePromise = void 0;
-    });
-    return pending;
-  }, "ensureStorage");
-  const target = {
-    kind: "farm-storage-client",
-    ready: ensureStorage,
-    createStorage: ensureStorage,
-    resolveDriver: ensureDriver
-  };
-  return new Proxy(target, {
-    get(currentTarget, prop, receiver) {
-      if (prop === "then") {
-        return void 0;
-      }
-      if (Reflect.has(currentTarget, prop)) {
-        return Reflect.get(currentTarget, prop, receiver);
-      }
-      return (...args) => ensureStorage().then(async (storage) => {
-        const member = Reflect.get(storage, prop);
-        if (typeof member !== "function") {
-          return member;
-        }
-        const result = Reflect.apply(member, storage, args);
-        if (prop === "dispose") {
-          return Promise.resolve(result).finally(() => {
-            storagePromise = void 0;
-            driverPromise = void 0;
-          });
-        }
-        return result;
-      });
-    }
-  });
-}
-function defineStorageClient(resolveDriver2) {
-  return createStorageClientFromResolver(resolveDriver2);
-}
-function createStorageClient(config) {
-  return defineStorageClient(() => resolveDriver(config));
-}
-function driverStorage(driver) {
-  return defineStorageClient(() => typeof driver === "function" ? driver() : driver);
-}
-function databaseStorage(database, options = {}) {
-  return defineStorageClient(async () => {
-    const db0DriverModule = await loadModule("unstorage/drivers/db0");
-    const { dispose: _dispose, ...driver } = db0DriverModule.default({
-      database,
-      tableName: options.tableName
-    });
-    return driver;
-  });
-}
-function memoryStorage() {
-  return createStorageClient({ driver: "memory" });
-}
-function localStorage(options = {}) {
-  return createStorageClient({
-    driver: "local",
-    ...options
-  });
-}
-function sqliteStorage(options) {
-  return createStorageClient({
-    driver: "sqlite",
-    ...options
-  });
-}
-function mysqlStorage(options) {
-  return createStorageClient({
-    driver: "mysql",
-    ...options
-  });
-}
-function mysql2Storage(options) {
-  return mysqlStorage(options);
-}
-function postgresStorage(options) {
-  return createStorageClient({
-    driver: "postgres",
-    ...options
-  });
-}
-function pgStorage(options) {
-  return postgresStorage(options);
-}
-function pgliteStorage(options) {
-  return createStorageClient({
-    driver: "pglite",
-    ...options
-  });
-}
-function planetscaleStorage(options) {
-  return createStorageClient({
-    driver: "planetscale",
-    ...options
-  });
-}
-function libsqlStorage(options) {
-  return createStorageClient({
-    driver: "libsql",
-    ...options
-  });
-}
-function redisStorage(options) {
-  return createStorageClient({
-    driver: "redis",
-    ...options
-  });
-}
-function s3Storage(options) {
-  return createStorageClient({
-    driver: "s3",
-    ...options
-  });
-}
-function mongodbStorage(options) {
-  return createStorageClient({
-    driver: "mongodb",
-    ...options
-  });
-}
-function upstashStorage(options) {
-  return createStorageClient({
-    driver: "upstash",
-    ...options
-  });
-}
-function netlifyBlobsStorage(options) {
-  return createStorageClient({
-    driver: "netlify-blobs",
-    ...options
-  });
-}
-function vercelKVStorage(options) {
-  return createStorageClient({
-    driver: "vercel-kv",
-    ...options
-  });
-}
-function vercelBlobStorage(options) {
-  return createStorageClient({
-    driver: "vercel-blob",
-    ...options
-  });
-}
-async function mountNamespaces(storage, mounts) {
-  if (!mounts) {
-    return;
-  }
-  for (const [base, config] of Object.entries(mounts)) {
-    storage.mount(normalizeMountKey(base), await resolveDriver(config));
-  }
-}
-async function createFarmStorage(config = {}) {
-  if (isStorageInstance(config)) {
-    return config;
-  }
-  if (isStorageClient(config)) {
-    return config.createStorage();
-  }
-  const rootConfig = isStorageClient(config.client) ? config.client : config;
-  const storage = (0, import_unstorage.createStorage)({
-    driver: await resolveDriver(rootConfig)
-  });
-  try {
-    await mountNamespaces(storage, config.mounts);
-  } catch (error) {
-    await storage.dispose().catch(() => {
-    });
-    throw error;
-  }
-  return storage;
-}
-async function resolveStorageRuntimeClient(config) {
-  if (!config || isStorageInstance(config) || isStorageClient(config)) {
-    return void 0;
-  }
-  const client = config.client;
-  if (!client || isStorageInstance(client) || isStorageClient(client)) {
-    return void 0;
-  }
-  return typeof client === "function" ? await client() : client;
-}
-async function initStorage(config = {}) {
-  globalStorage = getActiveGlobalStorage();
-  const nextStorage = await createFarmStorage(config);
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(nextStorage);
-  if (previousStorage !== nextStorage) {
-    await previousStorage.dispose().catch(() => {
-    });
-  }
-  return globalStorage;
-}
-function getStorage(namespace) {
-  globalStorage = getActiveGlobalStorage();
-  const base = normalizeMountKey(namespace);
-  if (!base) {
-    return globalStorage;
-  }
-  const namespaced = (0, import_unstorage.prefixStorage)(globalStorage, base);
-  const store = globalStorage;
-  const prefix = `${base}:`;
-  const stripPrefix = /* @__PURE__ */ __name((key) => key.startsWith(prefix) ? key.slice(prefix.length) : key, "stripPrefix");
-  const viewUnwatchers = /* @__PURE__ */ new Set();
-  const releaseViewWatchers = /* @__PURE__ */ __name(async () => {
-    const current = [...viewUnwatchers];
-    viewUnwatchers.clear();
-    await Promise.all(current.map((unwatch) => unwatch()));
-  }, "releaseViewWatchers");
-  return {
-    ...namespaced,
-    // Scope the wipe to the namespace instead of the whole storage, and keep
-    // the caller's base so `clear("sessions")` cannot take unrelated keys with
-    // it. Dropping the argument silently widens a targeted clear into a
-    // namespace-wide delete.
-    async clear(base2, opts) {
-      const keys = await namespaced.getKeys(base2);
-      await Promise.all(keys.map((key) => namespaced.removeItem(key, opts)));
-    },
-    async watch(callback) {
-      const unwatch = await store.watch((event, key) => {
-        if (key.startsWith(prefix)) callback(event, stripPrefix(key));
-      });
-      viewUnwatchers.add(unwatch);
-      return async () => {
-        viewUnwatchers.delete(unwatch);
-        await unwatch();
-      };
-    },
-    async unwatch() {
-      await releaseViewWatchers();
-    },
-    async dispose() {
-      await releaseViewWatchers();
-    },
-    getMount(key = "") {
-      return store.getMount(prefix + key);
-    },
-    getMounts(base2 = "", options) {
-      return store.getMounts(prefix + base2, options).map((mount) => ({ ...mount, base: stripPrefix(mount.base) }));
-    }
-  };
-}
-async function disposeStorage() {
-  globalStorage = getActiveGlobalStorage();
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(createMemoryStorage());
-  await previousStorage.dispose().catch(() => {
-  });
-}
-var import_unstorage, import_memory, loadModule, DATABASE_CONNECTORS, GLOBAL_STORAGE_KEY, globalStorage;
-var init_storage = __esm({
-  "src/storage/index.ts"() {
-    "use strict";
-    import_unstorage = require("unstorage");
-    import_memory = __toESM(require("unstorage/drivers/memory"));
-    loadModule = /* @__PURE__ */ __name((specifier) => import(
-      /* @vite-ignore */
-      specifier
-    ), "loadModule");
-    DATABASE_CONNECTORS = {
-      sqlite: {
-        connector: "node-sqlite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-      },
-      "node-sqlite": {
-        connector: "node-sqlite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-      },
-      sqlite3: {
-        connector: "sqlite3",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/sqlite3"), "load")
-      },
-      "better-sqlite3": {
-        connector: "better-sqlite3",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/better-sqlite3"), "load")
-      },
-      postgres: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      postgresql: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      pg: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      mysql: {
-        connector: "mysql2",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-      },
-      mysql2: {
-        connector: "mysql2",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-      },
-      pglite: {
-        connector: "pglite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/pglite"), "load")
-      },
-      planetscale: {
-        connector: "planetscale",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/planetscale"), "load")
-      },
-      libsql: {
-        connector: "libsql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-      },
-      "libsql-node": {
-        connector: "libsql-node",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-      },
-      "libsql-http": {
-        connector: "libsql-http",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/http"), "load")
-      }
-    };
-    __name(createMemoryStorage, "createMemoryStorage");
-    GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
-    __name(readGlobalStorage, "readGlobalStorage");
-    __name(writeGlobalStorage, "writeGlobalStorage");
-    __name(getActiveGlobalStorage, "getActiveGlobalStorage");
-    globalStorage = getActiveGlobalStorage();
-    __name(normalizeMountKey, "normalizeMountKey");
-    __name(isDriverInstance, "isDriverInstance");
-    __name(isStorageInstance, "isStorageInstance");
-    __name(isStorageClient, "isStorageClient");
-    __name(isDatabaseDriverName, "isDatabaseDriverName");
-    __name(extractDriverOptions, "extractDriverOptions");
-    __name(loadBuiltinDriver, "loadBuiltinDriver");
-    __name(loadDatabaseDriver, "loadDatabaseDriver");
-    __name(resolveDriver, "resolveDriver");
-    __name(createStorageClientFromResolver, "createStorageClientFromResolver");
-    __name(defineStorageClient, "defineStorageClient");
-    __name(createStorageClient, "createStorageClient");
-    __name(driverStorage, "driverStorage");
-    __name(databaseStorage, "databaseStorage");
-    __name(memoryStorage, "memoryStorage");
-    __name(localStorage, "localStorage");
-    __name(sqliteStorage, "sqliteStorage");
-    __name(mysqlStorage, "mysqlStorage");
-    __name(mysql2Storage, "mysql2Storage");
-    __name(postgresStorage, "postgresStorage");
-    __name(pgStorage, "pgStorage");
-    __name(pgliteStorage, "pgliteStorage");
-    __name(planetscaleStorage, "planetscaleStorage");
-    __name(libsqlStorage, "libsqlStorage");
-    __name(redisStorage, "redisStorage");
-    __name(s3Storage, "s3Storage");
-    __name(mongodbStorage, "mongodbStorage");
-    __name(upstashStorage, "upstashStorage");
-    __name(netlifyBlobsStorage, "netlifyBlobsStorage");
-    __name(vercelKVStorage, "vercelKVStorage");
-    __name(vercelBlobStorage, "vercelBlobStorage");
-    __name(mountNamespaces, "mountNamespaces");
-    __name(createFarmStorage, "createFarmStorage");
-    __name(resolveStorageRuntimeClient, "resolveStorageRuntimeClient");
-    __name(initStorage, "initStorage");
-    __name(getStorage, "getStorage");
-    __name(disposeStorage, "disposeStorage");
-  }
-});
-
-// src/schema-capabilities.ts
-function assertNoSchemaListField(field, fieldPath, target) {
-  if (!field.list) {
-    return;
-  }
-  throw new Error(
-    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
-  );
-}
-var init_schema_capabilities = __esm({
-  "src/schema-capabilities.ts"() {
-    "use strict";
-    __name(assertNoSchemaListField, "assertNoSchemaListField");
-  }
-});
-
-// src/schema-primary-key.ts
-function assertSupportedPrimaryKeyField(location, field) {
-  if (!field.primaryKey || SUPPORTED_PRIMARY_KEY_TYPES.has(field.type)) {
-    return;
-  }
-  throw new Error(
-    `Schema primary-key field "${location}" uses unsupported type "${field.type}". Supported types are id, uuid, string, and integer.`
-  );
-}
-var SUPPORTED_PRIMARY_KEY_TYPES;
-var init_schema_primary_key = __esm({
-  "src/schema-primary-key.ts"() {
-    "use strict";
-    SUPPORTED_PRIMARY_KEY_TYPES = /* @__PURE__ */ new Set(["id", "uuid", "string", "integer"]);
-    __name(assertSupportedPrimaryKeyField, "assertSupportedPrimaryKeyField");
-  }
-});
-
-// src/schema-reference.ts
-function isDatabaseEnforcedReference(reference) {
-  return reference.enforced === void 0 || reference.enforced === "db";
-}
-var init_schema_reference = __esm({
-  "src/schema-reference.ts"() {
-    "use strict";
-    __name(isDatabaseEnforcedReference, "isDatabaseEnforcedReference");
-  }
-});
-
-// src/schema-resolve.ts
-function resolveSchemaModels(ownerKey, schema) {
-  const models = Object.fromEntries(
-    Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)])
-  );
-  for (const [modelKey, extension] of Object.entries(schema.extend || {})) {
-    const existing = models[modelKey];
-    models[modelKey] = {
-      ...existing || { fields: {} },
-      ...extension.name ? { name: extension.name } : {},
-      ...extension.description ? { description: extension.description } : {},
-      fields: {
-        ...existing?.fields,
-        ...extension.fields
-      },
-      constraints: [...existing?.constraints || [], ...extension.constraints || []],
-      meta: {
-        ...existing?.meta,
-        ...extension.meta
-      }
-    };
-  }
-  for (const [modelKey, override] of Object.entries(schema.override || {})) {
-    const existing = models[modelKey];
-    if (!existing) {
-      throw new Error(
-        `Schema override for "${ownerKey}.${modelKey}" is invalid because that model does not exist.`
-      );
-    }
-    const fields = {
-      ...existing.fields
-    };
-    for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {
-      const existingField = fields[fieldKey];
-      if (!existingField && !fieldOverride.type) {
-        throw new Error(
-          `Schema override for "${ownerKey}.${modelKey}.${fieldKey}" is missing a field type.`
-        );
-      }
-      fields[fieldKey] = {
-        ...existingField,
-        ...fieldOverride
-      };
-    }
-    models[modelKey] = {
-      ...existing,
-      ...override.name ? { name: override.name } : {},
-      ...override.description ? { description: override.description } : {},
-      fields,
-      constraints: override.constraints || existing.constraints,
-      meta: {
-        ...existing.meta,
-        ...override.meta
-      }
-    };
-  }
-  const resolvedModels = {};
-  for (const [modelKey, model] of Object.entries(models)) {
-    const modelName = model.name || modelKey;
-    const fieldNames = /* @__PURE__ */ new Set();
-    const resolvedFields = {};
-    for (const [fieldKey, field] of Object.entries(model.fields)) {
-      const fieldName = field.name || fieldKey;
-      assertSupportedPrimaryKeyField(`${ownerKey}.${modelKey}.${fieldKey}`, field);
-      if (fieldNames.has(fieldName)) {
-        throw new Error(
-          `Schema model "${ownerKey}.${modelKey}" contains duplicate field name "${fieldName}".`
-        );
-      }
-      fieldNames.add(fieldName);
-      resolvedFields[fieldKey] = {
-        ...field,
-        name: fieldName
-      };
-    }
-    const primaryKeyFields = Object.entries(resolvedFields).filter(([, field]) => field.primaryKey).map(([fieldKey]) => fieldKey);
-    if (primaryKeyFields.length > 1) {
-      throw new Error(
-        `Schema model "${ownerKey}.${modelKey}" defines multiple primary-key fields: ${primaryKeyFields.map((fieldKey) => `"${fieldKey}"`).join(", ")}. Composite primary keys are not supported.`
-      );
-    }
-    for (const constraint of model.constraints || []) {
-      for (const fieldKey of constraint.fields) {
-        if (!Object.prototype.hasOwnProperty.call(resolvedFields, fieldKey)) {
-          throw new Error(
-            `Schema ${constraint.type} constraint on "${ownerKey}.${modelKey}" references missing field "${fieldKey}".`
-          );
-        }
-      }
-    }
-    resolvedModels[modelKey] = {
-      ...model,
-      name: modelName,
-      fields: resolvedFields
-    };
-  }
-  for (const [modelKey, model] of Object.entries(resolvedModels)) {
-    for (const [fieldKey, field] of Object.entries(model.fields)) {
-      const reference = field.reference;
-      if (!reference || !Object.prototype.hasOwnProperty.call(resolvedModels, reference.model)) {
-        continue;
-      }
-      const referencedModel = resolvedModels[reference.model];
-      if (!Object.prototype.hasOwnProperty.call(referencedModel.fields, reference.field)) {
-        throw new Error(
-          `Schema reference "${ownerKey}.${modelKey}.${fieldKey}" targets missing field "${ownerKey}.${reference.model}.${reference.field}".`
-        );
-      }
-    }
-  }
-  return resolvedModels;
-}
-function cloneSchemaModel(model) {
-  return {
-    ...model,
-    fields: Object.fromEntries(
-      Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }])
-    ),
-    constraints: model.constraints ? [...model.constraints] : void 0,
-    meta: model.meta ? { ...model.meta } : void 0
-  };
-}
-var init_schema_resolve = __esm({
-  "src/schema-resolve.ts"() {
-    "use strict";
-    init_schema_primary_key();
-    __name(resolveSchemaModels, "resolveSchemaModels");
-    __name(cloneSchemaModel, "cloneSchemaModel");
-  }
-});
-
-// src/integration-orm.ts
-var integration_orm_exports = {};
-__export(integration_orm_exports, {
-  createIntegrationOrm: () => createIntegrationOrm,
-  farmIntegrationSchemaToOrmSchema: () => farmIntegrationSchemaToOrmSchema,
-  resolveIntegrationOrmRuntimeClient: () => resolveIntegrationOrmRuntimeClient
-});
-async function createIntegrationOrm(options) {
-  const [schema, client] = await Promise.all([
-    farmIntegrationSchemaToOrmSchema(options.schema),
-    resolveIntegrationOrmRuntimeClient(options)
-  ]);
-  if (!client) {
-    throw new Error(
-      "Schema-backed integration storage requires a runtime client at farm.config storage.client."
-    );
-  }
-  const { createOrmFromRuntime } = await import("@farming-labs/orm-runtime");
-  return createOrmFromRuntime({
-    schema,
-    client
-  });
-}
-async function resolveIntegrationOrmRuntimeClient(options) {
-  if (options.client !== void 0) {
-    return typeof options.client === "function" ? await options.client() : options.client;
-  }
-  return resolveStorageRuntimeClient(options.storage ?? options.config?.storage);
-}
-async function farmIntegrationSchemaToOrmSchema(schema) {
-  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {
-    for (const [fieldKey, fieldSchema] of Object.entries(modelSchema.fields)) {
-      assertNoSchemaListField(
-        fieldSchema,
-        `${modelKey}.${fieldKey}`,
-        "the Farm integration runtime ORM"
-      );
-    }
-  }
-  const orm = await import("@farming-labs/orm");
-  const models = {};
-  const resolvedModels = resolveSchemaModels("integration", schema);
-  for (const [modelKey, modelSchema] of Object.entries(resolvedModels)) {
-    models[modelKey] = orm.model({
-      table: modelSchema.name ?? modelKey,
-      fields: createOrmModelFields(orm, modelKey, modelSchema),
-      constraints: createOrmModelConstraints(modelSchema),
-      description: modelSchema.description
-    });
-  }
-  return orm.defineSchema(models);
-}
-function createOrmModelFields(orm, modelKey, modelSchema) {
-  return Object.fromEntries(
-    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [
-      fieldKey,
-      createOrmField(orm, modelKey, fieldKey, fieldSchema)
-    ])
-  );
-}
-function createOrmField(orm, modelKey, fieldKey, field) {
-  assertSupportedPrimaryKeyField(`integration.${modelKey}.${fieldKey}`, field);
-  let builder = createOrmFieldBuilder(orm, fieldKey, field);
-  if (!field.primaryKey && field.unique) {
-    builder = builder.unique();
-  }
-  if (!field.primaryKey && (field.nullable || field.required === false)) {
-    builder = builder.nullable();
-  }
-  if (field.default !== void 0) {
-    builder = field.type === "datetime" && field.default === "now" ? builder.defaultNow() : builder.default(field.default);
-  }
-  if (field.reference && isDatabaseEnforcedReference(field.reference)) {
-    builder = builder.references(`${field.reference.model}.${field.reference.field}`);
-  }
-  if (field.name && field.name !== fieldKey) {
-    builder = builder.map(field.name);
-  }
-  if (field.description) {
-    builder = builder.describe(field.description);
-  }
-  return builder;
-}
-function createOrmFieldBuilder(orm, fieldKey, field) {
-  if (field.primaryKey) {
-    if (field.type === "integer") {
-      return orm.id({ type: "integer" });
-    }
-    if (field.type === "string") {
-      return new orm.FieldBuilder({
-        kind: "id",
-        nullable: false,
-        unique: true,
-        idType: "string"
-      });
-    }
-    return orm.id();
-  }
-  switch (field.type) {
-    case "id":
-    case "uuid":
-      return orm.string();
-    case "string":
-    case "text":
-      return orm.string();
-    case "boolean":
-      return orm.boolean();
-    case "integer":
-      return orm.integer();
-    case "number":
-      return orm.decimal();
-    case "datetime":
-      return orm.datetime();
-    case "json":
-      return orm.json();
-    case "enum": {
-      if (!field.values?.length) {
-        throw new Error(`Integration schema enum field "${fieldKey}" must define values.`);
-      }
-      return orm.enumeration(field.values);
-    }
-    default:
-      throw new Error(
-        `Unsupported integration schema field type "${field.type}" for "${fieldKey}".`
-      );
-  }
-}
-function createOrmModelConstraints(modelSchema) {
-  const unique = [];
-  const indexes = [];
-  for (const constraint of modelSchema.constraints ?? []) {
-    if (!constraint.fields.length) {
-      continue;
-    }
-    const fields = constraint.fields;
-    if (constraint.type === "unique") {
-      unique.push(fields);
-    } else {
-      indexes.push(fields);
-    }
-  }
-  return {
-    unique,
-    indexes
-  };
-}
-var init_integration_orm = __esm({
-  "src/integration-orm.ts"() {
-    "use strict";
-    init_schema_capabilities();
-    init_schema_primary_key();
-    init_schema_reference();
-    init_schema_resolve();
-    init_storage();
-    __name(createIntegrationOrm, "createIntegrationOrm");
-    __name(resolveIntegrationOrmRuntimeClient, "resolveIntegrationOrmRuntimeClient");
-    __name(farmIntegrationSchemaToOrmSchema, "farmIntegrationSchemaToOrmSchema");
-    __name(createOrmModelFields, "createOrmModelFields");
-    __name(createOrmField, "createOrmField");
-    __name(createOrmFieldBuilder, "createOrmFieldBuilder");
-    __name(createOrmModelConstraints, "createOrmModelConstraints");
-  }
-});
-
-// src/agent-runtime.ts
-var agent_runtime_exports = {};
-__export(agent_runtime_exports, {
-  applyAgentRuntimeViteProxy: () => applyAgentRuntimeViteProxy,
-  createAgentRuntimeIntegration: () => createAgentRuntimeIntegration,
-  findAvailableAgentRuntimePort: () => findAvailableAgentRuntimePort,
-  normalizeAgentOrigin: () => normalizeAgentOrigin,
-  normalizeAgentRoutePrefix: () => normalizeAgentRoutePrefix,
-  proxyAgentRuntimeRequest: () => proxyAgentRuntimeRequest,
-  resolveProjectPackageBin: () => resolveProjectPackageBin,
-  startManagedAgentRuntime: () => startManagedAgentRuntime
-});
-module.exports = __toCommonJS(agent_runtime_exports);
-var import_node_child_process = require("child_process");
-var import_promises = require("fs/promises");
-var import_node_module = require("module");
-var import_node_net = require("net");
-var import_node_path = require("path");
-
-// src/routing/specificity.ts
-var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AmbiguousRouteError";
-  }
-};
-__name(_AmbiguousRouteError, "AmbiguousRouteError");
-var AmbiguousRouteError = _AmbiguousRouteError;
-var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "NonTerminalCatchAllRouteError";
-  }
-};
-__name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "DuplicateRouteParameterError";
-  }
-};
-__name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-var DuplicateRouteParameterError = _DuplicateRouteParameterError;
-var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "ReservedRouteParameterError";
-  }
-};
-__name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-var ReservedRouteParameterError = _ReservedRouteParameterError;
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-var SEGMENT_RANK = {
-  static: 4,
-  dynamic: 3,
-  "catch-all": 1,
-  "optional-catch-all": 0
-};
-var ROUTE_END_RANK = 2;
-function compareRouteSpecificity(left, right) {
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
-    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
-    if (leftRank !== rightRank) return rightRank - leftRank;
-  }
-  return 0;
-}
-__name(compareRouteSpecificity, "compareRouteSpecificity");
-var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
-function assertUniqueRouteParameters(pattern, syntax = "page") {
-  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
-  const names = /* @__PURE__ */ new Set();
-  for (const segment of splitRoutePattern(pattern, syntax)) {
-    const match = parameterPattern.exec(segment);
-    const name = match?.slice(1).find(Boolean);
-    if (!name) continue;
-    if (RESERVED_PARAMETER_NAMES.has(name)) {
-      throw new ReservedRouteParameterError(
-        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
-      );
-    }
-    if (names.has(name)) {
-      throw new DuplicateRouteParameterError(
-        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
-      );
-    }
-    names.add(name);
-  }
-}
-__name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-__name(splitRoutePattern, "splitRoutePattern");
-function assertTerminalCatchAll(pattern, syntax = "page") {
-  const segments = splitRoutePattern(pattern, syntax);
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const catchAllPattern = new RegExp(
-    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
-  );
-  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
-  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
-    throw new NonTerminalCatchAllRouteError(
-      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
-    );
-  }
-}
-__name(assertTerminalCatchAll, "assertTerminalCatchAll");
-function getRoutePatternSpecificity(pattern, syntax = "page") {
-  assertTerminalCatchAll(pattern, syntax);
-  return splitRoutePattern(pattern, syntax).map(
-    (segment) => getPatternSegmentSpecificity(segment, syntax)
-  );
-}
-__name(getRoutePatternSpecificity, "getRoutePatternSpecificity");
-function getPatternSegmentSpecificity(segment, syntax) {
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const supportsColonAndStar = syntax === "router";
-  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
-    return "optional-catch-all";
-  }
-  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
-    return "catch-all";
-  }
-  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
-    return "dynamic";
-  }
-  return "static";
-}
-__name(getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
-
-// src/utils/decode.ts
-function decodeRouteSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodeRouteSegment, "decodeRouteSegment");
-function canonicalizeRequestPathSegments(pathname) {
-  const segments = pathname.split("/").filter(Boolean);
-  if (!pathname.includes("%")) return segments;
-  return segments.map(decodeRouteSegment);
-}
-__name(canonicalizeRequestPathSegments, "canonicalizeRequestPathSegments");
-function canonicalizeRequestPathname(pathname) {
-  const encoded = pathname.includes("%");
-  if (!encoded && !pathname.includes("//")) return pathname;
-  const collapsed = pathname.replace(/\/{2,}/g, "/");
-  if (!encoded) return collapsed;
-  return collapsed.split("/").map((segment) => {
-    const decoded = decodeRouteSegment(segment);
-    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
-  }).join("/");
-}
-__name(canonicalizeRequestPathname, "canonicalizeRequestPathname");
-
-// src/plugins/route-pattern.ts
-function validateConfigRouteSource(source, field = "Config route source") {
-  if (typeof source !== "string" || source.length === 0) {
-    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
-  }
-  if (source.trim() !== source) {
-    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
-  }
-  if (!source.startsWith("/")) {
-    throw new Error(`${field} must start with "/".`);
-  }
-  if (source.includes("?") || source.includes("#")) {
-    throw new Error(`${field} must be a pathname without a query string or hash.`);
-  }
-  if (source.includes("\\") || Array.from(source).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  })) {
-    throw new Error(`${field} cannot contain backslashes or control characters.`);
-  }
-  assertBrowserStableRoutePath(source);
-  return source;
-}
-__name(validateConfigRouteSource, "validateConfigRouteSource");
-
-// src/integration-api.ts
-function defineIntegrationAPIOperation(operation2) {
-  return {
-    kind: "farm-integration-api-operation",
-    ...operation2
-  };
-}
-__name(defineIntegrationAPIOperation, "defineIntegrationAPIOperation");
-function operation(method, pathOrOptions, maybeOptions = {}) {
-  const hasExplicitPath = typeof pathOrOptions === "string";
-  const path = hasExplicitPath ? pathOrOptions : "";
-  const options = hasExplicitPath ? maybeOptions : {
-    ...maybeOptions,
-    ...pathOrOptions
-  };
-  return defineIntegrationAPIOperation({
-    path,
-    method,
-    __pathless: !hasExplicitPath,
-    ...options
-  });
-}
-__name(operation, "operation");
-function get(pathOrOptions, maybeOptions = {}) {
-  return operation("GET", pathOrOptions, maybeOptions);
-}
-__name(get, "get");
-function isOperation(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
-}
-__name(isOperation, "isOperation");
-function bindRoutePath(path, api2) {
-  const entries = Object.entries(api2).map(([key, value]) => {
-    if (isOperation(value)) {
-      return [
-        key,
-        {
-          ...value,
-          path,
-          __pathless: false
-        }
-      ];
-    }
-    if (value && typeof value === "object") {
-      return [key, bindRoutePath(path, value)];
-    }
-    return [key, value];
-  });
-  return Object.fromEntries(entries);
-}
-__name(bindRoutePath, "bindRoutePath");
-function route(path, definitionOrOperation, ...operations) {
-  if (isOperation(definitionOrOperation)) {
-    const allOperations = [definitionOrOperation, ...operations];
-    return Object.fromEntries(
-      allOperations.map((operation2) => [
-        operation2.method.toLowerCase(),
-        {
-          ...operation2,
-          path,
-          __pathless: false
-        }
-      ])
-    );
-  }
-  return bindRoutePath(path, definitionOrOperation);
-}
-__name(route, "route");
-function normalizeRouteSegment(segment) {
-  if (!segment) {
-    return "index";
-  }
-  if (segment.startsWith("[...") && segment.endsWith("]")) {
-    return segment.slice(4, -1) || "index";
-  }
-  if (segment.startsWith("[") && segment.endsWith("]")) {
-    return segment.slice(1, -1) || "index";
-  }
-  const matcherIndex = segment.indexOf("(");
-  if (matcherIndex > 0) {
-    return segment.slice(0, matcherIndex);
-  }
-  return camelCaseRouteSegment(segment);
-}
-__name(normalizeRouteSegment, "normalizeRouteSegment");
-function camelCaseRouteSegment(segment) {
-  return segment.replace(/-([a-zA-Z0-9])/g, (_match, value) => value.toUpperCase());
-}
-__name(camelCaseRouteSegment, "camelCaseRouteSegment");
-function getRouteClientSegments(path) {
-  const segments = path.split("/").filter(Boolean);
-  if (segments.length === 0) {
-    return ["index"];
-  }
-  const stripped = segments[0] === "api" && segments.length > 2 ? segments.slice(2) : segments.length > 1 ? segments.slice(1) : [segments[segments.length - 1]];
-  return stripped.map(normalizeRouteSegment).filter(Boolean);
-}
-__name(getRouteClientSegments, "getRouteClientSegments");
-function setRouteOperation(target, pathSegments, operation2) {
-  const [head, ...tail] = pathSegments;
-  if (!head) {
-    return;
-  }
-  if (tail.length === 0) {
-    const leaf = target[head] || {};
-    leaf[operation2.method.toLowerCase()] = {
-      ...operation2,
-      path: operation2.path,
-      __pathless: false
-    };
-    target[head] = leaf;
-    return;
-  }
-  const branch = target[head] || {};
-  target[head] = branch;
-  setRouteOperation(branch, tail, operation2);
-}
-__name(setRouteOperation, "setRouteOperation");
-function fromRoutes(routes) {
-  const definition = {};
-  for (const route2 of routes) {
-    if (!isOperation(route2.__operation)) {
-      continue;
-    }
-    setRouteOperation(definition, getRouteClientSegments(route2.path), {
-      ...route2.__operation,
-      path: route2.path,
-      __pathless: false
-    });
-  }
-  return definition;
-}
-__name(fromRoutes, "fromRoutes");
-var api = {
-  get,
-  route,
-  fromRoutes,
-  query(pathOrOptions, maybeOptions = {}) {
-    return operation("QUERY", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  post(pathOrOptions, maybeOptions = {}) {
-    return operation("POST", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  put(pathOrOptions, maybeOptions = {}) {
-    return operation("PUT", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  patch(pathOrOptions, maybeOptions = {}) {
-    return operation("PATCH", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  delete(pathOrOptions, maybeOptions = {}) {
-    return operation("DELETE", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  options(pathOrOptions, maybeOptions = {}) {
-    return operation(
-      "OPTIONS",
-      pathOrOptions,
-      maybeOptions
-    );
-  },
-  head(pathOrOptions, maybeOptions = {}) {
-    return operation(
-      "HEAD",
-      pathOrOptions,
-      maybeOptions
-    );
-  },
-  form: {
-    query(pathOrOptions, maybeOptions = {}) {
-      return operation("QUERY", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    post(pathOrOptions, maybeOptions = {}) {
-      return operation("POST", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    put(pathOrOptions, maybeOptions = {}) {
-      return operation("PUT", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    patch(pathOrOptions, maybeOptions = {}) {
-      return operation("PATCH", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    delete(pathOrOptions, maybeOptions = {}) {
-      return operation("DELETE", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    }
-  }
-};
-
-// src/request-context.ts
-var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
-function getRequestContextStore() {
-  const globalState = globalThis;
-  if (!globalState[REQUEST_CONTEXT_STORE_KEY]) {
-    globalState[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
-  }
-  return globalState[REQUEST_CONTEXT_STORE_KEY];
-}
-__name(getRequestContextStore, "getRequestContextStore");
-function getBucket(target) {
-  const requestContextStore = getRequestContextStore();
-  let bucket = requestContextStore.get(target);
-  if (!bucket) {
-    bucket = {
-      privateData: /* @__PURE__ */ new Map(),
-      exposedData: /* @__PURE__ */ new Map()
-    };
-    requestContextStore.set(target, bucket);
-  }
-  return bucket;
-}
-__name(getBucket, "getBucket");
-function setRequestContext(target, key, value, options = {}) {
-  const bucket = getBucket(target);
-  bucket.privateData.set(key, value);
-  if (options.exposeToPage) {
-    bucket.exposedData.set(key, value);
-  }
-}
-__name(setRequestContext, "setRequestContext");
-function getRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return bucket?.privateData.get(key);
-}
-__name(getRequestContext, "getRequestContext");
-function hasRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return bucket?.privateData.has(key) ?? false;
-}
-__name(hasRequestContext, "hasRequestContext");
-function deleteRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return false;
-  const removedPrivate = bucket.privateData.delete(key);
-  bucket.exposedData.delete(key);
-  return removedPrivate;
-}
-__name(deleteRequestContext, "deleteRequestContext");
-function clearRequestContext(target) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return;
-  bucket.privateData.clear();
-  bucket.exposedData.clear();
-}
-__name(clearRequestContext, "clearRequestContext");
-function getRequestContextSnapshot(target, options = {}) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return /* @__PURE__ */ new Map();
-  if (options.exposedOnly) {
-    return new Map(bucket.exposedData);
-  }
-  return new Map(bucket.privateData);
-}
-__name(getRequestContextSnapshot, "getRequestContextSnapshot");
-function copyRequestContext(source, target) {
-  const bucket = getRequestContextStore().get(source);
-  if (!bucket || source === target) return;
-  for (const [key, value] of bucket.privateData) {
-    setRequestContext(target, key, value, { exposeToPage: bucket.exposedData.has(key) });
-  }
-}
-__name(copyRequestContext, "copyRequestContext");
-
-// src/server-http.ts
-var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
-var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
-var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
-var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
-var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
-var MAX_FARM_SERVER_TIMEOUT = 2147483647;
-var _FarmRequestBodyError = class _FarmRequestBodyError extends Error {
-  constructor(code, status, message) {
-    super(message);
-    this.name = "FarmRequestBodyError";
-    this.code = code;
-    this.status = status;
-  }
-};
-__name(_FarmRequestBodyError, "FarmRequestBodyError");
-var FarmRequestBodyError = _FarmRequestBodyError;
-function resolveFarmServerConfig(config) {
-  const headersTimeout = parseFarmServerDuration(
-    config?.headersTimeout ?? DEFAULT_FARM_SERVER_HEADERS_TIMEOUT,
-    "server.headersTimeout"
-  );
-  const requestTimeout = parseFarmServerDuration(
-    config?.requestTimeout ?? DEFAULT_FARM_SERVER_REQUEST_TIMEOUT,
-    "server.requestTimeout"
-  );
-  if (headersTimeout > requestTimeout) {
-    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
-  }
-  return Object.freeze({
-    bodySizeLimit: parseBodySizeLimit(
-      config?.bodySizeLimit ?? DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
-      "server.bodySizeLimit"
-    ),
-    trustProxy: config?.trustProxy === true,
-    headersTimeout,
-    requestTimeout,
-    keepAliveTimeout: parseFarmServerDuration(
-      config?.keepAliveTimeout ?? DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT,
-      "server.keepAliveTimeout"
-    ),
-    gracefulShutdownTimeout: parseFarmServerDuration(
-      config?.gracefulShutdownTimeout ?? DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT,
-      "server.gracefulShutdownTimeout"
-    ),
-    health: resolveFarmServerHealthConfig(config?.health)
-  });
-}
-__name(resolveFarmServerConfig, "resolveFarmServerConfig");
-function parseFarmServerDuration(value, optionName = "duration") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    if (value > MAX_FARM_SERVER_TIMEOUT) {
-      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2];
-  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
-  const milliseconds = Math.floor(amount * multiplier);
-  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
-    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-  }
-  return milliseconds;
-}
-__name(parseFarmServerDuration, "parseFarmServerDuration");
-function resolveFarmServerHealthConfig(config) {
-  if (config === false || config && "enabled" in config && config.enabled === false) {
-    return Object.freeze({
-      enabled: false,
-      livenessPath: "/_farm/health/live",
-      readinessPath: "/_farm/health/ready"
-    });
-  }
-  const livenessPath = normalizeHealthPath(
-    config?.livenessPath ?? "/_farm/health/live",
-    "server.health.livenessPath"
-  );
-  const readinessPath = normalizeHealthPath(
-    config?.readinessPath ?? "/_farm/health/ready",
-    "server.health.readinessPath"
-  );
-  if (livenessPath === readinessPath) {
-    throw new TypeError("server.health livenessPath and readinessPath must be different");
-  }
-  return Object.freeze({ enabled: true, livenessPath, readinessPath });
-}
-__name(resolveFarmServerHealthConfig, "resolveFarmServerHealthConfig");
-function normalizeHealthPath(value, optionName) {
-  const path = value.trim();
-  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
-    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
-  }
-  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
-  assertBrowserStableRoutePath(normalized);
-  return normalized;
-}
-__name(normalizeHealthPath, "normalizeHealthPath");
-function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2] ?? "b";
-  const multiplier = {
-    b: 1,
-    kb: 1e3,
-    mb: 1e6,
-    gb: 1e9,
-    kib: 1024,
-    mib: 1048576,
-    gib: 1073741824
-  };
-  const bytes = Math.floor(amount * multiplier[unit]);
-  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  return bytes;
-}
-__name(parseBodySizeLimit, "parseBodySizeLimit");
-async function bufferFarmRequestBody(request, limit) {
-  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
-    return request;
-  }
-  const bytes = await readFarmRequestBody(request, limit);
-  const body = new Uint8Array(bytes.byteLength);
-  body.set(bytes);
-  const buffered = new Request(request, {
-    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
-    body: body.buffer
-  });
-  copyRequestContext(request, buffered);
-  return buffered;
-}
-__name(bufferFarmRequestBody, "bufferFarmRequestBody");
-async function readFarmRequestBody(request, limit) {
-  try {
-    validateContentLength(request.headers.get("content-length"), limit);
-  } catch (error) {
-    void request.body?.cancel(error).catch(() => {
-    });
-    throw error;
-  }
-  throwIfAborted(request.signal);
-  if (!request.body) return new Uint8Array();
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  const cancelBodyRead = /* @__PURE__ */ __name(() => {
-    void reader.cancel(request.signal.reason).catch(() => {
-    });
-  }, "cancelBodyRead");
-  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
-  try {
-    while (true) {
-      throwIfAborted(request.signal);
-      const { done, value } = await reader.read();
-      throwIfAborted(request.signal);
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-        void reader.cancel(error).catch(() => {
-        });
-        throw error;
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    if (request.signal.aborted) throwIfAborted(request.signal);
-    throw error;
-  } finally {
-    request.signal.removeEventListener("abort", cancelBodyRead);
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-__name(readFarmRequestBody, "readFarmRequestBody");
-function createFarmRequestBodyErrorResponse(error) {
-  if (!(error instanceof FarmRequestBodyError)) return null;
-  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
-    status: error.status,
-    headers: {
-      "cache-control": "no-store",
-      "content-type": "text/plain; charset=utf-8",
-      "x-content-type-options": "nosniff"
-    }
-  });
-}
-__name(createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
-function validateContentLength(value, limit) {
-  const contentLength = value?.trim();
-  if (!contentLength) return;
-  if (!/^\d+$/.test(contentLength)) {
-    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
-  }
-  if (Number(contentLength) > limit) {
-    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-  }
-}
-__name(validateContentLength, "validateContentLength");
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-__name(throwIfAborted, "throwIfAborted");
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkZ5HIWVDPcjs = require('./chunk-Z5HIWVDP.cjs');
+require('./chunk-SVRTJOUF.cjs');
+require('./chunk-G643DQCH.cjs');
+require('./chunk-EM6SBQKM.cjs');
+require('./chunk-UQZ4AYTH.cjs');
+require('./chunk-NZKJGRB3.cjs');
+require('./chunk-DVM4FKZL.cjs');
+require('./chunk-US2QVW3E.cjs');
+require('./chunk-BIDYX3SL.cjs');
+require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
 
-// src/integrations.ts
-var FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
-var FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
-function takeForwardedIntegrationSetCookies(context) {
-  const cookies = context.req.get(FARM_INTEGRATION_SET_COOKIES_KEY);
-  if (cookies && cookies.length > 0) {
-    context.req.delete(FARM_INTEGRATION_SET_COOKIES_KEY);
-    return cookies;
-  }
-  if (cookies) {
-    context.req.delete(FARM_INTEGRATION_SET_COOKIES_KEY);
-  }
-  return [];
-}
-__name(takeForwardedIntegrationSetCookies, "takeForwardedIntegrationSetCookies");
-function appendIntegrationForwardedCookies(response, cookies) {
-  if (cookies.length === 0) return response;
-  const headers = new Headers(response.headers);
-  for (const cookie of cookies) {
-    headers.append("set-cookie", cookie);
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(appendIntegrationForwardedCookies, "appendIntegrationForwardedCookies");
-function defineTypedIntegrationRoute(method, path, input) {
-  return {
-    path,
-    method,
-    middleware: input.middleware,
-    before: input.before,
-    after: input.after,
-    rawBody: input.rawBody,
-    bodyFormat: input.bodyFormat,
-    input: normalizeIntegrationRouteInputSchemas(input),
-    handler: input.handler,
-    __operation: defineIntegrationAPIOperation({
-      path,
-      method,
-      bodyFormat: input.bodyFormat,
-      responseFormat: input.responseFormat,
-      headers: input.headers,
-      credentials: input.credentials,
-      isServer: input.isServer
-    })
-  };
-}
-__name(defineTypedIntegrationRoute, "defineTypedIntegrationRoute");
-function createIntegrationRouteFactory() {
-  return {
-    get(path, input) {
-      return defineTypedIntegrationRoute(
-        "GET",
-        path,
-        input
-      );
-    },
-    post(path, input) {
-      return defineTypedIntegrationRoute(
-        "POST",
-        path,
-        {
-          bodyFormat: "json",
-          ...input
-        }
-      );
-    },
-    query(path, input) {
-      return defineTypedIntegrationRoute("QUERY", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    put(path, input) {
-      return defineTypedIntegrationRoute(
-        "PUT",
-        path,
-        {
-          bodyFormat: "json",
-          ...input
-        }
-      );
-    },
-    patch(path, input) {
-      return defineTypedIntegrationRoute("PATCH", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    delete(path, input) {
-      return defineTypedIntegrationRoute("DELETE", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    options(path, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path, input);
-    },
-    head(path, input) {
-      return defineTypedIntegrationRoute(
-        "HEAD",
-        path,
-        input
-      );
-    }
-  };
-}
-__name(createIntegrationRouteFactory, "createIntegrationRouteFactory");
-function createIntegrationRoute(_schema) {
-  return createIntegrationRouteFactory();
-}
-__name(createIntegrationRoute, "createIntegrationRoute");
-var integrationRoute = createIntegrationRouteFactory();
-var INTEGRATION_REQUEST_DISPATCHER_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRequestDispatcher");
-function isIntegrationEndpointRoute(value) {
-  return !!value && typeof value === "object" && typeof value.path === "string" && typeof value.handler === "function";
-}
-__name(isIntegrationEndpointRoute, "isIntegrationEndpointRoute");
-function flattenIntegrationEndpoints(endpoints) {
-  if (!endpoints) {
-    return [];
-  }
-  if (Array.isArray(endpoints)) {
-    return endpoints.flatMap((endpoint) => flattenIntegrationEndpoints(endpoint));
-  }
-  if (isIntegrationEndpointRoute(endpoints)) {
-    return [endpoints];
-  }
-  if (typeof endpoints === "object") {
-    return Object.values(endpoints).flatMap((endpoint) => flattenIntegrationEndpoints(endpoint));
-  }
-  return [];
-}
-__name(flattenIntegrationEndpoints, "flattenIntegrationEndpoints");
-function defineIntegration(integration) {
-  const category = integration.category ?? integration.slot;
-  if (!category) {
-    throw new Error("Integration category is required.");
-  }
-  if (integration.category && integration.slot && integration.category !== integration.slot) {
-    throw new Error("Integration category and slot must match when both are provided.");
-  }
-  const routeFactory = createIntegrationRoute(integration.schema);
-  const routes = typeof integration.routes === "function" ? integration.routes({
-    route: routeFactory,
-    integrationRoute: routeFactory
-  }) : integration.routes;
-  const endpoints = typeof integration.endpoints === "function" ? integration.endpoints({
-    endpoint: routeFactory,
-    route: routeFactory,
-    integrationRoute: routeFactory
-  }) : integration.endpoints;
-  const endpointRoutes = flattenIntegrationEndpoints(endpoints);
-  const allRoutes = routes?.length || endpointRoutes.length ? [...routes || [], ...endpointRoutes] : void 0;
-  for (const route2 of allRoutes || []) {
-    assertUniqueRouteParameters(route2.path, "api");
-    validateConfigRouteSource(route2.path, `Integration route "${route2.path}"`);
-    assertTerminalCatchAll(route2.path, "api");
-  }
-  const derivedApi = integration.api || (allRoutes?.length ? api.fromRoutes(
-    allRoutes
-  ) : void 0);
-  return {
-    kind: "farm-integration",
-    ...integration,
-    endpoints,
-    routes: allRoutes,
-    api: derivedApi,
-    category,
-    slot: category
-  };
-}
-__name(defineIntegration, "defineIntegration");
-async function emitIntegrationLog(integration, event) {
-  try {
-    await integration.log?.(event);
-  } catch {
-  }
-}
-__name(emitIntegrationLog, "emitIntegrationLog");
-var INTEGRATION_DATA_HEADER = "x-farm-integration-data";
-var INTEGRATION_DATA_HEADER_MAX_LENGTH = 16 * 1024;
-var BLOCKED_INTEGRATION_DATA_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function isFarmIntegrationData(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isFarmIntegrationData, "isFarmIntegrationData");
-function isPlainIntegrationDataObject(value) {
-  if (!isFarmIntegrationData(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-__name(isPlainIntegrationDataObject, "isPlainIntegrationDataObject");
-function sanitizeIntegrationDataValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeIntegrationDataValue(item));
-  }
-  if (!isPlainIntegrationDataObject(value)) {
-    return value;
-  }
-  const sanitized = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (BLOCKED_INTEGRATION_DATA_KEYS.has(key)) {
-      continue;
-    }
-    sanitized[key] = sanitizeIntegrationDataValue(item);
-  }
-  return sanitized;
-}
-__name(sanitizeIntegrationDataValue, "sanitizeIntegrationDataValue");
-function normalizeIntegrationData(value) {
-  if (!isFarmIntegrationData(value)) {
-    return {};
-  }
-  const sanitized = sanitizeIntegrationDataValue(value);
-  return isFarmIntegrationData(sanitized) ? sanitized : {};
-}
-__name(normalizeIntegrationData, "normalizeIntegrationData");
-function getIntegrationDataHeaderByteLength(value) {
-  return new TextEncoder().encode(value).byteLength;
-}
-__name(getIntegrationDataHeaderByteLength, "getIntegrationDataHeaderByteLength");
-function parseIntegrationDataHeader(request) {
-  const raw = request.headers.get(INTEGRATION_DATA_HEADER);
-  if (!raw) {
-    return {};
-  }
-  if (getIntegrationDataHeaderByteLength(raw) > INTEGRATION_DATA_HEADER_MAX_LENGTH) {
-    return {};
-  }
-  try {
-    const value = JSON.parse(raw);
-    return normalizeIntegrationData(value);
-  } catch {
-    return {};
-  }
-}
-__name(parseIntegrationDataHeader, "parseIntegrationDataHeader");
-function resolveIntegrationData(request, data) {
-  return {
-    ...parseIntegrationDataHeader(request),
-    ...normalizeIntegrationData(data)
-  };
-}
-__name(resolveIntegrationData, "resolveIntegrationData");
-var INTEGRATION_ROUTE_SEGMENTS = /* @__PURE__ */ Symbol("farm.integrationRouteSegments");
-var EMPTY_NORMALIZED_INTEGRATION_ROUTES = [];
-var normalizedIntegrationRoutesCache = /* @__PURE__ */ new WeakMap();
-function normalizeIntegrationRoutes(routes) {
-  if (routes.length === 0) {
-    return EMPTY_NORMALIZED_INTEGRATION_ROUTES;
-  }
-  const cached = normalizedIntegrationRoutesCache.get(routes);
-  if (cached) {
-    return cached;
-  }
-  const normalized = routes.map((route2, index) => {
-    assertUniqueRouteParameters(route2.path, "api");
-    return {
-      index,
-      route: {
-        ...route2,
-        methods: normalizeIntegrationRouteMethods(route2),
-        input: normalizeIntegrationRouteInputSchemas(route2),
-        [INTEGRATION_ROUTE_SEGMENTS]: splitPath(route2.path)
-      },
-      specificity: getRoutePatternSpecificity(route2.path, "api")
-    };
-  }).sort(
-    (left, right) => compareRouteSpecificity(left.specificity, right.specificity) || left.index - right.index
-  ).map(({ route: route2 }) => route2);
-  normalizedIntegrationRoutesCache.set(routes, normalized);
-  return normalized;
-}
-__name(normalizeIntegrationRoutes, "normalizeIntegrationRoutes");
-function normalizeIntegrationRouteMethods(route2) {
-  const input = route2.methods && route2.methods.length > 0 ? [...route2.methods] : route2.method ? [route2.method] : ["ALL"];
-  return input.map((method) => String(method).toUpperCase());
-}
-__name(normalizeIntegrationRouteMethods, "normalizeIntegrationRouteMethods");
-function normalizeIntegrationRouteInputSchemas(route2) {
-  const input = {
-    ...route2.input
-  };
-  if (route2.body) {
-    input.body = route2.body;
-  }
-  if (route2.query) {
-    input.query = route2.query;
-  }
-  return input.body || input.query ? input : void 0;
-}
-__name(normalizeIntegrationRouteInputSchemas, "normalizeIntegrationRouteInputSchemas");
-async function validateIntegrationRouteInput(route2, request, url) {
-  if (request.method.toUpperCase() === "QUERY" && !request.headers.has("content-type")) {
-    return {
-      success: false,
-      response: Response.json(
-        {
-          error: "Invalid QUERY request",
-          message: "QUERY requests must include a Content-Type header."
-        },
-        { status: 400 }
-      )
-    };
-  }
-  const schemas = route2.input;
-  if (!schemas?.body && !schemas?.query) {
-    return {
-      success: true,
-      input: {}
-    };
-  }
-  const input = {};
-  const issues = [];
-  if (schemas.query) {
-    const queryResult = await parseIntegrationInputSchema(
-      "query",
-      schemas.query,
-      createQueryInput(url.searchParams)
-    );
-    if (queryResult.success) {
-      input.query = queryResult.data;
-    } else {
-      issues.push(...queryResult.issues);
-    }
-  }
-  if (schemas.body) {
-    const bodyInput = await readIntegrationValidationBody(
-      request,
-      getIntegrationRouteBodyFormat(route2)
-    );
-    if (bodyInput.success) {
-      const bodyResult = await parseIntegrationInputSchema("body", schemas.body, bodyInput.data);
-      if (bodyResult.success) {
-        input.body = bodyResult.data;
-      } else {
-        issues.push(...bodyResult.issues);
-      }
-    } else {
-      issues.push(bodyInput.issue);
-    }
-  }
-  if (issues.length > 0) {
-    return {
-      success: false,
-      response: createIntegrationValidationResponse(issues)
-    };
-  }
-  return {
-    success: true,
-    input
-  };
-}
-__name(validateIntegrationRouteInput, "validateIntegrationRouteInput");
-async function parseIntegrationInputSchema(source, schema, value) {
-  const parser = schema.safeParseAsync || schema.safeParse;
-  if (parser) {
-    const result = await parser.call(schema, value);
-    if (result.success) {
-      return {
-        success: true,
-        data: result.data
-      };
-    }
-    return {
-      success: false,
-      issues: normalizeIntegrationValidationIssues(source, result.error)
-    };
-  }
-  if (schema["~standard"]?.validate) {
-    const result = await schema["~standard"].validate(value);
-    if ("value" in result) {
-      return {
-        success: true,
-        data: result.value
-      };
-    }
-    return {
-      success: false,
-      issues: normalizeIntegrationValidationIssues(source, {
-        issues: result.issues
-      })
-    };
-  }
-  if (schema.parse) {
-    try {
-      return {
-        success: true,
-        data: await schema.parse(value)
-      };
-    } catch (error) {
-      return {
-        success: false,
-        issues: normalizeIntegrationValidationIssues(
-          source,
-          normalizeIntegrationValidationError(error)
-        )
-      };
-    }
-  }
-  return {
-    success: false,
-    issues: [
-      {
-        source,
-        message: "Input schema must expose safeParse, safeParseAsync, parse, or ~standard.validate."
-      }
-    ]
-  };
-}
-__name(parseIntegrationInputSchema, "parseIntegrationInputSchema");
-function createIntegrationValidationResponse(issues) {
-  return Response.json(
-    {
-      error: "Integration route input validation failed",
-      issues
-    },
-    {
-      status: 400
-    }
-  );
-}
-__name(createIntegrationValidationResponse, "createIntegrationValidationResponse");
-function normalizeIntegrationValidationIssues(source, error) {
-  if (Array.isArray(error.issues) && error.issues.length > 0) {
-    return error.issues.map((issue) => ({
-      source,
-      path: normalizeIntegrationValidationPath(issue.path),
-      code: issue.code,
-      message: issue.message || "Invalid input"
-    }));
-  }
-  return [
-    {
-      source,
-      path: [],
-      message: error.message || "Invalid input"
-    }
-  ];
-}
-__name(normalizeIntegrationValidationIssues, "normalizeIntegrationValidationIssues");
-function normalizeIntegrationValidationPath(path) {
-  return (path || []).map((segment) => {
-    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
-    return typeof key === "symbol" ? key.description || key.toString() : key;
-  });
-}
-__name(normalizeIntegrationValidationPath, "normalizeIntegrationValidationPath");
-function normalizeIntegrationValidationError(error) {
-  if (error && typeof error === "object") {
-    return error;
-  }
-  return {
-    message: error instanceof Error ? error.message : String(error || "Invalid input")
-  };
-}
-__name(normalizeIntegrationValidationError, "normalizeIntegrationValidationError");
-async function readIntegrationValidationBody(request, format) {
-  if (request.method === "GET" || request.method === "HEAD" || format === "none") {
-    return {
-      success: true,
-      data: void 0
-    };
-  }
-  try {
-    if (format === "form") {
-      return {
-        success: true,
-        data: createFormInput(await request.clone().formData())
-      };
-    }
-    const text = await request.clone().text();
-    if (text.trim().length === 0) {
-      return {
-        success: true,
-        data: void 0
-      };
-    }
-    return {
-      success: true,
-      data: JSON.parse(text)
-    };
-  } catch (error) {
-    return {
-      success: false,
-      issue: {
-        source: "body",
-        path: [],
-        message: format === "json" ? "Expected a valid JSON request body." : error instanceof Error && error.message ? error.message : "Could not parse request body."
-      }
-    };
-  }
-}
-__name(readIntegrationValidationBody, "readIntegrationValidationBody");
-function getIntegrationRouteBodyFormat(route2) {
-  return route2.bodyFormat || route2.__operation?.bodyFormat || "json";
-}
-__name(getIntegrationRouteBodyFormat, "getIntegrationRouteBodyFormat");
-function createIntegrationRouteArgs(input) {
-  let clientPromise;
-  let ormPromise;
-  const getClient = /* @__PURE__ */ __name(() => {
-    clientPromise ?? (clientPromise = Promise.resolve().then(() => (init_storage(), storage_exports)).then(
-      ({ resolveStorageRuntimeClient: resolveStorageRuntimeClient2 }) => resolveStorageRuntimeClient2(input.config.storage)
-    ));
-    return clientPromise;
-  }, "getClient");
-  const getOrm = /* @__PURE__ */ __name(() => {
-    if (!input.integration.schema) {
-      throw new Error(
-        `Integration "${input.integration.type}" does not define a schema for ctx.args.db.`
-      );
-    }
-    ormPromise ?? (ormPromise = Promise.resolve().then(() => (init_integration_orm(), integration_orm_exports)).then(
-      ({ createIntegrationOrm: createIntegrationOrm2 }) => createIntegrationOrm2({
-        schema: input.integration.schema,
-        config: input.config
-      })
-    ));
-    return ormPromise;
-  }, "getOrm");
-  return {
-    db: createLazyIntegrationOrmClient(getOrm),
-    getDb: getOrm,
-    storage: {
-      getClient,
-      getOrm
-    }
-  };
-}
-__name(createIntegrationRouteArgs, "createIntegrationRouteArgs");
-function createLazyIntegrationOrmClient(resolveOrm) {
-  const modelProxyCache = /* @__PURE__ */ new Map();
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "then") {
-          return void 0;
-        }
-        if (prop === "transaction" || prop === "batch") {
-          return async (...args) => {
-            const orm = await resolveOrm();
-            const member = orm[prop];
-            if (typeof member !== "function") {
-              throw new Error(`Integration ORM does not expose "${String(prop)}".`);
-            }
-            return member.apply(orm, args);
-          };
-        }
-        if (prop === "$driver") {
-          return void 0;
-        }
-        if (!modelProxyCache.has(prop)) {
-          modelProxyCache.set(prop, createLazyIntegrationOrmModel(resolveOrm, prop));
-        }
-        return modelProxyCache.get(prop);
-      }
-    }
-  );
-}
-__name(createLazyIntegrationOrmClient, "createLazyIntegrationOrmClient");
-function createLazyIntegrationOrmModel(resolveOrm, modelName) {
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "then") {
-          return void 0;
-        }
-        return async (...args) => {
-          const orm = await resolveOrm();
-          const model = orm[modelName];
-          const member = model?.[prop];
-          if (typeof member !== "function") {
-            throw new Error(
-              `Integration ORM model "${String(modelName)}" does not expose "${String(prop)}".`
-            );
-          }
-          return member.apply(model, args);
-        };
-      }
-    }
-  );
-}
-__name(createLazyIntegrationOrmModel, "createLazyIntegrationOrmModel");
-async function runIntegrationRouteBeforeHooks(route2, request, context) {
-  const hookContext = context;
-  hookContext.response = void 0;
-  for (const hook of route2.before || []) {
-    const response = await hook(request, hookContext);
-    if (response) {
-      hookContext.response = response;
-      return response;
-    }
-    if (hookContext.response) {
-      return hookContext.response;
-    }
-  }
-  return void 0;
-}
-__name(runIntegrationRouteBeforeHooks, "runIntegrationRouteBeforeHooks");
-async function runIntegrationRouteAfterHooks(route2, request, context, response) {
-  const hookContext = context;
-  let currentResponse = response;
-  for (const hook of route2.after || []) {
-    hookContext.response = currentResponse;
-    const nextResponse = await hook(request, hookContext);
-    currentResponse = nextResponse || hookContext.response || currentResponse;
-  }
-  hookContext.response = currentResponse;
-  return currentResponse;
-}
-__name(runIntegrationRouteAfterHooks, "runIntegrationRouteAfterHooks");
-function createQueryInput(searchParams) {
-  const input = {};
-  searchParams.forEach((value, key) => {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
-    const existing = input[key];
-    if (existing === void 0) {
-      input[key] = value;
-      return;
-    }
-    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-  });
-  return input;
-}
-__name(createQueryInput, "createQueryInput");
-function createFormInput(formData) {
-  const input = {};
-  formData.forEach((value, key) => {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
-    const existing = input[key];
-    if (existing === void 0) {
-      input[key] = value;
-      return;
-    }
-    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-  });
-  return input;
-}
-__name(createFormInput, "createFormInput");
-async function dispatchIntegrationRequest(runtime, request, options = {}) {
-  try {
-    request = await bufferFarmRequestBody(
-      request,
-      resolveFarmServerConfig(runtime.config.server).bodySizeLimit
-    );
-  } catch (error) {
-    const response = createFarmRequestBodyErrorResponse(error);
-    if (response) return response;
-    throw error;
-  }
-  const integration = runtime.integration;
-  const url = new URL(request.url);
-  const pathname = url.pathname;
-  const requestId = request.headers.get("x-request-id") || options.currentRequest?.headers.get("x-request-id") || String(Date.now());
-  const routes = normalizeIntegrationRoutes(integration.routes || []);
-  const pathSegments = canonicalizeRequestPathSegments(pathname);
-  const method = normalizeIntegrationRequestMethod(request.method);
-  const middleware = [...integration.middleware || []];
-  const forwardedSetCookies = [];
-  for (const entry of middleware) {
-    const params = resolveMatcherParams(entry.matcher, pathname);
-    if (!params) {
-      continue;
-    }
-    const handlerContext = createServerIntegrationHandlerContext({
-      runtime,
-      route: {
-        kind: "middleware",
-        path: normalizeMatcher(entry.matcher),
-        methods: ["ALL"]
-      },
-      request,
-      params,
-      pathname,
-      requestId,
-      currentRequest: options.currentRequest,
-      data: options.data,
-      internal: options.internal === true
-    });
-    const startedAt = Date.now();
-    await emitIntegrationLog(integration, {
-      category: integration.category,
-      slot: integration.category,
-      type: integration.type,
-      phase: "request:start",
-      route: {
-        kind: "middleware",
-        path: normalizeMatcher(entry.matcher),
-        methods: ["ALL"]
-      },
-      request,
-      requestId,
-      context: handlerContext.req.snapshot()
-    });
-    try {
-      const response = await entry.handler(request, handlerContext);
-      forwardedSetCookies.push(...takeForwardedIntegrationSetCookies(handlerContext));
-      if (response) {
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "middleware",
-            path: normalizeMatcher(entry.matcher),
-            methods: ["ALL"]
-          },
-          request,
-          response,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return appendIntegrationForwardedCookies(response, forwardedSetCookies);
-      }
-      await emitIntegrationLog(integration, {
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:end",
-        route: {
-          kind: "middleware",
-          path: normalizeMatcher(entry.matcher),
-          methods: ["ALL"]
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        context: handlerContext.req.snapshot()
-      });
-    } catch (error) {
-      await emitIntegrationLog(integration, {
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:error",
-        route: {
-          kind: "middleware",
-          path: normalizeMatcher(entry.matcher),
-          methods: ["ALL"]
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        error,
-        context: handlerContext.req.snapshot()
-      });
-      throw error;
-    }
-  }
-  for (const route2 of routes) {
-    const params = method && matchesMethod(route2.methods, method) ? matchPathSegments(route2[INTEGRATION_ROUTE_SEGMENTS], pathSegments) : null;
-    if (!params) {
-      continue;
-    }
-    const handlerContext = createServerIntegrationHandlerContext({
-      runtime,
-      route: {
-        kind: "route",
-        path: route2.path,
-        methods: route2.methods
-      },
-      request,
-      params,
-      pathname,
-      requestId,
-      currentRequest: options.currentRequest,
-      data: options.data,
-      internal: options.internal === true
-    });
-    const startedAt = Date.now();
-    await emitIntegrationLog(integration, {
-      category: integration.category,
-      slot: integration.category,
-      type: integration.type,
-      phase: "request:start",
-      route: {
-        kind: "route",
-        path: route2.path,
-        methods: route2.methods
-      },
-      request,
-      requestId,
-      context: handlerContext.req.snapshot()
-    });
-    try {
-      const validation = await validateIntegrationRouteInput(route2, request, url);
-      if (!validation.success) {
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.methods
-          },
-          request,
-          response: validation.response,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return appendIntegrationForwardedCookies(validation.response, forwardedSetCookies);
-      }
-      handlerContext.input = validation.input;
-      for (const middlewareEntry of route2.middleware || []) {
-        const middlewareResponse = await middlewareEntry.handler(request, handlerContext);
-        forwardedSetCookies.push(...takeForwardedIntegrationSetCookies(handlerContext));
-        if (middlewareResponse) {
-          await emitIntegrationLog(integration, {
-            category: integration.category,
-            slot: integration.category,
-            type: integration.type,
-            phase: "request:end",
-            route: {
-              kind: "route",
-              path: route2.path,
-              methods: route2.methods
-            },
-            request,
-            response: middlewareResponse,
-            requestId,
-            durationMs: Date.now() - startedAt,
-            context: handlerContext.req.snapshot()
-          });
-          return appendIntegrationForwardedCookies(middlewareResponse, forwardedSetCookies);
-        }
-      }
-      const beforeResponse = await runIntegrationRouteBeforeHooks(route2, request, handlerContext);
-      if (beforeResponse) {
-        const response2 = await runIntegrationRouteAfterHooks(
-          route2,
-          request,
-          handlerContext,
-          beforeResponse
-        );
-        await emitIntegrationLog(integration, {
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.methods
-          },
-          request,
-          response: response2,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return appendIntegrationForwardedCookies(response2, forwardedSetCookies);
-      }
-      const handlerResponse = await route2.handler(request, handlerContext);
-      const response = await runIntegrationRouteAfterHooks(
-        route2,
-        request,
-        handlerContext,
-        handlerResponse
-      );
-      await emitIntegrationLog(integration, {
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:end",
-        route: {
-          kind: "route",
-          path: route2.path,
-          methods: route2.methods
-        },
-        request,
-        response,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        context: handlerContext.req.snapshot()
-      });
-      return appendIntegrationForwardedCookies(response, forwardedSetCookies);
-    } catch (error) {
-      await emitIntegrationLog(integration, {
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:error",
-        route: {
-          kind: "route",
-          path: route2.path,
-          methods: route2.methods
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        error,
-        context: handlerContext.req.snapshot()
-      });
-      throw error;
-    }
-  }
-  if (forwardedSetCookies.length > 0) {
-    options.onForwardedCookies?.(forwardedSetCookies);
-  }
-  return null;
-}
-__name(dispatchIntegrationRequest, "dispatchIntegrationRequest");
-globalThis[INTEGRATION_REQUEST_DISPATCHER_KEY] = dispatchIntegrationRequest;
-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 normalizeIntegrationRequestMethod(method) {
-  return method ? method.toUpperCase() : void 0;
-}
-__name(normalizeIntegrationRequestMethod, "normalizeIntegrationRequestMethod");
-function matchesMethod(methods, normalizedMethod) {
-  return methods.some((candidate) => candidate === "ALL" || candidate === normalizedMethod);
-}
-__name(matchesMethod, "matchesMethod");
-function resolveMatcherParams(matcher, pathname) {
-  if (!matcher) {
-    return {};
-  }
-  const list = Array.isArray(matcher) ? matcher : [matcher];
-  let canonicalPathname;
-  let canonicalSegments;
-  for (const item of list) {
-    if (item === "/(.*)" || item === "*") {
-      return {};
-    }
-    if (item.endsWith("(.*)")) {
-      canonicalPathname ?? (canonicalPathname = canonicalizeRequestPathname(pathname));
-      const prefix = item.slice(0, -4);
-      if (canonicalPathname === prefix || canonicalPathname.startsWith(`${prefix}/`)) {
-        return {};
-      }
-      continue;
-    }
-    canonicalSegments ?? (canonicalSegments = canonicalizeRequestPathSegments(pathname));
-    const params = matchPathSegments(splitPath(item), canonicalSegments);
-    if (params) {
-      return params;
-    }
-  }
-  return null;
-}
-__name(resolveMatcherParams, "resolveMatcherParams");
-function matchPathSegments(routeSegments, pathSegments) {
-  const params = {};
-  let routeIndex = 0;
-  let pathIndex = 0;
-  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
-    const routeSegment = routeSegments[routeIndex];
-    const pathSegment = pathSegments[pathIndex];
-    if (isCatchAllSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex);
-      return params;
-    }
-    if (isDynamicSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegment;
-      routeIndex += 1;
-      pathIndex += 1;
-      continue;
-    }
-    if (routeSegment !== pathSegment) {
-      return null;
-    }
-    routeIndex += 1;
-    pathIndex += 1;
-  }
-  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
-    return params;
-  }
-  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
-    params[getSegmentParamName(routeSegments[routeIndex])] = [];
-    return params;
-  }
-  return null;
-}
-__name(matchPathSegments, "matchPathSegments");
-function splitPath(value) {
-  return value.split("/").filter(Boolean);
-}
-__name(splitPath, "splitPath");
-function isDynamicSegment(segment) {
-  return segment.startsWith("[") && segment.endsWith("]");
-}
-__name(isDynamicSegment, "isDynamicSegment");
-function isCatchAllSegment(segment) {
-  return segment.startsWith("[...") && segment.endsWith("]");
-}
-__name(isCatchAllSegment, "isCatchAllSegment");
-function getSegmentParamName(segment) {
-  if (isCatchAllSegment(segment)) {
-    return segment.slice(4, -1);
-  }
-  return segment.slice(1, -1);
-}
-__name(getSegmentParamName, "getSegmentParamName");
-function normalizeMatcher(matcher) {
-  if (!matcher) {
-    return "/(.*)";
-  }
-  return typeof matcher === "string" ? matcher : matcher.join(", ");
-}
-__name(normalizeMatcher, "normalizeMatcher");
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
 // src/agent-runtime.ts
+var _child_process = require('child_process');
+var _promises = require('fs/promises');
+var _module = require('module');
+var _net = require('net');
+var _path = require('path');
 var AGENT_RUNTIME_METHODS = [
   "GET",
   "HEAD",
@@ -2775,7 +59,7 @@ function createAgentRuntimeIntegration(options) {
     provider,
     routePrefix,
     routePrefixes,
-    getOrigin: /* @__PURE__ */ __name(() => state.origin ?? resolveConfiguredOrigin(options.origin, originEnv), "getOrigin")
+    getOrigin: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => _nullishCoalesce(state.origin, () => ( resolveConfiguredOrigin(options.origin, originEnv))), "getOrigin")
   };
   const runtimePlugin = {
     name: `farm:agent-runtime:${provider}`,
@@ -2808,7 +92,7 @@ function createAgentRuntimeIntegration(options) {
       });
     }
   };
-  return defineIntegration({
+  return _chunkZ5HIWVDPcjs.defineIntegration.call(void 0, {
     category: "agent",
     type: provider,
     serverRuntime: options.serverRuntime,
@@ -2826,7 +110,7 @@ function createAgentRuntimeIntegration(options) {
         origin: state.origin
       });
       await context.cleanup(async () => {
-        await state.managed?.stop();
+        await _optionalChain([state, 'access', _ => _.managed, 'optionalAccess', _2 => _2.stop, 'call', _3 => _3()]);
         state.managed = void 0;
         state.origin = void 0;
       });
@@ -2852,7 +136,7 @@ function createAgentRuntimeIntegration(options) {
     plugins: [runtimePlugin, ...options.plugins || []]
   });
 }
-__name(createAgentRuntimeIntegration, "createAgentRuntimeIntegration");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createAgentRuntimeIntegration, "createAgentRuntimeIntegration");
 function applyAgentRuntimeViteProxy(config, input) {
   const origin = normalizeAgentOrigin(input.origin);
   const routePrefix = normalizeAgentRoutePrefix(input.routePrefix);
@@ -2879,7 +163,7 @@ function applyAgentRuntimeViteProxy(config, input) {
     }
   };
 }
-__name(applyAgentRuntimeViteProxy, "applyAgentRuntimeViteProxy");
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyAgentRuntimeViteProxy, "applyAgentRuntimeViteProxy");
 async function proxyAgentRuntimeRequest(request, origin, options = {}) {
   const upstreamOrigin = normalizeAgentOrigin(origin);
   const incomingUrl = new URL(request.url);
@@ -2900,7 +184,7 @@ async function proxyAgentRuntimeRequest(request, origin, options = {}) {
     const upstream = await (options.fetch || globalThis.fetch)(targetUrl, init);
     const responseHeaders = new Headers(upstream.headers);
     removeHopByHopHeaders(responseHeaders);
-    const contentCodings = responseHeaders.get("content-encoding")?.toLowerCase().split(",").map((coding) => coding.trim()).filter(Boolean);
+    const contentCodings = _optionalChain([responseHeaders, 'access', _4 => _4.get, 'call', _5 => _5("content-encoding"), 'optionalAccess', _6 => _6.toLowerCase, 'call', _7 => _7(), 'access', _8 => _8.split, 'call', _9 => _9(","), 'access', _10 => _10.map, 'call', _11 => _11((coding) => coding.trim()), 'access', _12 => _12.filter, 'call', _13 => _13(Boolean)]);
     let responseBody = upstream.body;
     if (upstream.body && contentCodings && contentCodings.length) {
       if (contentCodings.every((coding) => DECODED_CONTENT_CODINGS.includes(coding))) {
@@ -2935,15 +219,15 @@ async function proxyAgentRuntimeRequest(request, origin, options = {}) {
     );
   }
 }
-__name(proxyAgentRuntimeRequest, "proxyAgentRuntimeRequest");
+_chunkS3JO3N4Hcjs.__name.call(void 0, proxyAgentRuntimeRequest, "proxyAgentRuntimeRequest");
 async function startManagedAgentRuntime(options) {
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  const stopTimeoutMs = options.stopTimeoutMs ?? 2e3;
+  const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 3e4));
+  const stopTimeoutMs = _nullishCoalesce(options.stopTimeoutMs, () => ( 2e3));
   const fixedOrigin = options.origin ? normalizeAgentOrigin(options.origin) : void 0;
   let output = "";
   let settled = false;
   let checkingReadiness = false;
-  const child = (0, import_node_child_process.spawn)(options.command, [...options.args || []], {
+  const child = _child_process.spawn.call(void 0, options.command, [...options.args || []], {
     cwd: options.cwd,
     env: {
       ...process.env,
@@ -2953,14 +237,14 @@ async function startManagedAgentRuntime(options) {
   });
   const origin = await new Promise((resolveOrigin, reject) => {
     let timer;
-    const finish = /* @__PURE__ */ __name(() => {
+    const finish = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
       child.off("error", onError);
       child.off("exit", onExit);
     }, "finish");
-    const succeed = /* @__PURE__ */ __name(async (candidate) => {
+    const succeed = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (candidate) => {
       if (settled || checkingReadiness) return;
       checkingReadiness = true;
       try {
@@ -2979,11 +263,11 @@ async function startManagedAgentRuntime(options) {
       terminateChild(child);
       reject(new Error(`${options.label} did not become ready within ${timeoutMs}ms.`));
     }, timeoutMs);
-    const onError = /* @__PURE__ */ __name((error) => {
+    const onError = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => {
       finish();
       reject(error);
     }, "onError");
-    const onExit = /* @__PURE__ */ __name((code, signal) => {
+    const onExit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (code, signal) => {
       finish();
       reject(
         new Error(
@@ -2991,7 +275,7 @@ async function startManagedAgentRuntime(options) {
         )
       );
     }, "onExit");
-    const onData = /* @__PURE__ */ __name((chunk, stream) => {
+    const onData = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (chunk, stream) => {
       const text = chunk.toString("utf8");
       output = `${output}${text}`.slice(-16384);
       emitProcessOutput(text, stream, options.onOutput);
@@ -3004,8 +288,8 @@ async function startManagedAgentRuntime(options) {
     }, "onData");
     child.once("error", onError);
     child.once("exit", onExit);
-    child.stdout?.on("data", (chunk) => onData(chunk, "stdout"));
-    child.stderr?.on("data", (chunk) => onData(chunk, "stderr"));
+    _optionalChain([child, 'access', _14 => _14.stdout, 'optionalAccess', _15 => _15.on, 'call', _16 => _16("data", (chunk) => onData(chunk, "stdout"))]);
+    _optionalChain([child, 'access', _17 => _17.stderr, 'optionalAccess', _18 => _18.on, 'call', _19 => _19("data", (chunk) => onData(chunk, "stderr"))]);
     if (fixedOrigin) {
       void succeed(fixedOrigin);
     }
@@ -3026,10 +310,10 @@ async function startManagedAgentRuntime(options) {
     }
   };
 }
-__name(startManagedAgentRuntime, "startManagedAgentRuntime");
+_chunkS3JO3N4Hcjs.__name.call(void 0, startManagedAgentRuntime, "startManagedAgentRuntime");
 async function findAvailableAgentRuntimePort(host = "127.0.0.1") {
   return await new Promise((resolvePort, reject) => {
-    const server = (0, import_node_net.createServer)();
+    const server = _net.createServer.call(void 0, );
     server.unref();
     server.once("error", reject);
     server.listen(0, host, () => {
@@ -3047,33 +331,33 @@ async function findAvailableAgentRuntimePort(host = "127.0.0.1") {
     });
   });
 }
-__name(findAvailableAgentRuntimePort, "findAvailableAgentRuntimePort");
+_chunkS3JO3N4Hcjs.__name.call(void 0, findAvailableAgentRuntimePort, "findAvailableAgentRuntimePort");
 async function resolveProjectPackageBin(projectRoot, packageName, binName) {
-  const root = (0, import_node_path.resolve)(projectRoot);
-  const projectRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(root, "package.json"));
+  const root = _path.resolve.call(void 0, projectRoot);
+  const projectRequire = _module.createRequire.call(void 0, _path.join.call(void 0, root, "package.json"));
   let packageJsonPath;
   try {
     packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
-  } catch {
+  } catch (e) {
     throw new Error(
       `${packageName} is required by this agent integration. Install it in ${root} and try again.`
     );
   }
-  const packageJson = JSON.parse(await (0, import_promises.readFile)(packageJsonPath, "utf8"));
-  const bin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.[binName || packageName.split("/").at(-1) || packageName];
+  const packageJson = JSON.parse(await _promises.readFile.call(void 0, packageJsonPath, "utf8"));
+  const bin = typeof packageJson.bin === "string" ? packageJson.bin : _optionalChain([packageJson, 'access', _20 => _20.bin, 'optionalAccess', _21 => _21[binName || packageName.split("/").at(-1) || packageName]]);
   if (!bin) {
     throw new Error(
       `${packageName} does not expose the expected ${binName || packageName} binary.`
     );
   }
-  const packageRoot = (0, import_node_path.dirname)(packageJsonPath);
-  const binaryPath = (0, import_node_path.resolve)(packageRoot, bin);
-  if ((0, import_node_path.relative)(packageRoot, binaryPath).startsWith("..") || (0, import_node_path.isAbsolute)((0, import_node_path.relative)(packageRoot, binaryPath))) {
+  const packageRoot = _path.dirname.call(void 0, packageJsonPath);
+  const binaryPath = _path.resolve.call(void 0, packageRoot, bin);
+  if (_path.relative.call(void 0, packageRoot, binaryPath).startsWith("..") || _path.isAbsolute.call(void 0, _path.relative.call(void 0, packageRoot, binaryPath))) {
     throw new Error(`${packageName} exposes a binary outside its package root.`);
   }
   return binaryPath;
 }
-__name(resolveProjectPackageBin, "resolveProjectPackageBin");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveProjectPackageBin, "resolveProjectPackageBin");
 function normalizeAgentOrigin(value) {
   const input = value.trim();
   if (!input) {
@@ -3091,7 +375,7 @@ function normalizeAgentOrigin(value) {
   }
   return url.origin;
 }
-__name(normalizeAgentOrigin, "normalizeAgentOrigin");
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeAgentOrigin, "normalizeAgentOrigin");
 function normalizeAgentRoutePrefix(value) {
   const normalized = `/${value.trim()}`.replace(/\/{2,}/g, "/");
   if (normalized === "/") {
@@ -3099,7 +383,7 @@ function normalizeAgentRoutePrefix(value) {
   }
   return normalized.replace(/\/$/, "");
 }
-__name(normalizeAgentRoutePrefix, "normalizeAgentRoutePrefix");
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeAgentRoutePrefix, "normalizeAgentRoutePrefix");
 function normalizeProviderName(value) {
   const provider = value.trim();
   if (!provider || !/^[a-z0-9][a-z0-9._-]*$/i.test(provider)) {
@@ -3107,25 +391,25 @@ function normalizeProviderName(value) {
   }
   return provider;
 }
-__name(normalizeProviderName, "normalizeProviderName");
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeProviderName, "normalizeProviderName");
 function normalizeOriginEnv(value) {
   if (!value) return [];
   return (Array.isArray(value) ? value : [value]).map((entry) => entry.trim()).filter(Boolean);
 }
-__name(normalizeOriginEnv, "normalizeOriginEnv");
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeOriginEnv, "normalizeOriginEnv");
 function resolveConfiguredOrigin(configuredOrigin, envNames) {
   if (configuredOrigin) {
     return normalizeAgentOrigin(configuredOrigin);
   }
   for (const envName of envNames) {
     const value = process.env[envName];
-    if (value?.trim()) {
+    if (_optionalChain([value, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()])) {
       return normalizeAgentOrigin(value);
     }
   }
   return void 0;
 }
-__name(resolveConfiguredOrigin, "resolveConfiguredOrigin");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveConfiguredOrigin, "resolveConfiguredOrigin");
 function createProxyRequestHeaders(input, incomingUrl) {
   const headers = new Headers(input);
   removeHopByHopHeaders(headers);
@@ -3136,9 +420,9 @@ function createProxyRequestHeaders(input, incomingUrl) {
   headers.set("x-forwarded-proto", incomingUrl.protocol.replace(":", ""));
   return headers;
 }
-__name(createProxyRequestHeaders, "createProxyRequestHeaders");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createProxyRequestHeaders, "createProxyRequestHeaders");
 function removeHopByHopHeaders(headers) {
-  const connectionOptions = headers.get("connection")?.split(",") ?? [];
+  const connectionOptions = _nullishCoalesce(_optionalChain([headers, 'access', _24 => _24.get, 'call', _25 => _25("connection"), 'optionalAccess', _26 => _26.split, 'call', _27 => _27(",")]), () => ( []));
   for (const option of connectionOptions) {
     const header = option.trim();
     if (/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(header)) {
@@ -3149,7 +433,7 @@ function removeHopByHopHeaders(headers) {
     headers.delete(header);
   }
 }
-__name(removeHopByHopHeaders, "removeHopByHopHeaders");
+_chunkS3JO3N4Hcjs.__name.call(void 0, removeHopByHopHeaders, "removeHopByHopHeaders");
 async function detectZstdDecoding(body) {
   const reader = body.getReader();
   const consumed = [];
@@ -3162,7 +446,7 @@ async function detectZstdDecoding(body) {
       consumed.push(value);
       total += value.byteLength;
     }
-  } catch {
+  } catch (e2) {
   }
   const lookahead = concatUint8(consumed);
   const decoded = !startsWithZstdFrameMagic(lookahead);
@@ -3177,7 +461,7 @@ async function detectZstdDecoding(body) {
           controller.close();
           return;
         }
-        controller.enqueue(value ?? new Uint8Array());
+        controller.enqueue(_nullishCoalesce(value, () => ( new Uint8Array())));
       } catch (error) {
         controller.error(error);
       }
@@ -3189,7 +473,7 @@ async function detectZstdDecoding(body) {
   });
   return { decoded, body: rebuilt };
 }
-__name(detectZstdDecoding, "detectZstdDecoding");
+_chunkS3JO3N4Hcjs.__name.call(void 0, detectZstdDecoding, "detectZstdDecoding");
 function concatUint8(chunks) {
   if (chunks.length === 0) return new Uint8Array(0);
   if (chunks.length === 1) return chunks[0];
@@ -3202,7 +486,7 @@ function concatUint8(chunks) {
   }
   return merged;
 }
-__name(concatUint8, "concatUint8");
+_chunkS3JO3N4Hcjs.__name.call(void 0, concatUint8, "concatUint8");
 function startsWithZstdFrameMagic(buffer) {
   if (buffer.byteLength < ZSTD_FRAME_MAGIC.byteLength) return false;
   let isStandardFrame = true;
@@ -3215,7 +499,7 @@ function startsWithZstdFrameMagic(buffer) {
   if (isStandardFrame) return true;
   return buffer[0] >= 80 && buffer[0] <= 95 && buffer[1] === 42 && buffer[2] === 77 && buffer[3] === 24;
 }
-__name(startsWithZstdFrameMagic, "startsWithZstdFrameMagic");
+_chunkS3JO3N4Hcjs.__name.call(void 0, startsWithZstdFrameMagic, "startsWithZstdFrameMagic");
 function rewriteProxyLocation(headers, upstreamOrigin, incomingOrigin) {
   const location = headers.get("location");
   if (!location) return;
@@ -3224,14 +508,14 @@ function rewriteProxyLocation(headers, upstreamOrigin, incomingOrigin) {
     if (url.origin === upstreamOrigin) {
       headers.set("location", `${incomingOrigin}${url.pathname}${url.search}${url.hash}`);
     }
-  } catch {
+  } catch (e3) {
   }
 }
-__name(rewriteProxyLocation, "rewriteProxyLocation");
+_chunkS3JO3N4Hcjs.__name.call(void 0, rewriteProxyLocation, "rewriteProxyLocation");
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
-__name(isAbortError, "isAbortError");
+_chunkS3JO3N4Hcjs.__name.call(void 0, isAbortError, "isAbortError");
 async function waitForAgentRuntime(origin, healthPath, timeoutMs, child) {
   const deadline = Date.now() + timeoutMs;
   const healthUrl = new URL(healthPath || "/", origin);
@@ -3247,7 +531,7 @@ async function waitForAgentRuntime(origin, healthPath, timeoutMs, child) {
         redirect: "manual"
       });
       return;
-    } catch {
+    } catch (e4) {
       await delay(100);
     } finally {
       clearTimeout(timer);
@@ -3255,7 +539,7 @@ async function waitForAgentRuntime(origin, healthPath, timeoutMs, child) {
   }
   throw new Error(`Agent runtime at ${origin} did not answer before the startup timeout.`);
 }
-__name(waitForAgentRuntime, "waitForAgentRuntime");
+_chunkS3JO3N4Hcjs.__name.call(void 0, waitForAgentRuntime, "waitForAgentRuntime");
 function emitProcessOutput(text, stream, onOutput) {
   if (!onOutput) return;
   for (const line of text.split(/\r?\n/)) {
@@ -3263,13 +547,13 @@ function emitProcessOutput(text, stream, onOutput) {
     if (value) onOutput(value, stream);
   }
 }
-__name(emitProcessOutput, "emitProcessOutput");
+_chunkS3JO3N4Hcjs.__name.call(void 0, emitProcessOutput, "emitProcessOutput");
 function terminateChild(child) {
   if (child.exitCode === null && child.signalCode === null) {
     child.kill("SIGTERM");
   }
 }
-__name(terminateChild, "terminateChild");
+_chunkS3JO3N4Hcjs.__name.call(void 0, terminateChild, "terminateChild");
 async function waitForChildExit(child, timeoutMs) {
   if (child.exitCode !== null || child.signalCode !== null) return true;
   return await new Promise((resolveExit) => {
@@ -3277,26 +561,25 @@ async function waitForChildExit(child, timeoutMs) {
       child.off("exit", onExit);
       resolveExit(false);
     }, timeoutMs);
-    const onExit = /* @__PURE__ */ __name(() => {
+    const onExit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
       clearTimeout(timer);
       resolveExit(true);
     }, "onExit");
     child.once("exit", onExit);
   });
 }
-__name(waitForChildExit, "waitForChildExit");
+_chunkS3JO3N4Hcjs.__name.call(void 0, waitForChildExit, "waitForChildExit");
 function delay(ms) {
   return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
 }
-__name(delay, "delay");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyAgentRuntimeViteProxy,
-  createAgentRuntimeIntegration,
-  findAvailableAgentRuntimePort,
-  normalizeAgentOrigin,
-  normalizeAgentRoutePrefix,
-  proxyAgentRuntimeRequest,
-  resolveProjectPackageBin,
-  startManagedAgentRuntime
-});
+_chunkS3JO3N4Hcjs.__name.call(void 0, delay, "delay");
+
+
+
+
+
+
+
+
+
+exports.applyAgentRuntimeViteProxy = applyAgentRuntimeViteProxy; exports.createAgentRuntimeIntegration = createAgentRuntimeIntegration; exports.findAvailableAgentRuntimePort = findAvailableAgentRuntimePort; exports.normalizeAgentOrigin = normalizeAgentOrigin; exports.normalizeAgentRoutePrefix = normalizeAgentRoutePrefix; exports.proxyAgentRuntimeRequest = proxyAgentRuntimeRequest; exports.resolveProjectPackageBin = resolveProjectPackageBin; exports.startManagedAgentRuntime = startManagedAgentRuntime;