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

package/dist/agent-runtime.cjs

@@ -1,2379 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  createFarmStorage: () => createFarmStorage,
-  createStorageClient: () => createStorageClient,
-  databaseStorage: () => databaseStorage,
-  defineStorageClient: () => defineStorageClient,
-  disposeStorage: () => disposeStorage,
-  driverStorage: () => driverStorage,
-  getStorage: () => getStorage,
-  initStorage: () => initStorage,
-  libsqlStorage: () => libsqlStorage,
-  localStorage: () => localStorage,
-  memoryStorage: () => memoryStorage,
-  mongodbStorage: () => mongodbStorage,
-  mysql2Storage: () => mysql2Storage,
-  mysqlStorage: () => mysqlStorage,
-  netlifyBlobsStorage: () => netlifyBlobsStorage,
-  pgStorage: () => pgStorage,
-  pgliteStorage: () => pgliteStorage,
-  planetscaleStorage: () => planetscaleStorage,
-  postgresStorage: () => postgresStorage,
-  redisStorage: () => redisStorage,
-  resolveStorageRuntimeClient: () => resolveStorageRuntimeClient,
-  s3Storage: () => s3Storage,
-  sqliteStorage: () => sqliteStorage,
-  upstashStorage: () => upstashStorage,
-  vercelBlobStorage: () => vercelBlobStorage,
-  vercelKVStorage: () => vercelKVStorage
-});
-function createMemoryStorage() {
-  return (0, import_unstorage.createStorage)({
-    driver: (0, import_memory.default)()
-  });
-}
-function readGlobalStorage() {
-  return globalThis[GLOBAL_STORAGE_KEY];
-}
-function writeGlobalStorage(storage) {
-  globalThis[GLOBAL_STORAGE_KEY] = storage;
-  return storage;
-}
-function getActiveGlobalStorage() {
-  const existing = readGlobalStorage();
-  if (existing) {
-    return existing;
-  }
-  return writeGlobalStorage(createMemoryStorage());
-}
-function normalizeMountKey(base) {
-  return (base || "").trim().replace(/^[:/\\]+|[:/\\]+$/g, "").replace(/[\\/]+/g, ":");
-}
-function isDriverInstance(value) {
-  return !!value && typeof value === "object" && typeof value.getItem === "function" && typeof value.getKeys === "function";
-}
-function isStorageInstance(value) {
-  return !!value && typeof value === "object" && typeof value.mount === "function" && typeof value.getMount === "function";
-}
-function isStorageClient(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-storage-client" && typeof value.resolveDriver === "function" && typeof value.createStorage === "function";
-}
-function isDatabaseDriverName(name) {
-  return name in DATABASE_CONNECTORS;
-}
-function extractDriverOptions(config) {
-  const source = config;
-  const {
-    client: _client,
-    driver: _driver,
-    mounts: _mounts,
-    options,
-    tableName: _tableName,
-    ...inlineOptions
-  } = source;
-  const hasInlineOptions = Object.keys(inlineOptions).length > 0;
-  if (options && typeof options === "object" && !Array.isArray(options)) {
-    return hasInlineOptions ? { ...inlineOptions, ...options } : options;
-  }
-  if (hasInlineOptions) {
-    return inlineOptions;
-  }
-  return options;
-}
-async function loadBuiltinDriver(name, options) {
-  const modulePath = import_unstorage.builtinDrivers[name];
-  if (!modulePath) {
-    throw new Error(`Unsupported storage driver "${name}".`);
-  }
-  const module2 = await loadModule(modulePath);
-  return module2.default(options);
-}
-async function loadDatabaseDriver(config) {
-  const connectorEntry = DATABASE_CONNECTORS[config.driver];
-  const [{ createDatabase }, connectorModule, db0DriverModule] = await Promise.all([
-    loadModule("db0"),
-    connectorEntry.load(),
-    loadModule("unstorage/drivers/db0")
-  ]);
-  const database = createDatabase(connectorModule.default(extractDriverOptions(config) || {}));
-  return db0DriverModule.default({
-    database,
-    tableName: config.tableName
-  });
-}
-async function resolveDriver(config) {
-  if (config && isStorageClient(config)) {
-    return config.resolveDriver();
-  }
-  const driverInput = config?.driver ?? "memory";
-  if (typeof driverInput === "function") {
-    return await driverInput();
-  }
-  if (isDriverInstance(driverInput)) {
-    return driverInput;
-  }
-  if (isDatabaseDriverName(driverInput)) {
-    return loadDatabaseDriver(config);
-  }
-  if (driverInput === "local") {
-    return loadBuiltinDriver("fs-lite", extractDriverOptions(config));
-  }
-  return loadBuiltinDriver(
-    driverInput,
-    extractDriverOptions(config)
-  );
-}
-function createStorageClientFromResolver(resolveDriver2) {
-  let driverPromise;
-  let storagePromise;
-  const ensureDriver = /* @__PURE__ */ __name(async () => {
-    driverPromise ?? (driverPromise = Promise.resolve(resolveDriver2()));
-    return driverPromise;
-  }, "ensureDriver");
-  const ensureStorage = /* @__PURE__ */ __name(async () => {
-    storagePromise ?? (storagePromise = ensureDriver().then(
-      (driver) => (0, import_unstorage.createStorage)({
-        driver
-      })
-    ));
-    return storagePromise;
-  }, "ensureStorage");
-  const target = {
-    kind: "farm-storage-client",
-    ready: ensureStorage,
-    createStorage: ensureStorage,
-    resolveDriver: ensureDriver
-  };
-  return new Proxy(target, {
-    get(currentTarget, prop, receiver) {
-      if (prop === "then") {
-        return void 0;
-      }
-      if (Reflect.has(currentTarget, prop)) {
-        return Reflect.get(currentTarget, prop, receiver);
-      }
-      return (...args) => ensureStorage().then(async (storage) => {
-        const member = Reflect.get(storage, prop);
-        if (typeof member !== "function") {
-          return member;
-        }
-        const result = Reflect.apply(member, storage, args);
-        if (prop === "dispose") {
-          return Promise.resolve(result).finally(() => {
-            storagePromise = void 0;
-          });
-        }
-        return result;
-      });
-    }
-  });
-}
-function defineStorageClient(resolveDriver2) {
-  return createStorageClientFromResolver(resolveDriver2);
-}
-function createStorageClient(config) {
-  return defineStorageClient(() => resolveDriver(config));
-}
-function driverStorage(driver) {
-  return defineStorageClient(() => typeof driver === "function" ? driver() : driver);
-}
-function databaseStorage(database, options = {}) {
-  return defineStorageClient(async () => {
-    const db0DriverModule = await loadModule("unstorage/drivers/db0");
-    return db0DriverModule.default({
-      database,
-      tableName: options.tableName
-    });
-  });
-}
-function memoryStorage() {
-  return createStorageClient({ driver: "memory" });
-}
-function localStorage(options = {}) {
-  return createStorageClient({
-    driver: "local",
-    ...options
-  });
-}
-function sqliteStorage(options) {
-  return createStorageClient({
-    driver: "sqlite",
-    ...options
-  });
-}
-function mysqlStorage(options) {
-  return createStorageClient({
-    driver: "mysql",
-    ...options
-  });
-}
-function mysql2Storage(options) {
-  return mysqlStorage(options);
-}
-function postgresStorage(options) {
-  return createStorageClient({
-    driver: "postgres",
-    ...options
-  });
-}
-function pgStorage(options) {
-  return postgresStorage(options);
-}
-function pgliteStorage(options) {
-  return createStorageClient({
-    driver: "pglite",
-    ...options
-  });
-}
-function planetscaleStorage(options) {
-  return createStorageClient({
-    driver: "planetscale",
-    ...options
-  });
-}
-function libsqlStorage(options) {
-  return createStorageClient({
-    driver: "libsql",
-    ...options
-  });
-}
-function redisStorage(options) {
-  return createStorageClient({
-    driver: "redis",
-    ...options
-  });
-}
-function s3Storage(options) {
-  return createStorageClient({
-    driver: "s3",
-    ...options
-  });
-}
-function mongodbStorage(options) {
-  return createStorageClient({
-    driver: "mongodb",
-    ...options
-  });
-}
-function upstashStorage(options) {
-  return createStorageClient({
-    driver: "upstash",
-    ...options
-  });
-}
-function netlifyBlobsStorage(options) {
-  return createStorageClient({
-    driver: "netlify-blobs",
-    ...options
-  });
-}
-function vercelKVStorage(options) {
-  return createStorageClient({
-    driver: "vercel-kv",
-    ...options
-  });
-}
-function vercelBlobStorage(options) {
-  return createStorageClient({
-    driver: "vercel-blob",
-    ...options
-  });
-}
-async function mountNamespaces(storage, mounts) {
-  if (!mounts) {
-    return;
-  }
-  for (const [base, config] of Object.entries(mounts)) {
-    storage.mount(normalizeMountKey(base), await resolveDriver(config));
-  }
-}
-async function createFarmStorage(config = {}) {
-  if (isStorageInstance(config)) {
-    return config;
-  }
-  if (isStorageClient(config)) {
-    return config.createStorage();
-  }
-  const rootConfig = isStorageClient(config.client) ? config.client : config;
-  const storage = (0, import_unstorage.createStorage)({
-    driver: await resolveDriver(rootConfig)
-  });
-  await mountNamespaces(storage, config.mounts);
-  return storage;
-}
-async function resolveStorageRuntimeClient(config) {
-  if (!config || isStorageInstance(config) || isStorageClient(config)) {
-    return void 0;
-  }
-  const client = config.client;
-  if (!client || isStorageInstance(client) || isStorageClient(client)) {
-    return void 0;
-  }
-  return typeof client === "function" ? await client() : client;
-}
-async function initStorage(config = {}) {
-  globalStorage = getActiveGlobalStorage();
-  const nextStorage = await createFarmStorage(config);
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(nextStorage);
-  if (previousStorage !== nextStorage) {
-    await previousStorage.dispose().catch(() => {
-    });
-  }
-  return globalStorage;
-}
-function getStorage(namespace) {
-  globalStorage = getActiveGlobalStorage();
-  const base = normalizeMountKey(namespace);
-  if (!base) {
-    return globalStorage;
-  }
-  const namespaced = (0, import_unstorage.prefixStorage)(globalStorage, base);
-  return {
-    ...namespaced,
-    async clear() {
-      const keys = await namespaced.getKeys();
-      await Promise.all(keys.map((key) => namespaced.removeItem(key)));
-    }
-  };
-}
-async function disposeStorage() {
-  globalStorage = getActiveGlobalStorage();
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(createMemoryStorage());
-  await previousStorage.dispose().catch(() => {
-  });
-}
-var import_unstorage, import_memory, loadModule, DATABASE_CONNECTORS, GLOBAL_STORAGE_KEY, globalStorage;
-var init_storage = __esm({
-  "src/storage/index.ts"() {
-    "use strict";
-    import_unstorage = require("unstorage");
-    import_memory = __toESM(require("unstorage/drivers/memory"));
-    loadModule = /* @__PURE__ */ __name((specifier) => import(
-      /* @vite-ignore */
-      specifier
-    ), "loadModule");
-    DATABASE_CONNECTORS = {
-      sqlite: {
-        connector: "node-sqlite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-      },
-      "node-sqlite": {
-        connector: "node-sqlite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-      },
-      sqlite3: {
-        connector: "sqlite3",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/sqlite3"), "load")
-      },
-      "better-sqlite3": {
-        connector: "better-sqlite3",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/better-sqlite3"), "load")
-      },
-      postgres: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      postgresql: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      pg: {
-        connector: "postgresql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-      },
-      mysql: {
-        connector: "mysql2",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-      },
-      mysql2: {
-        connector: "mysql2",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-      },
-      pglite: {
-        connector: "pglite",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/pglite"), "load")
-      },
-      planetscale: {
-        connector: "planetscale",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/planetscale"), "load")
-      },
-      libsql: {
-        connector: "libsql",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-      },
-      "libsql-node": {
-        connector: "libsql-node",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-      },
-      "libsql-http": {
-        connector: "libsql-http",
-        load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/http"), "load")
-      }
-    };
-    __name(createMemoryStorage, "createMemoryStorage");
-    GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
-    __name(readGlobalStorage, "readGlobalStorage");
-    __name(writeGlobalStorage, "writeGlobalStorage");
-    __name(getActiveGlobalStorage, "getActiveGlobalStorage");
-    globalStorage = getActiveGlobalStorage();
-    __name(normalizeMountKey, "normalizeMountKey");
-    __name(isDriverInstance, "isDriverInstance");
-    __name(isStorageInstance, "isStorageInstance");
-    __name(isStorageClient, "isStorageClient");
-    __name(isDatabaseDriverName, "isDatabaseDriverName");
-    __name(extractDriverOptions, "extractDriverOptions");
-    __name(loadBuiltinDriver, "loadBuiltinDriver");
-    __name(loadDatabaseDriver, "loadDatabaseDriver");
-    __name(resolveDriver, "resolveDriver");
-    __name(createStorageClientFromResolver, "createStorageClientFromResolver");
-    __name(defineStorageClient, "defineStorageClient");
-    __name(createStorageClient, "createStorageClient");
-    __name(driverStorage, "driverStorage");
-    __name(databaseStorage, "databaseStorage");
-    __name(memoryStorage, "memoryStorage");
-    __name(localStorage, "localStorage");
-    __name(sqliteStorage, "sqliteStorage");
-    __name(mysqlStorage, "mysqlStorage");
-    __name(mysql2Storage, "mysql2Storage");
-    __name(postgresStorage, "postgresStorage");
-    __name(pgStorage, "pgStorage");
-    __name(pgliteStorage, "pgliteStorage");
-    __name(planetscaleStorage, "planetscaleStorage");
-    __name(libsqlStorage, "libsqlStorage");
-    __name(redisStorage, "redisStorage");
-    __name(s3Storage, "s3Storage");
-    __name(mongodbStorage, "mongodbStorage");
-    __name(upstashStorage, "upstashStorage");
-    __name(netlifyBlobsStorage, "netlifyBlobsStorage");
-    __name(vercelKVStorage, "vercelKVStorage");
-    __name(vercelBlobStorage, "vercelBlobStorage");
-    __name(mountNamespaces, "mountNamespaces");
-    __name(createFarmStorage, "createFarmStorage");
-    __name(resolveStorageRuntimeClient, "resolveStorageRuntimeClient");
-    __name(initStorage, "initStorage");
-    __name(getStorage, "getStorage");
-    __name(disposeStorage, "disposeStorage");
-  }
-});
-
-// src/integration-orm.ts
-var integration_orm_exports = {};
-__export(integration_orm_exports, {
-  createIntegrationOrm: () => createIntegrationOrm,
-  farmIntegrationSchemaToOrmSchema: () => farmIntegrationSchemaToOrmSchema,
-  resolveIntegrationOrmRuntimeClient: () => resolveIntegrationOrmRuntimeClient
-});
-async function createIntegrationOrm(options) {
-  const [schema, client] = await Promise.all([
-    farmIntegrationSchemaToOrmSchema(options.schema),
-    resolveIntegrationOrmRuntimeClient(options)
-  ]);
-  if (!client) {
-    throw new Error(
-      "Schema-backed integration storage requires a runtime client at farm.config storage.client."
-    );
-  }
-  const { createOrmFromRuntime } = await import("@farming-labs/orm-runtime");
-  return createOrmFromRuntime({
-    schema,
-    client
-  });
-}
-async function resolveIntegrationOrmRuntimeClient(options) {
-  if (options.client !== void 0) {
-    return typeof options.client === "function" ? await options.client() : options.client;
-  }
-  return resolveStorageRuntimeClient(options.storage ?? options.config?.storage);
-}
-async function farmIntegrationSchemaToOrmSchema(schema) {
-  const orm = await import("@farming-labs/orm");
-  const models = {};
-  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {
-    models[modelKey] = orm.model({
-      table: modelSchema.name ?? modelKey,
-      fields: createOrmModelFields(orm, modelSchema),
-      constraints: createOrmModelConstraints(modelSchema),
-      description: modelSchema.description
-    });
-  }
-  return orm.defineSchema(models);
-}
-function createOrmModelFields(orm, modelSchema) {
-  return Object.fromEntries(
-    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [
-      fieldKey,
-      createOrmField(orm, fieldKey, fieldSchema)
-    ])
-  );
-}
-function createOrmField(orm, fieldKey, field) {
-  let builder = createOrmFieldBuilder(orm, fieldKey, field);
-  if (field.unique) {
-    builder = builder.unique();
-  }
-  if (field.nullable || field.required === false) {
-    builder = builder.nullable();
-  }
-  if (field.default !== void 0) {
-    builder = field.type === "datetime" && field.default === "now" ? builder.defaultNow() : builder.default(field.default);
-  }
-  if (field.reference) {
-    builder = builder.references(`${field.reference.model}.${field.reference.field}`);
-  }
-  if (field.name && field.name !== fieldKey) {
-    builder = builder.map(field.name);
-  }
-  if (field.description) {
-    builder = builder.describe(field.description);
-  }
-  return builder;
-}
-function createOrmFieldBuilder(orm, fieldKey, field) {
-  switch (field.type) {
-    case "id":
-    case "uuid":
-      return orm.id();
-    case "string":
-    case "text":
-      return orm.string();
-    case "boolean":
-      return orm.boolean();
-    case "integer":
-      return orm.integer();
-    case "number":
-      return orm.decimal();
-    case "datetime":
-      return orm.datetime();
-    case "json":
-      return orm.json();
-    case "enum": {
-      if (!field.values?.length) {
-        throw new Error(`Integration schema enum field "${fieldKey}" must define values.`);
-      }
-      return orm.enumeration(field.values);
-    }
-    default:
-      throw new Error(
-        `Unsupported integration schema field type "${field.type}" for "${fieldKey}".`
-      );
-  }
-}
-function createOrmModelConstraints(modelSchema) {
-  const unique = [];
-  const indexes = [];
-  for (const constraint of modelSchema.constraints ?? []) {
-    if (!constraint.fields.length) {
-      continue;
-    }
-    const fields = constraint.fields;
-    if (constraint.type === "unique") {
-      unique.push(fields);
-    } else {
-      indexes.push(fields);
-    }
-  }
-  return {
-    unique,
-    indexes
-  };
-}
-var init_integration_orm = __esm({
-  "src/integration-orm.ts"() {
-    "use strict";
-    init_storage();
-    __name(createIntegrationOrm, "createIntegrationOrm");
-    __name(resolveIntegrationOrmRuntimeClient, "resolveIntegrationOrmRuntimeClient");
-    __name(farmIntegrationSchemaToOrmSchema, "farmIntegrationSchemaToOrmSchema");
-    __name(createOrmModelFields, "createOrmModelFields");
-    __name(createOrmField, "createOrmField");
-    __name(createOrmFieldBuilder, "createOrmFieldBuilder");
-    __name(createOrmModelConstraints, "createOrmModelConstraints");
-  }
-});
-
-// src/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/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,
-  post(pathOrOptions, maybeOptions = {}) {
-    return operation("POST", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  put(pathOrOptions, maybeOptions = {}) {
-    return operation("PUT", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  patch(pathOrOptions, maybeOptions = {}) {
-    return operation("PATCH", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  delete(pathOrOptions, maybeOptions = {}) {
-    return operation("DELETE", pathOrOptions, {
-      bodyFormat: "json",
-      ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-    });
-  },
-  options(pathOrOptions, maybeOptions = {}) {
-    return operation(
-      "OPTIONS",
-      pathOrOptions,
-      maybeOptions
-    );
-  },
-  head(pathOrOptions, maybeOptions = {}) {
-    return operation(
-      "HEAD",
-      pathOrOptions,
-      maybeOptions
-    );
-  },
-  form: {
-    post(pathOrOptions, maybeOptions = {}) {
-      return operation("POST", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    put(pathOrOptions, maybeOptions = {}) {
-      return operation("PUT", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    patch(pathOrOptions, maybeOptions = {}) {
-      return operation("PATCH", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    },
-    delete(pathOrOptions, maybeOptions = {}) {
-      return operation("DELETE", pathOrOptions, {
-        bodyFormat: "form",
-        ...typeof pathOrOptions === "string" ? maybeOptions : pathOrOptions
-      });
-    }
-  }
-};
-
-// src/request-context.ts
-var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
-function getRequestContextStore() {
-  const globalState = globalThis;
-  if (!globalState[REQUEST_CONTEXT_STORE_KEY]) {
-    globalState[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
-  }
-  return globalState[REQUEST_CONTEXT_STORE_KEY];
-}
-__name(getRequestContextStore, "getRequestContextStore");
-function getBucket(target) {
-  const requestContextStore = getRequestContextStore();
-  let bucket = requestContextStore.get(target);
-  if (!bucket) {
-    bucket = {
-      privateData: /* @__PURE__ */ new Map(),
-      exposedData: /* @__PURE__ */ new Map()
-    };
-    requestContextStore.set(target, bucket);
-  }
-  return bucket;
-}
-__name(getBucket, "getBucket");
-function setRequestContext(target, key, value, options = {}) {
-  const bucket = getBucket(target);
-  bucket.privateData.set(key, value);
-  if (options.exposeToPage) {
-    bucket.exposedData.set(key, value);
-  }
-}
-__name(setRequestContext, "setRequestContext");
-function getRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return bucket?.privateData.get(key);
-}
-__name(getRequestContext, "getRequestContext");
-function hasRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return bucket?.privateData.has(key) ?? false;
-}
-__name(hasRequestContext, "hasRequestContext");
-function deleteRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return false;
-  const removedPrivate = bucket.privateData.delete(key);
-  bucket.exposedData.delete(key);
-  return removedPrivate;
-}
-__name(deleteRequestContext, "deleteRequestContext");
-function clearRequestContext(target) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return;
-  bucket.privateData.clear();
-  bucket.exposedData.clear();
-}
-__name(clearRequestContext, "clearRequestContext");
-function getRequestContextSnapshot(target, options = {}) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return /* @__PURE__ */ new Map();
-  if (options.exposedOnly) {
-    return new Map(bucket.exposedData);
-  }
-  return new Map(bucket.privateData);
-}
-__name(getRequestContextSnapshot, "getRequestContextSnapshot");
-
-// src/server/response.ts
-var import_node_events = require("events");
-
-// src/integrations.ts
-var FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
-function defineTypedIntegrationRoute(method, path, input) {
-  return {
-    path,
-    method,
-    middleware: input.middleware,
-    before: input.before,
-    after: input.after,
-    rawBody: input.rawBody,
-    bodyFormat: input.bodyFormat,
-    input: normalizeIntegrationRouteInputSchemas(input),
-    handler: input.handler,
-    __operation: defineIntegrationAPIOperation({
-      path,
-      method,
-      bodyFormat: input.bodyFormat,
-      responseFormat: input.responseFormat,
-      headers: input.headers,
-      credentials: input.credentials,
-      isServer: input.isServer
-    })
-  };
-}
-__name(defineTypedIntegrationRoute, "defineTypedIntegrationRoute");
-function createIntegrationRouteFactory() {
-  return {
-    get(path, input) {
-      return defineTypedIntegrationRoute(
-        "GET",
-        path,
-        input
-      );
-    },
-    post(path, input) {
-      return defineTypedIntegrationRoute(
-        "POST",
-        path,
-        {
-          bodyFormat: "json",
-          ...input
-        }
-      );
-    },
-    put(path, input) {
-      return defineTypedIntegrationRoute(
-        "PUT",
-        path,
-        {
-          bodyFormat: "json",
-          ...input
-        }
-      );
-    },
-    patch(path, input) {
-      return defineTypedIntegrationRoute("PATCH", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    delete(path, input) {
-      return defineTypedIntegrationRoute("DELETE", path, {
-        bodyFormat: "json",
-        ...input
-      });
-    },
-    options(path, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path, input);
-    },
-    head(path, input) {
-      return defineTypedIntegrationRoute(
-        "HEAD",
-        path,
-        input
-      );
-    }
-  };
-}
-__name(createIntegrationRouteFactory, "createIntegrationRouteFactory");
-function createIntegrationRoute(_schema) {
-  return createIntegrationRouteFactory();
-}
-__name(createIntegrationRoute, "createIntegrationRoute");
-var integrationRoute = createIntegrationRouteFactory();
-var INTEGRATION_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;
-  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");
-var INTEGRATION_DATA_HEADER = "x-farm-integration-data";
-var INTEGRATION_DATA_HEADER_MAX_LENGTH = 16 * 1024;
-var BLOCKED_INTEGRATION_DATA_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function isFarmIntegrationData(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isFarmIntegrationData, "isFarmIntegrationData");
-function isPlainIntegrationDataObject(value) {
-  if (!isFarmIntegrationData(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-__name(isPlainIntegrationDataObject, "isPlainIntegrationDataObject");
-function sanitizeIntegrationDataValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeIntegrationDataValue(item));
-  }
-  if (!isPlainIntegrationDataObject(value)) {
-    return value;
-  }
-  const sanitized = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (BLOCKED_INTEGRATION_DATA_KEYS.has(key)) {
-      continue;
-    }
-    sanitized[key] = sanitizeIntegrationDataValue(item);
-  }
-  return sanitized;
-}
-__name(sanitizeIntegrationDataValue, "sanitizeIntegrationDataValue");
-function normalizeIntegrationData(value) {
-  if (!isFarmIntegrationData(value)) {
-    return {};
-  }
-  const sanitized = sanitizeIntegrationDataValue(value);
-  return isFarmIntegrationData(sanitized) ? sanitized : {};
-}
-__name(normalizeIntegrationData, "normalizeIntegrationData");
-function getIntegrationDataHeaderByteLength(value) {
-  return new TextEncoder().encode(value).byteLength;
-}
-__name(getIntegrationDataHeaderByteLength, "getIntegrationDataHeaderByteLength");
-function parseIntegrationDataHeader(request) {
-  const raw = request.headers.get(INTEGRATION_DATA_HEADER);
-  if (!raw) {
-    return {};
-  }
-  if (getIntegrationDataHeaderByteLength(raw) > INTEGRATION_DATA_HEADER_MAX_LENGTH) {
-    return {};
-  }
-  try {
-    const value = JSON.parse(raw);
-    return normalizeIntegrationData(value);
-  } catch {
-    return {};
-  }
-}
-__name(parseIntegrationDataHeader, "parseIntegrationDataHeader");
-function resolveIntegrationData(request, data) {
-  return {
-    ...parseIntegrationDataHeader(request),
-    ...normalizeIntegrationData(data)
-  };
-}
-__name(resolveIntegrationData, "resolveIntegrationData");
-function normalizeIntegrationRoutes(routes) {
-  return routes.map((route2) => ({
-    ...route2,
-    methods: normalizeIntegrationRouteMethods(route2),
-    input: normalizeIntegrationRouteInputSchemas(route2)
-  }));
-}
-__name(normalizeIntegrationRoutes, "normalizeIntegrationRoutes");
-function normalizeIntegrationRouteMethods(route2) {
-  const input = route2.methods && route2.methods.length > 0 ? [...route2.methods] : route2.method ? [route2.method] : ["ALL"];
-  return input.map((method) => String(method).toUpperCase());
-}
-__name(normalizeIntegrationRouteMethods, "normalizeIntegrationRouteMethods");
-function normalizeIntegrationRouteInputSchemas(route2) {
-  const input = {
-    ...route2.input
-  };
-  if (route2.body) {
-    input.body = route2.body;
-  }
-  if (route2.query) {
-    input.query = route2.query;
-  }
-  return input.body || input.query ? input : void 0;
-}
-__name(normalizeIntegrationRouteInputSchemas, "normalizeIntegrationRouteInputSchemas");
-async function validateIntegrationRouteInput(route2, request, url) {
-  const schemas = route2.input;
-  if (!schemas?.body && !schemas?.query) {
-    return {
-      success: true,
-      input: {}
-    };
-  }
-  const input = {};
-  const issues = [];
-  if (schemas.query) {
-    const queryResult = await parseIntegrationInputSchema(
-      "query",
-      schemas.query,
-      createQueryInput(url.searchParams)
-    );
-    if (queryResult.success) {
-      input.query = queryResult.data;
-    } else {
-      issues.push(...queryResult.issues);
-    }
-  }
-  if (schemas.body) {
-    const bodyInput = await readIntegrationValidationBody(
-      request,
-      getIntegrationRouteBodyFormat(route2)
-    );
-    if (bodyInput.success) {
-      const bodyResult = await parseIntegrationInputSchema("body", schemas.body, bodyInput.data);
-      if (bodyResult.success) {
-        input.body = bodyResult.data;
-      } else {
-        issues.push(...bodyResult.issues);
-      }
-    } else {
-      issues.push(bodyInput.issue);
-    }
-  }
-  if (issues.length > 0) {
-    return {
-      success: false,
-      response: createIntegrationValidationResponse(issues)
-    };
-  }
-  return {
-    success: true,
-    input
-  };
-}
-__name(validateIntegrationRouteInput, "validateIntegrationRouteInput");
-async function parseIntegrationInputSchema(source, schema, value) {
-  const parser = schema.safeParseAsync || schema.safeParse;
-  if (parser) {
-    const result = await parser.call(schema, value);
-    if (result.success) {
-      return {
-        success: true,
-        data: result.data
-      };
-    }
-    return {
-      success: false,
-      issues: normalizeIntegrationValidationIssues(source, result.error)
-    };
-  }
-  if (schema["~standard"]?.validate) {
-    const result = await schema["~standard"].validate(value);
-    if ("value" in result) {
-      return {
-        success: true,
-        data: result.value
-      };
-    }
-    return {
-      success: false,
-      issues: normalizeIntegrationValidationIssues(source, {
-        issues: result.issues
-      })
-    };
-  }
-  if (schema.parse) {
-    try {
-      return {
-        success: true,
-        data: await schema.parse(value)
-      };
-    } catch (error) {
-      return {
-        success: false,
-        issues: normalizeIntegrationValidationIssues(
-          source,
-          normalizeIntegrationValidationError(error)
-        )
-      };
-    }
-  }
-  return {
-    success: false,
-    issues: [
-      {
-        source,
-        message: "Input schema must expose safeParse, safeParseAsync, parse, or ~standard.validate."
-      }
-    ]
-  };
-}
-__name(parseIntegrationInputSchema, "parseIntegrationInputSchema");
-function createIntegrationValidationResponse(issues) {
-  return Response.json(
-    {
-      error: "Integration route input validation failed",
-      issues
-    },
-    {
-      status: 400
-    }
-  );
-}
-__name(createIntegrationValidationResponse, "createIntegrationValidationResponse");
-function normalizeIntegrationValidationIssues(source, error) {
-  if (Array.isArray(error.issues) && error.issues.length > 0) {
-    return error.issues.map((issue) => ({
-      source,
-      path: normalizeIntegrationValidationPath(issue.path),
-      code: issue.code,
-      message: issue.message || "Invalid input"
-    }));
-  }
-  return [
-    {
-      source,
-      path: [],
-      message: error.message || "Invalid input"
-    }
-  ];
-}
-__name(normalizeIntegrationValidationIssues, "normalizeIntegrationValidationIssues");
-function normalizeIntegrationValidationPath(path) {
-  return (path || []).map((segment) => {
-    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
-    return typeof key === "symbol" ? key.description || key.toString() : key;
-  });
-}
-__name(normalizeIntegrationValidationPath, "normalizeIntegrationValidationPath");
-function normalizeIntegrationValidationError(error) {
-  if (error && typeof error === "object") {
-    return error;
-  }
-  return {
-    message: error instanceof Error ? error.message : String(error || "Invalid input")
-  };
-}
-__name(normalizeIntegrationValidationError, "normalizeIntegrationValidationError");
-async function readIntegrationValidationBody(request, format) {
-  if (request.method === "GET" || request.method === "HEAD" || format === "none") {
-    return {
-      success: true,
-      data: void 0
-    };
-  }
-  try {
-    if (format === "form") {
-      return {
-        success: true,
-        data: createFormInput(await request.clone().formData())
-      };
-    }
-    const text = await request.clone().text();
-    if (text.trim().length === 0) {
-      return {
-        success: true,
-        data: void 0
-      };
-    }
-    return {
-      success: true,
-      data: JSON.parse(text)
-    };
-  } catch (error) {
-    return {
-      success: false,
-      issue: {
-        source: "body",
-        path: [],
-        message: format === "json" ? "Expected a valid JSON request body." : error instanceof Error && error.message ? error.message : "Could not parse request body."
-      }
-    };
-  }
-}
-__name(readIntegrationValidationBody, "readIntegrationValidationBody");
-function getIntegrationRouteBodyFormat(route2) {
-  return route2.bodyFormat || route2.__operation?.bodyFormat || "json";
-}
-__name(getIntegrationRouteBodyFormat, "getIntegrationRouteBodyFormat");
-function createIntegrationRouteArgs(input) {
-  let clientPromise;
-  let ormPromise;
-  const getClient = /* @__PURE__ */ __name(() => {
-    clientPromise ?? (clientPromise = Promise.resolve().then(() => (init_storage(), storage_exports)).then(
-      ({ resolveStorageRuntimeClient: resolveStorageRuntimeClient2 }) => resolveStorageRuntimeClient2(input.config.storage)
-    ));
-    return clientPromise;
-  }, "getClient");
-  const getOrm = /* @__PURE__ */ __name(() => {
-    if (!input.integration.schema) {
-      throw new Error(
-        `Integration "${input.integration.type}" does not define a schema for ctx.args.db.`
-      );
-    }
-    ormPromise ?? (ormPromise = Promise.resolve().then(() => (init_integration_orm(), integration_orm_exports)).then(
-      ({ createIntegrationOrm: createIntegrationOrm2 }) => createIntegrationOrm2({
-        schema: input.integration.schema,
-        config: input.config
-      })
-    ));
-    return ormPromise;
-  }, "getOrm");
-  return {
-    db: createLazyIntegrationOrmClient(getOrm),
-    getDb: getOrm,
-    storage: {
-      getClient,
-      getOrm
-    }
-  };
-}
-__name(createIntegrationRouteArgs, "createIntegrationRouteArgs");
-function createLazyIntegrationOrmClient(resolveOrm) {
-  const modelProxyCache = /* @__PURE__ */ new Map();
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "then") {
-          return void 0;
-        }
-        if (prop === "transaction" || prop === "batch") {
-          return async (...args) => {
-            const orm = await resolveOrm();
-            const member = orm[prop];
-            if (typeof member !== "function") {
-              throw new Error(`Integration ORM does not expose "${String(prop)}".`);
-            }
-            return member.apply(orm, args);
-          };
-        }
-        if (prop === "$driver") {
-          return void 0;
-        }
-        if (!modelProxyCache.has(prop)) {
-          modelProxyCache.set(prop, createLazyIntegrationOrmModel(resolveOrm, prop));
-        }
-        return modelProxyCache.get(prop);
-      }
-    }
-  );
-}
-__name(createLazyIntegrationOrmClient, "createLazyIntegrationOrmClient");
-function createLazyIntegrationOrmModel(resolveOrm, modelName) {
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "then") {
-          return void 0;
-        }
-        return async (...args) => {
-          const orm = await resolveOrm();
-          const model = orm[modelName];
-          const member = model?.[prop];
-          if (typeof member !== "function") {
-            throw new Error(
-              `Integration ORM model "${String(modelName)}" does not expose "${String(prop)}".`
-            );
-          }
-          return member.apply(model, args);
-        };
-      }
-    }
-  );
-}
-__name(createLazyIntegrationOrmModel, "createLazyIntegrationOrmModel");
-async function runIntegrationRouteBeforeHooks(route2, request, context) {
-  const hookContext = context;
-  hookContext.response = void 0;
-  for (const hook of route2.before || []) {
-    const response = await hook(request, hookContext);
-    if (response) {
-      hookContext.response = response;
-      return response;
-    }
-    if (hookContext.response) {
-      return hookContext.response;
-    }
-  }
-  return void 0;
-}
-__name(runIntegrationRouteBeforeHooks, "runIntegrationRouteBeforeHooks");
-async function runIntegrationRouteAfterHooks(route2, request, context, response) {
-  const hookContext = context;
-  let currentResponse = response;
-  for (const hook of route2.after || []) {
-    hookContext.response = currentResponse;
-    const nextResponse = await hook(request, hookContext);
-    currentResponse = nextResponse || hookContext.response || currentResponse;
-  }
-  hookContext.response = currentResponse;
-  return currentResponse;
-}
-__name(runIntegrationRouteAfterHooks, "runIntegrationRouteAfterHooks");
-function createQueryInput(searchParams) {
-  const input = {};
-  searchParams.forEach((value, key) => {
-    const existing = input[key];
-    if (existing === void 0) {
-      input[key] = value;
-      return;
-    }
-    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-  });
-  return input;
-}
-__name(createQueryInput, "createQueryInput");
-function createFormInput(formData) {
-  const input = {};
-  formData.forEach((value, key) => {
-    const existing = input[key];
-    if (existing === void 0) {
-      input[key] = value;
-      return;
-    }
-    input[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-  });
-  return input;
-}
-__name(createFormInput, "createFormInput");
-async function dispatchIntegrationRequest(runtime, request, options = {}) {
-  const integration = runtime.integration;
-  const url = new URL(request.url);
-  const pathname = url.pathname;
-  const requestId = request.headers.get("x-request-id") || options.currentRequest?.headers.get("x-request-id") || String(Date.now());
-  const routes = normalizeIntegrationRoutes(integration.routes || []);
-  const middleware = [...integration.middleware || []];
-  for (const entry of middleware) {
-    const params = resolveMatcherParams(entry.matcher, pathname);
-    if (!params) {
-      continue;
-    }
-    const handlerContext = createServerIntegrationHandlerContext({
-      runtime,
-      route: {
-        kind: "middleware",
-        path: normalizeMatcher(entry.matcher),
-        methods: ["ALL"]
-      },
-      request,
-      params,
-      pathname,
-      requestId,
-      currentRequest: options.currentRequest,
-      data: options.data,
-      internal: options.internal === true
-    });
-    const startedAt = Date.now();
-    await integration.log?.({
-      category: integration.category,
-      slot: integration.category,
-      type: integration.type,
-      phase: "request:start",
-      route: {
-        kind: "middleware",
-        path: normalizeMatcher(entry.matcher),
-        methods: ["ALL"]
-      },
-      request,
-      requestId,
-      context: handlerContext.req.snapshot()
-    });
-    try {
-      const response = await entry.handler(request, handlerContext);
-      if (response) {
-        await integration.log?.({
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "middleware",
-            path: normalizeMatcher(entry.matcher),
-            methods: ["ALL"]
-          },
-          request,
-          response,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return response;
-      }
-      await integration.log?.({
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:end",
-        route: {
-          kind: "middleware",
-          path: normalizeMatcher(entry.matcher),
-          methods: ["ALL"]
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        context: handlerContext.req.snapshot()
-      });
-    } catch (error) {
-      await integration.log?.({
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:error",
-        route: {
-          kind: "middleware",
-          path: normalizeMatcher(entry.matcher),
-          methods: ["ALL"]
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        error,
-        context: handlerContext.req.snapshot()
-      });
-      throw error;
-    }
-  }
-  for (const route2 of routes) {
-    const params = matchesMethod(route2.methods, request.method) ? extractPathParams(route2.path, pathname) : null;
-    if (!params) {
-      continue;
-    }
-    const handlerContext = createServerIntegrationHandlerContext({
-      runtime,
-      route: {
-        kind: "route",
-        path: route2.path,
-        methods: route2.methods
-      },
-      request,
-      params,
-      pathname,
-      requestId,
-      currentRequest: options.currentRequest,
-      data: options.data,
-      internal: options.internal === true
-    });
-    const startedAt = Date.now();
-    await integration.log?.({
-      category: integration.category,
-      slot: integration.category,
-      type: integration.type,
-      phase: "request:start",
-      route: {
-        kind: "route",
-        path: route2.path,
-        methods: route2.methods
-      },
-      request,
-      requestId,
-      context: handlerContext.req.snapshot()
-    });
-    try {
-      const validation = await validateIntegrationRouteInput(route2, request, url);
-      if (!validation.success) {
-        await integration.log?.({
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.methods
-          },
-          request,
-          response: validation.response,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return validation.response;
-      }
-      handlerContext.input = validation.input;
-      for (const middlewareEntry of route2.middleware || []) {
-        const middlewareResponse = await middlewareEntry.handler(request, handlerContext);
-        if (middlewareResponse) {
-          await integration.log?.({
-            category: integration.category,
-            slot: integration.category,
-            type: integration.type,
-            phase: "request:end",
-            route: {
-              kind: "route",
-              path: route2.path,
-              methods: route2.methods
-            },
-            request,
-            response: middlewareResponse,
-            requestId,
-            durationMs: Date.now() - startedAt,
-            context: handlerContext.req.snapshot()
-          });
-          return middlewareResponse;
-        }
-      }
-      const beforeResponse = await runIntegrationRouteBeforeHooks(route2, request, handlerContext);
-      if (beforeResponse) {
-        const response2 = await runIntegrationRouteAfterHooks(
-          route2,
-          request,
-          handlerContext,
-          beforeResponse
-        );
-        await integration.log?.({
-          category: integration.category,
-          slot: integration.category,
-          type: integration.type,
-          phase: "request:end",
-          route: {
-            kind: "route",
-            path: route2.path,
-            methods: route2.methods
-          },
-          request,
-          response: response2,
-          requestId,
-          durationMs: Date.now() - startedAt,
-          context: handlerContext.req.snapshot()
-        });
-        return response2;
-      }
-      const handlerResponse = await route2.handler(request, handlerContext);
-      const response = await runIntegrationRouteAfterHooks(
-        route2,
-        request,
-        handlerContext,
-        handlerResponse
-      );
-      await integration.log?.({
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:end",
-        route: {
-          kind: "route",
-          path: route2.path,
-          methods: route2.methods
-        },
-        request,
-        response,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        context: handlerContext.req.snapshot()
-      });
-      return response;
-    } catch (error) {
-      await integration.log?.({
-        category: integration.category,
-        slot: integration.category,
-        type: integration.type,
-        phase: "request:error",
-        route: {
-          kind: "route",
-          path: route2.path,
-          methods: route2.methods
-        },
-        request,
-        requestId,
-        durationMs: Date.now() - startedAt,
-        error,
-        context: handlerContext.req.snapshot()
-      });
-      throw error;
-    }
-  }
-  return null;
-}
-__name(dispatchIntegrationRequest, "dispatchIntegrationRequest");
-globalThis[INTEGRATION_REQUEST_DISPATCHER_KEY] = dispatchIntegrationRequest;
-function 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 matchesMethod(methods, method) {
-  if (!method) {
-    return false;
-  }
-  return methods.some((item) => item.toUpperCase() === method.toUpperCase());
-}
-__name(matchesMethod, "matchesMethod");
-function resolveMatcherParams(matcher, pathname) {
-  if (!matcher) {
-    return {};
-  }
-  const list = Array.isArray(matcher) ? matcher : [matcher];
-  for (const item of list) {
-    if (item === "/(.*)" || item === "*") {
-      return {};
-    }
-    if (item.endsWith("(.*)")) {
-      const prefix = item.slice(0, -4);
-      if (pathname === prefix || pathname.startsWith(`${prefix}/`)) {
-        return {};
-      }
-      continue;
-    }
-    const params = extractPathParams(item, pathname);
-    if (params) {
-      return params;
-    }
-  }
-  return null;
-}
-__name(resolveMatcherParams, "resolveMatcherParams");
-function extractPathParams(pattern, pathname) {
-  const routeSegments = splitPath(pattern);
-  const pathSegments = splitPath(pathname);
-  const params = {};
-  let routeIndex = 0;
-  let pathIndex = 0;
-  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
-    const routeSegment = routeSegments[routeIndex];
-    const pathSegment = pathSegments[pathIndex];
-    if (isCatchAllSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex).map((segment) => decodeURIComponent(segment));
-      return params;
-    }
-    if (isDynamicSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = decodeURIComponent(pathSegment);
-      routeIndex += 1;
-      pathIndex += 1;
-      continue;
-    }
-    if (routeSegment !== pathSegment) {
-      return null;
-    }
-    routeIndex += 1;
-    pathIndex += 1;
-  }
-  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
-    return params;
-  }
-  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
-    params[getSegmentParamName(routeSegments[routeIndex])] = [];
-    return params;
-  }
-  return null;
-}
-__name(extractPathParams, "extractPathParams");
-function splitPath(value) {
-  return value.split("/").filter(Boolean);
-}
-__name(splitPath, "splitPath");
-function isDynamicSegment(segment) {
-  return segment.startsWith("[") && segment.endsWith("]");
-}
-__name(isDynamicSegment, "isDynamicSegment");
-function isCatchAllSegment(segment) {
-  return segment.startsWith("[...") && segment.endsWith("]");
-}
-__name(isCatchAllSegment, "isCatchAllSegment");
-function getSegmentParamName(segment) {
-  if (isCatchAllSegment(segment)) {
-    return segment.slice(4, -1);
-  }
-  return segment.slice(1, -1);
-}
-__name(getSegmentParamName, "getSegmentParamName");
-function normalizeMatcher(matcher) {
-  if (!matcher) {
-    return "/(.*)";
-  }
-  return typeof matcher === "string" ? matcher : matcher.join(", ");
-}
-__name(normalizeMatcher, "normalizeMatcher");
-
-// src/agent-runtime.ts
-var AGENT_RUNTIME_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
-var HOP_BY_HOP_HEADERS = [
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-];
-function createAgentRuntimeIntegration(options) {
-  const provider = normalizeProviderName(options.provider);
-  const routePrefix = normalizeAgentRoutePrefix(options.routePrefix);
-  const routePrefixes = [
-    routePrefix,
-    ...(options.additionalRoutePrefixes || []).map(normalizeAgentRoutePrefix)
-  ].filter((prefix, index, values) => values.indexOf(prefix) === index);
-  const originEnv = normalizeOriginEnv(options.originEnv);
-  const state = {
-    origin: resolveConfiguredOrigin(options.origin, originEnv)
-  };
-  const runtimeInstance = {
-    ...options.instance,
-    provider,
-    routePrefix,
-    routePrefixes,
-    getOrigin: /* @__PURE__ */ __name(() => state.origin ?? resolveConfiguredOrigin(options.origin, originEnv), "getOrigin")
-  };
-  const runtimePlugin = {
-    name: `farm:agent-runtime:${provider}`,
-    config(config, context) {
-      if (!context.isDev) {
-        return config;
-      }
-      const origin = runtimeInstance.getOrigin();
-      if (!origin) {
-        return config;
-      }
-      for (const prefix of routePrefixes) {
-        applyAgentRuntimeViteProxy(config, {
-          origin,
-          routePrefix: prefix,
-          webSockets: options.webSockets
-        });
-      }
-      return config;
-    },
-    async afterBundle(result) {
-      if (!result.success || !options.afterBuild) {
-        return;
-      }
-      await options.afterBuild({
-        ...result,
-        provider,
-        routePrefix,
-        routePrefixes
-      });
-    }
-  };
-  return defineIntegration({
-    category: "agent",
-    type: provider,
-    serverRuntime: options.serverRuntime,
-    instance: runtimeInstance,
-    async setup(context) {
-      if (!context.isDev || state.origin || !options.startDev) {
-        return;
-      }
-      state.managed = await options.startDev({
-        root: context.appConfig.root || process.cwd(),
-        log: context.log
-      });
-      state.origin = normalizeAgentOrigin(state.managed.origin);
-      context.log.info(`${provider} runtime ready`, {
-        origin: state.origin
-      });
-      await context.cleanup(async () => {
-        await state.managed?.stop();
-        state.managed = void 0;
-        state.origin = void 0;
-      });
-    },
-    routes: routePrefixes.map((prefix) => ({
-      path: `${prefix}/[...farmAgentRuntimePath]`,
-      methods: AGENT_RUNTIME_METHODS,
-      rawBody: true,
-      async handler(request) {
-        const origin = runtimeInstance.getOrigin();
-        if (!origin) {
-          return Response.json(
-            {
-              error: "Agent runtime unavailable",
-              provider
-            },
-            { status: 503 }
-          );
-        }
-        return proxyAgentRuntimeRequest(request, origin);
-      }
-    })),
-    plugins: [runtimePlugin, ...options.plugins || []]
-  });
-}
-__name(createAgentRuntimeIntegration, "createAgentRuntimeIntegration");
-function applyAgentRuntimeViteProxy(config, input) {
-  const origin = normalizeAgentOrigin(input.origin);
-  const routePrefix = normalizeAgentRoutePrefix(input.routePrefix);
-  const vite = config.vite || {};
-  const server = vite.server || {};
-  const proxy = server.proxy || {};
-  if (proxy[routePrefix]) {
-    throw new Error(
-      `Farm agent runtime cannot own ${routePrefix} because vite.server.proxy already defines it.`
-    );
-  }
-  config.vite = {
-    ...vite,
-    server: {
-      ...server,
-      proxy: {
-        ...proxy,
-        [routePrefix]: {
-          target: origin,
-          changeOrigin: true,
-          ws: input.webSockets === true
-        }
-      }
-    }
-  };
-}
-__name(applyAgentRuntimeViteProxy, "applyAgentRuntimeViteProxy");
-async function proxyAgentRuntimeRequest(request, origin, options = {}) {
-  const upstreamOrigin = normalizeAgentOrigin(origin);
-  const incomingUrl = new URL(request.url);
-  const targetUrl = new URL(`${incomingUrl.pathname}${incomingUrl.search}`, upstreamOrigin);
-  const headers = createProxyRequestHeaders(request.headers, incomingUrl);
-  const method = request.method.toUpperCase();
-  const init = {
-    method,
-    headers,
-    redirect: "manual",
-    signal: request.signal
-  };
-  if (method !== "GET" && method !== "HEAD" && request.body) {
-    init.body = request.body;
-    init.duplex = "half";
-  }
-  try {
-    const upstream = await (options.fetch || globalThis.fetch)(targetUrl, init);
-    const responseHeaders = new Headers(upstream.headers);
-    removeHopByHopHeaders(responseHeaders);
-    rewriteProxyLocation(responseHeaders, upstreamOrigin, incomingUrl.origin);
-    return new Response(upstream.body, {
-      status: upstream.status,
-      statusText: upstream.statusText,
-      headers: responseHeaders
-    });
-  } catch (error) {
-    if (request.signal.aborted || isAbortError(error)) {
-      throw error;
-    }
-    return Response.json(
-      {
-        error: "Agent runtime request failed"
-      },
-      { status: 502 }
-    );
-  }
-}
-__name(proxyAgentRuntimeRequest, "proxyAgentRuntimeRequest");
-async function startManagedAgentRuntime(options) {
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  const stopTimeoutMs = 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 || []], {
-    cwd: options.cwd,
-    env: {
-      ...process.env,
-      ...options.env
-    },
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const origin = await new Promise((resolveOrigin, reject) => {
-    let timer;
-    const finish = /* @__PURE__ */ __name(() => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      child.off("error", onError);
-      child.off("exit", onExit);
-    }, "finish");
-    const succeed = /* @__PURE__ */ __name(async (candidate) => {
-      if (settled || checkingReadiness) return;
-      checkingReadiness = true;
-      try {
-        const normalized = normalizeAgentOrigin(candidate);
-        await waitForAgentRuntime(normalized, options.healthPath, timeoutMs, child);
-        finish();
-        resolveOrigin(normalized);
-      } catch (error) {
-        finish();
-        terminateChild(child);
-        reject(error);
-      }
-    }, "succeed");
-    timer = setTimeout(() => {
-      finish();
-      terminateChild(child);
-      reject(new Error(`${options.label} did not become ready within ${timeoutMs}ms.`));
-    }, timeoutMs);
-    const onError = /* @__PURE__ */ __name((error) => {
-      finish();
-      reject(error);
-    }, "onError");
-    const onExit = /* @__PURE__ */ __name((code, signal) => {
-      finish();
-      reject(
-        new Error(
-          `${options.label} exited before it was ready (code ${String(code)}, signal ${String(signal)}).`
-        )
-      );
-    }, "onExit");
-    const onData = /* @__PURE__ */ __name((chunk, stream) => {
-      const text = chunk.toString("utf8");
-      output = `${output}${text}`.slice(-16384);
-      emitProcessOutput(text, stream, options.onOutput);
-      if (!fixedOrigin && options.resolveOrigin) {
-        const candidate = options.resolveOrigin(output);
-        if (candidate) {
-          void succeed(candidate);
-        }
-      }
-    }, "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"));
-    if (fixedOrigin) {
-      void succeed(fixedOrigin);
-    }
-  });
-  return {
-    origin,
-    process: child,
-    async stop() {
-      if (child.exitCode !== null || child.signalCode !== null) {
-        return;
-      }
-      child.kill("SIGTERM");
-      const exited = await waitForChildExit(child, stopTimeoutMs);
-      if (!exited && child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
-        await waitForChildExit(child, stopTimeoutMs);
-      }
-    }
-  };
-}
-__name(startManagedAgentRuntime, "startManagedAgentRuntime");
-async function findAvailableAgentRuntimePort(host = "127.0.0.1") {
-  return await new Promise((resolvePort, reject) => {
-    const server = (0, import_node_net.createServer)();
-    server.unref();
-    server.once("error", reject);
-    server.listen(0, host, () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close();
-        reject(new Error("Unable to allocate an agent runtime port."));
-        return;
-      }
-      const port = address.port;
-      server.close((error) => {
-        if (error) reject(error);
-        else resolvePort(port);
-      });
-    });
-  });
-}
-__name(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"));
-  let packageJsonPath;
-  try {
-    packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
-  } catch {
-    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];
-  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))) {
-    throw new Error(`${packageName} exposes a binary outside its package root.`);
-  }
-  return binaryPath;
-}
-__name(resolveProjectPackageBin, "resolveProjectPackageBin");
-function normalizeAgentOrigin(value) {
-  const input = value.trim();
-  if (!input) {
-    throw new Error("Agent runtime origin cannot be empty.");
-  }
-  const url = new URL(input);
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error("Agent runtime origin must use http or https.");
-  }
-  if (url.username || url.password) {
-    throw new Error("Agent runtime origin cannot contain credentials.");
-  }
-  if (url.pathname !== "/" || url.search || url.hash) {
-    throw new Error("Agent runtime origin must not contain a path, query, or hash.");
-  }
-  return url.origin;
-}
-__name(normalizeAgentOrigin, "normalizeAgentOrigin");
-function normalizeAgentRoutePrefix(value) {
-  const normalized = `/${value.trim()}`.replace(/\/{2,}/g, "/");
-  if (normalized === "/") {
-    throw new Error("Agent runtime route prefix cannot own the application root.");
-  }
-  return normalized.replace(/\/$/, "");
-}
-__name(normalizeAgentRoutePrefix, "normalizeAgentRoutePrefix");
-function normalizeProviderName(value) {
-  const provider = value.trim();
-  if (!provider || !/^[a-z0-9][a-z0-9._-]*$/i.test(provider)) {
-    throw new Error("Agent runtime provider must be a non-empty package-style name.");
-  }
-  return provider;
-}
-__name(normalizeProviderName, "normalizeProviderName");
-function normalizeOriginEnv(value) {
-  if (!value) return [];
-  return (Array.isArray(value) ? value : [value]).map((entry) => entry.trim()).filter(Boolean);
-}
-__name(normalizeOriginEnv, "normalizeOriginEnv");
-function resolveConfiguredOrigin(configuredOrigin, envNames) {
-  if (configuredOrigin) {
-    return normalizeAgentOrigin(configuredOrigin);
-  }
-  for (const envName of envNames) {
-    const value = process.env[envName];
-    if (value?.trim()) {
-      return normalizeAgentOrigin(value);
-    }
-  }
-  return void 0;
-}
-__name(resolveConfiguredOrigin, "resolveConfiguredOrigin");
-function createProxyRequestHeaders(input, incomingUrl) {
-  const headers = new Headers(input);
-  removeHopByHopHeaders(headers);
-  headers.delete("host");
-  headers.delete("content-length");
-  headers.delete("accept-encoding");
-  if (!headers.has("x-forwarded-host")) headers.set("x-forwarded-host", incomingUrl.host);
-  if (!headers.has("x-forwarded-proto")) {
-    headers.set("x-forwarded-proto", incomingUrl.protocol.replace(":", ""));
-  }
-  return headers;
-}
-__name(createProxyRequestHeaders, "createProxyRequestHeaders");
-function removeHopByHopHeaders(headers) {
-  for (const header of HOP_BY_HOP_HEADERS) {
-    headers.delete(header);
-  }
-}
-__name(removeHopByHopHeaders, "removeHopByHopHeaders");
-function rewriteProxyLocation(headers, upstreamOrigin, incomingOrigin) {
-  const location = headers.get("location");
-  if (!location) return;
-  try {
-    const url = new URL(location, upstreamOrigin);
-    if (url.origin === upstreamOrigin) {
-      headers.set("location", `${incomingOrigin}${url.pathname}${url.search}${url.hash}`);
-    }
-  } catch {
-  }
-}
-__name(rewriteProxyLocation, "rewriteProxyLocation");
-function isAbortError(error) {
-  return error instanceof Error && error.name === "AbortError";
-}
-__name(isAbortError, "isAbortError");
-async function waitForAgentRuntime(origin, healthPath, timeoutMs, child) {
-  const deadline = Date.now() + timeoutMs;
-  const healthUrl = new URL(healthPath || "/", origin);
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null || child.signalCode !== null) {
-      throw new Error("Agent runtime exited while Farm was waiting for it to become ready.");
-    }
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 750);
-    try {
-      await fetch(healthUrl, {
-        signal: controller.signal,
-        redirect: "manual"
-      });
-      return;
-    } catch {
-      await delay(100);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  throw new Error(`Agent runtime at ${origin} did not answer before the startup timeout.`);
-}
-__name(waitForAgentRuntime, "waitForAgentRuntime");
-function emitProcessOutput(text, stream, onOutput) {
-  if (!onOutput) return;
-  for (const line of text.split(/\r?\n/)) {
-    const value = line.trimEnd();
-    if (value) onOutput(value, stream);
-  }
-}
-__name(emitProcessOutput, "emitProcessOutput");
-function terminateChild(child) {
-  if (child.exitCode === null && child.signalCode === null) {
-    child.kill("SIGTERM");
-  }
-}
-__name(terminateChild, "terminateChild");
-async function waitForChildExit(child, timeoutMs) {
-  if (child.exitCode !== null || child.signalCode !== null) return true;
-  return await new Promise((resolveExit) => {
-    const timer = setTimeout(() => {
-      child.off("exit", onExit);
-      resolveExit(false);
-    }, timeoutMs);
-    const onExit = /* @__PURE__ */ __name(() => {
-      clearTimeout(timer);
-      resolveExit(true);
-    }, "onExit");
-    child.once("exit", onExit);
-  });
-}
-__name(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
-});
-//# sourceMappingURL=agent-runtime.cjs.map