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

package/dist/agent-runtime.cjs

@@ -0,0 +1,2379 @@
+"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