@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-GHNW564E.mjs

@@ -0,0 +1,1044 @@
+import {
+  collectSchemaExtensions,
+  declareSchemaTables,
+  readSchemaTables
+} from "./chunk-2DLGV2ZG.mjs";
+import {
+  resolveSchemaModels
+} from "./chunk-F3N52U7S.mjs";
+import {
+  normalizeFarmPluginRuntimeEndpointPath,
+  normalizeRuntimeEndpointRequestPath
+} from "./chunk-UUMKLGUU.mjs";
+import {
+  pluginShortName
+} from "./chunk-XR2ZIBQK.mjs";
+import {
+  getResolvedEnv
+} from "./chunk-N33DLJBC.mjs";
+import {
+  getFarmPluginIntegrationContext
+} from "./chunk-H4WUWLQR.mjs";
+import {
+  clearRequestContext,
+  copyRequestContext,
+  deleteRequestContext,
+  getRequestContext,
+  getRequestContextSnapshot,
+  hasRequestContext,
+  setRequestContext
+} from "./chunk-D2LCAV6L.mjs";
+import {
+  normalizeFarmBasePath,
+  stripFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/schema-step-types.ts
+function validateSchemaSteps(owner, schema, steps) {
+  if (steps === void 0) return;
+  if (!Array.isArray(steps)) {
+    throw new TypeError(`${owner}: \`migrations\` must be a list of steps.`);
+  }
+  const models = resolveSchemaModels(owner, schema);
+  const ids = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    const where = `${owner} migration "${step?.id}"`;
+    if (!step || typeof step.id !== "string" || step.id.trim() === "") {
+      throw new TypeError(`${owner}: every migration step needs a non-empty \`id\`.`);
+    }
+    if (ids.has(step.id))
+      throw new Error(`${owner}: two migration steps share the id "${step.id}".`);
+    ids.add(step.id);
+    const kinds = ["renameColumn", "renameTable", "dropColumn", "dropTable", "sql"].filter(
+      (kind) => kind in step
+    );
+    if (kinds.length !== 1) {
+      throw new Error(
+        `${where} must be exactly one of renameColumn, renameTable, dropColumn, dropTable, or sql.`
+      );
+    }
+    if ("renameColumn" in step) {
+      const { model, from, to } = step.renameColumn;
+      const target = Object.prototype.hasOwnProperty.call(models, model) ? models[model] : void 0;
+      if (!target)
+        throw new Error(`${where} renames a column of "${model}", which is not a model.`);
+      if (!Object.prototype.hasOwnProperty.call(target.fields, to)) {
+        throw new Error(`${where} renames to "${model}.${to}", which is not a field.`);
+      }
+      if (typeof from !== "string" || from.trim() === "") {
+        throw new Error(`${where} needs the old column name in \`from\`.`);
+      }
+    } else if ("renameTable" in step) {
+      const { from, to } = step.renameTable;
+      if (!Object.prototype.hasOwnProperty.call(models, to)) {
+        throw new Error(`${where} renames a table to "${to}", which is not a model.`);
+      }
+      if (typeof from !== "string" || from.trim() === "") {
+        throw new Error(`${where} needs the old table name in \`from\`.`);
+      }
+    } else if ("dropColumn" in step) {
+      const { model, column } = step.dropColumn;
+      const target = Object.prototype.hasOwnProperty.call(models, model) ? models[model] : void 0;
+      if (!target) {
+        throw new Error(`${where} drops a column of "${model}", which is not a model.`);
+      }
+      if (typeof column !== "string" || column.trim() === "") {
+        throw new Error(`${where} needs the column to drop in \`column\`.`);
+      }
+      const current = Object.entries(target.fields).find(
+        ([key, field]) => key === column || field.name === column
+      );
+      if (current) {
+        throw new Error(`${where} drops "${model}.${column}", which is still in the schema.`);
+      }
+    } else if ("dropTable" in step) {
+      const { table } = step.dropTable;
+      if (typeof table !== "string" || table.trim() === "") {
+        throw new Error(`${where} needs the table to drop in \`table\`.`);
+      }
+      const current = Object.entries(models).find(
+        ([key, model]) => key === table || model.name === table
+      );
+      if (current) {
+        throw new Error(
+          `${where} drops "${table}", which is still in the schema${current[1].external ? " as a table the plugin does not own" : ""}.`
+        );
+      }
+    } else {
+      const sql = step.sql;
+      const dialects = Object.keys(sql ?? {});
+      if (!sql || typeof sql !== "object" || dialects.length === 0) {
+        throw new Error(`${where} needs SQL for at least one of postgres, mysql, or sqlite.`);
+      }
+    }
+  }
+}
+
+// src/plugin-options.ts
+var FarmPluginOptionsError = class extends TypeError {
+  constructor(issues) {
+    const lines = issues.map((issue) => {
+      const path = formatIssuePath(issue.path);
+      return `  - ${path ? `${path}: ` : ""}${issue.message}`;
+    });
+    super(`Invalid plugin options:
+${lines.join("\n")}`);
+    this.name = "FarmPluginOptionsError";
+    this.issues = issues;
+  }
+};
+function formatIssuePath(path) {
+  if (!path?.length) return "";
+  return path.map((segment) => {
+    const key = typeof segment === "object" && segment !== null ? segment.key : segment;
+    return typeof key === "symbol" ? key.toString() : String(key);
+  }).join(".");
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function isPluginOptionsSchema(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
+  const standard = value["~standard"];
+  return typeof standard?.validate === "function";
+}
+function parsePluginOptions(schema, options) {
+  const standard = schema?.["~standard"];
+  if (!standard || typeof standard.validate !== "function") {
+    throw new TypeError(
+      "A plugin's `options` needs a Standard Schema, such as a Zod, Valibot, or ArkType schema."
+    );
+  }
+  const result = standard.validate(options === void 0 ? {} : options);
+  if (isPromiseLike(result)) {
+    throw new TypeError(
+      "Plugin option schemas must validate synchronously: plugins are created while the config loads. Remove asynchronous refinements or transforms from the schema."
+    );
+  }
+  if (result.issues) throw new FarmPluginOptionsError(result.issues);
+  return result.value;
+}
+
+// src/plugin.ts
+var FARM_NODE_RESPONSE_END_PENDING = /* @__PURE__ */ Symbol.for("farm.nodeResponseEndPending");
+var FarmRuntimeShutdownError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.name = "FarmRuntimeShutdownError";
+    this.errors = errors;
+  }
+};
+var PluginManager = class {
+  constructor(context) {
+    this.plugins = [];
+    this.hookPresence = /* @__PURE__ */ new Map();
+    this.runtimeHookPresence = /* @__PURE__ */ new Map();
+    this.pluginStates = /* @__PURE__ */ new Map();
+    this.setupComplete = false;
+    this.initialized = false;
+    this.runtimeReady = false;
+    this.runtimeClosed = false;
+    this.runtimeShutdownHooksRunning = false;
+    this.runtimeDisposers = [];
+    this.runtimeRequestContexts = /* @__PURE__ */ new WeakMap();
+    this.failedRuntimeSessions = /* @__PURE__ */ new WeakSet();
+    this.context = {
+      ...context,
+      lifecycle: {
+        onShutdown: (dispose) => {
+          if (typeof dispose !== "function") {
+            throw new TypeError("Farm lifecycle.onShutdown requires a cleanup function");
+          }
+          if (this.runtimeClosed) {
+            void (async () => {
+              try {
+                await dispose();
+              } catch (error) {
+                console.error("Farm runtime cleanup registered after shutdown failed:", error);
+              }
+            })();
+            return () => {
+            };
+          }
+          this.runtimeDisposers.push(dispose);
+          let registered = true;
+          return () => {
+            if (!registered) return;
+            registered = false;
+            const index = this.runtimeDisposers.indexOf(dispose);
+            if (index >= 0) this.runtimeDisposers.splice(index, 1);
+          };
+        }
+      },
+      requestContext: {
+        set(target, key, value, options) {
+          setRequestContext(target, key, value, options);
+        },
+        get(target, key) {
+          return getRequestContext(target, key);
+        },
+        has(target, key) {
+          return hasRequestContext(target, key);
+        },
+        delete(target, key) {
+          return deleteRequestContext(target, key);
+        },
+        clear(target) {
+          clearRequestContext(target);
+        },
+        getAll(target, options) {
+          return getRequestContextSnapshot(target, options);
+        }
+      }
+    };
+  }
+  createPluginHookContext(plugin, context = this.context) {
+    const integration = getFarmPluginIntegrationContext(plugin);
+    return integration ? { ...context, integration } : context;
+  }
+  createRequestHookContext(target, plugin) {
+    const requestContext = this.context.requestContext;
+    return {
+      ...this.createPluginHookContext(plugin),
+      req: {
+        set(key, value, options) {
+          requestContext.set(target, key, value, options);
+        },
+        get(key) {
+          return requestContext.get(target, key);
+        },
+        has(key) {
+          return requestContext.has(target, key);
+        },
+        delete(key) {
+          return requestContext.delete(target, key);
+        },
+        clear() {
+          requestContext.clear(target);
+        },
+        snapshot(options) {
+          return requestContext.getAll(target, options);
+        }
+      }
+    };
+  }
+  copyRequestStore(source, target) {
+    copyRequestContext(source, target);
+  }
+  copyRuntimeRequestContext(source, target) {
+    const runtimeContext = this.runtimeRequestContexts.get(source);
+    if (runtimeContext) {
+      this.runtimeRequestContexts.set(target, runtimeContext);
+    }
+  }
+  createRuntimeBaseEvent(plugin, request, options, waitUntil) {
+    return {
+      ...this.createStateHookContext(plugin),
+      request,
+      req: this.createRequestHookContext(request, plugin).req,
+      kind: options.kind ?? "request",
+      route: options.route,
+      signal: request.signal,
+      waitUntil
+    };
+  }
+  getRuntimeEndpoints() {
+    if (this.runtimeEndpoints) return this.runtimeEndpoints;
+    const endpoints = [];
+    const owners = /* @__PURE__ */ new Map();
+    for (const plugin of this.getSortedPlugins()) {
+      const configured = plugin.runtime?.endpoints;
+      if (configured === void 0) continue;
+      if (!Array.isArray(configured)) {
+        throw new TypeError(`Farm plugin "${plugin.name}" runtime.endpoints must be an array`);
+      }
+      for (const endpoint of configured) {
+        if (!endpoint || typeof endpoint !== "object") {
+          throw new TypeError(
+            `Farm plugin "${plugin.name}" runtime.endpoints must contain endpoint objects`
+          );
+        }
+        const path = normalizeFarmPluginRuntimeEndpointPath(
+          endpoint.path,
+          `Farm plugin "${plugin.name}" runtime endpoint`
+        );
+        if (typeof endpoint.handler !== "function") {
+          throw new TypeError(
+            `Farm plugin "${plugin.name}" runtime endpoint ${path} requires a handler`
+          );
+        }
+        const owner = owners.get(path);
+        if (owner) {
+          throw new Error(
+            `Farm plugin runtime endpoint ${path} from "${plugin.name}" conflicts with "${owner}"`
+          );
+        }
+        owners.set(path, plugin.name);
+        endpoints.push({ plugin, endpoint, path });
+      }
+    }
+    this.runtimeEndpoints = endpoints;
+    return endpoints;
+  }
+  async runRuntimeEndpoint(request, options, waitUntil, onMatch) {
+    const endpoints = this.getRuntimeEndpoints();
+    if (endpoints.length === 0) return void 0;
+    const requestPathname = new URL(request.url).pathname;
+    const basePath = normalizeFarmBasePath(this.context.config.basePath);
+    if (basePath && requestPathname !== basePath && !requestPathname.startsWith(`${basePath}/`)) {
+      return void 0;
+    }
+    const pathname = normalizeRuntimeEndpointRequestPath(
+      stripFarmBasePath(requestPathname, basePath)
+    );
+    const match = endpoints.find((entry) => entry.path === pathname);
+    if (!match) return void 0;
+    const endpointOptions = {
+      ...options,
+      kind: "endpoint",
+      route: {
+        pathname: requestPathname,
+        pattern: match.path,
+        params: {}
+      }
+    };
+    onMatch(endpointOptions);
+    const response = await match.endpoint.handler({
+      ...this.createRuntimeBaseEvent(match.plugin, request, endpointOptions, waitUntil),
+      path: match.path
+    });
+    if (!(response instanceof Response)) {
+      throw new TypeError(
+        `Farm plugin "${match.plugin.name}" runtime endpoint ${match.path} must return a Response`
+      );
+    }
+    return response;
+  }
+  async createRuntimeRequestContext(request, options, waitUntil) {
+    const values = {};
+    const owners = /* @__PURE__ */ new Map();
+    for (const plugin of this.getSortedPlugins()) {
+      const createContext = plugin.runtime?.context;
+      if (!createContext) continue;
+      const result = await createContext(
+        this.createRuntimeBaseEvent(plugin, request, options, waitUntil)
+      );
+      if (result === void 0) continue;
+      if (!result || typeof result !== "object" || Array.isArray(result)) {
+        throw new TypeError(`Farm plugin "${plugin.name}" runtime.context must return an object`);
+      }
+      for (const [key, value] of Object.entries(result)) {
+        const owner = owners.get(key);
+        if (owner) {
+          throw new Error(
+            `Farm plugin context key "${key}" from "${plugin.name}" conflicts with "${owner}"`
+          );
+        }
+        owners.set(key, plugin.name);
+        values[key] = value;
+      }
+    }
+    const runtimeContext = Object.freeze(values);
+    this.runtimeRequestContexts.set(request, runtimeContext);
+    return runtimeContext;
+  }
+  async runRuntimeErrorHooks(request, error, ctx, durationMs, options, waitUntil) {
+    for (const plugin of this.getSortedPlugins()) {
+      const onError = plugin.runtime?.error;
+      if (!onError) continue;
+      try {
+        await onError({
+          ...this.createRuntimeBaseEvent(plugin, request, options, waitUntil),
+          ctx,
+          error,
+          durationMs
+        });
+      } catch (hookError) {
+        console.error(`Farm plugin "${plugin.name}" runtime.error failed:`, hookError);
+      }
+    }
+    try {
+      await this.runHookParallel("onError", {
+        phase: "runtime",
+        error,
+        meta: {
+          kind: options.kind ?? "request",
+          pathname: new URL(request.url).pathname,
+          durationMs
+        }
+      });
+    } catch (hookError) {
+      console.error("Farm plugin onError hook failed:", hookError);
+    }
+  }
+  createStateHookContext(plugin, context = this.context) {
+    return {
+      ...this.createPluginHookContext(plugin, context),
+      state: this.pluginStates.get(plugin)
+    };
+  }
+  getPluginHooks(plugin, hookName) {
+    const hooks = [];
+    const legacyHook = plugin[hookName];
+    if (typeof legacyHook === "function") {
+      hooks.push(legacyHook);
+    }
+    const withState = (context) => this.createStateHookContext(plugin, context);
+    switch (hookName) {
+      case "config":
+        if (plugin.configure) {
+          hooks.push(
+            (config, context) => plugin.configure?.(config, context)
+          );
+        }
+        break;
+      case "ready":
+        if (plugin.runtime?.start) {
+          hooks.push((context) => plugin.runtime?.start?.(withState(context)));
+        }
+        break;
+      case "shutdown":
+        if (plugin.runtime?.close) {
+          hooks.push(
+            (payload, context) => plugin.runtime?.close?.({
+              ...withState(context),
+              reason: payload.reason
+            })
+          );
+        }
+        break;
+      case "routeDiscovered":
+        if (plugin.router?.discovered) {
+          hooks.push(
+            (route, context) => plugin.router?.discovered?.(route, withState(context))
+          );
+        }
+        break;
+      case "middlewareDiscovered":
+        if (plugin.router?.discovered) {
+          hooks.push(
+            (route, context) => plugin.router?.discovered?.({ kind: "middleware", ...route }, withState(context))
+          );
+        }
+        break;
+      case "apiRouteDiscovered":
+        if (plugin.router?.discovered) {
+          hooks.push(
+            (route, context) => plugin.router?.discovered?.({ kind: "api", ...route }, withState(context))
+          );
+        }
+        break;
+      case "routesGenerated":
+        if (plugin.router?.generated) {
+          hooks.push(
+            (routes, context) => plugin.router?.generated?.(routes, withState(context))
+          );
+        }
+        break;
+      case "beforeRouteMatch":
+        if (plugin.router?.before) {
+          hooks.push(
+            (route, context) => plugin.router?.before?.(route, withState(context))
+          );
+        }
+        break;
+      case "afterRouteMatch":
+        if (plugin.router?.after) {
+          hooks.push(
+            (result, context) => plugin.router?.after?.(result, withState(context))
+          );
+        }
+        break;
+      case "beforeRender":
+        if (plugin.render?.before) {
+          hooks.push(
+            (render, context) => plugin.render?.before?.(render, withState(context))
+          );
+        }
+        break;
+      case "afterRender":
+        if (plugin.render?.html) {
+          hooks.push(
+            (html, render, context) => plugin.render?.html?.(html, render, withState(context))
+          );
+        }
+        break;
+      case "beforeBundle":
+        if (plugin.build?.before) {
+          hooks.push(
+            (bundle, context) => plugin.build?.before?.(bundle, withState(context))
+          );
+        }
+        break;
+      case "beforeNitroBuild":
+        if (plugin.build?.configure) {
+          hooks.push(
+            (buildConfig, context) => plugin.build?.configure?.(buildConfig, withState(context))
+          );
+        }
+        break;
+      case "afterBundle":
+        if (plugin.build?.after) {
+          hooks.push(
+            (result, context) => plugin.build?.after?.(result, withState(context))
+          );
+        }
+        break;
+      case "devServerCreated":
+        if (plugin.dev?.server) {
+          hooks.push(
+            (server, context) => plugin.dev?.server?.(server, withState(context))
+          );
+        }
+        break;
+      case "hmrUpdate":
+        if (plugin.dev?.update) {
+          hooks.push(
+            (update, context) => plugin.dev?.update?.(update, withState(context))
+          );
+        }
+        break;
+    }
+    return hooks;
+  }
+  getHookContext(plugin, hookName, args) {
+    if (hookName === "beforeRequest" || hookName === "afterResponse" || hookName === "beforeApiHandler") {
+      const target = args[0];
+      if (target && typeof target === "object") {
+        return this.createRequestHookContext(target, plugin);
+      }
+    }
+    return this.createPluginHookContext(plugin);
+  }
+  addPlugin(plugin) {
+    this.plugins.push(plugin);
+    this.hookPresence.clear();
+    this.runtimeHookPresence.clear();
+    this.runtimeEndpoints = void 0;
+  }
+  addPlugins(plugins) {
+    for (const plugin of plugins) {
+      this.addPlugin(plugin);
+    }
+  }
+  getPlugins() {
+    return [...this.plugins];
+  }
+  getSortedPlugins() {
+    const pre = this.plugins.filter((p) => p.enforce === "pre");
+    const normal = this.plugins.filter((p) => !p.enforce);
+    const post = this.plugins.filter((p) => p.enforce === "post");
+    return [...pre, ...normal, ...post];
+  }
+  hasHook(hookName) {
+    const cached = this.hookPresence.get(hookName);
+    if (cached !== void 0) return cached;
+    const present = this.plugins.some((plugin) => this.getPluginHooks(plugin, hookName).length > 0);
+    this.hookPresence.set(hookName, present);
+    return present;
+  }
+  hasRuntimeHook(hookName) {
+    const cached = this.runtimeHookPresence.get(hookName);
+    if (cached !== void 0) return cached;
+    const present = this.plugins.some((plugin) => typeof plugin.runtime?.[hookName] === "function");
+    this.runtimeHookPresence.set(hookName, present);
+    return present;
+  }
+  hasRuntimeRequestHooks() {
+    return this.getRuntimeEndpoints().length > 0 || this.hasRuntimeHook("context") || this.hasRuntimeHook("before") || this.hasRuntimeHook("after") || this.hasRuntimeHook("error");
+  }
+  copyRequestContext(source, target) {
+    this.copyRequestStore(source, target);
+    if (source instanceof Request && target instanceof Request) {
+      this.copyRuntimeRequestContext(source, target);
+    }
+  }
+  async setupPlugins() {
+    if (this.setupComplete) return;
+    for (const plugin of this.getSortedPlugins()) {
+      if (!plugin.setup) continue;
+      const state = await plugin.setup({
+        ...this.createPluginHookContext(plugin),
+        env: getResolvedEnv()
+      });
+      this.pluginStates.set(plugin, state);
+    }
+    this.setupComplete = true;
+  }
+  async startRuntime() {
+    if (this.runtimeReady) return;
+    if (this.runtimeStartPromise) return this.runtimeStartPromise;
+    this.runtimeStartPromise = (async () => {
+      this.getRuntimeEndpoints();
+      if (!this.initialized) {
+        await this.runHookParallel("init");
+      }
+      await this.setupPlugins();
+      if (!this.runtimeReady) {
+        await this.runHookParallel("ready");
+      }
+    })();
+    try {
+      await this.runtimeStartPromise;
+    } catch (error) {
+      this.runtimeStartPromise = void 0;
+      throw error;
+    }
+  }
+  async closeRuntime(reason = "runtime-closed") {
+    if (this.runtimeClosePromise) return this.runtimeClosePromise;
+    if (this.runtimeClosed) return;
+    this.runtimeClosePromise = (async () => {
+      const errors = [];
+      this.runtimeShutdownHooksRunning = true;
+      try {
+        await this.runHookParallel("shutdown", { reason });
+      } catch (error) {
+        if (error instanceof FarmRuntimeShutdownError) errors.push(...error.errors);
+        else errors.push(error);
+      } finally {
+        this.runtimeShutdownHooksRunning = false;
+      }
+      while (this.runtimeDisposers.length > 0) {
+        const batch = this.runtimeDisposers.splice(0).reverse();
+        for (const dispose of batch) {
+          try {
+            await dispose();
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+      }
+      this.runtimeClosed = true;
+      if (errors.length > 0) {
+        throw new FarmRuntimeShutdownError("Farm runtime shutdown failed", errors);
+      }
+    })();
+    return this.runtimeClosePromise;
+  }
+  async runBeforeHooks(request, options, waitUntil, ctx) {
+    let activeRequest = request;
+    for (const plugin of this.getSortedPlugins()) {
+      const before = plugin.runtime?.before;
+      if (!before) continue;
+      const result = await before({
+        ...this.createRuntimeBaseEvent(plugin, activeRequest, options, waitUntil),
+        ctx
+      });
+      if (result instanceof Request) {
+        this.copyRequestStore(activeRequest, result);
+        this.copyRuntimeRequestContext(activeRequest, result);
+        activeRequest = result;
+        continue;
+      }
+      if (result instanceof Response) {
+        return { request: activeRequest, response: result };
+      }
+      if (result !== void 0) {
+        throw new TypeError(
+          `Farm plugin "${plugin.name}" runtime.before must return a Request, Response, or undefined`
+        );
+      }
+    }
+    return { request: activeRequest };
+  }
+  /**
+   * Runs only `runtime.before` for a request Farm re-routed internally, such as
+   * a configured rewrite, so guards also see the destination URL. The session
+   * opened for `source` keeps its context; context and after hooks don't rerun.
+   */
+  async runRuntimeBeforeForRewrite(source, request, options = {}) {
+    if (!this.hasRuntimeHook("before")) return request;
+    this.copyRequestContext(source, request);
+    const waitUntil = options.waitUntil ? (promise) => options.waitUntil?.(Promise.resolve(promise)) : (promise) => {
+      void Promise.resolve(promise).catch(() => {
+      });
+    };
+    const result = await this.runBeforeHooks(
+      request,
+      options,
+      waitUntil,
+      this.runtimeRequestContexts.get(request) ?? Object.freeze({})
+    );
+    return result.response ?? result.request;
+  }
+  async beginRuntimeRequest(request, options = {}) {
+    await this.startRuntime();
+    const startedAt = Date.now();
+    const waitUntil = options.waitUntil ? (promise) => options.waitUntil?.(Promise.resolve(promise)) : (promise) => {
+      void Promise.resolve(promise).catch(() => {
+      });
+    };
+    let activeRequest = request;
+    let activeOptions = options;
+    let runtimeContext = Object.freeze({});
+    try {
+      const endpoint = await this.runRuntimeEndpoint(
+        activeRequest,
+        activeOptions,
+        waitUntil,
+        (nextOptions) => {
+          activeOptions = nextOptions;
+        }
+      );
+      if (endpoint) {
+        return {
+          request: activeRequest,
+          response: endpoint,
+          ctx: runtimeContext,
+          startedAt,
+          options: activeOptions,
+          waitUntil
+        };
+      }
+      runtimeContext = await this.createRuntimeRequestContext(
+        activeRequest,
+        activeOptions,
+        waitUntil
+      );
+      const before = await this.runBeforeHooks(
+        activeRequest,
+        activeOptions,
+        waitUntil,
+        runtimeContext
+      );
+      activeRequest = before.request;
+      return {
+        request: activeRequest,
+        response: before.response,
+        ctx: runtimeContext,
+        startedAt,
+        options: activeOptions,
+        waitUntil
+      };
+    } catch (error) {
+      await this.runRuntimeErrorHooks(
+        activeRequest,
+        error,
+        runtimeContext,
+        Date.now() - startedAt,
+        activeOptions,
+        waitUntil
+      );
+      throw error;
+    }
+  }
+  async endRuntimeRequest(session, initialResponse) {
+    let response = initialResponse;
+    try {
+      for (const plugin of this.getSortedPlugins()) {
+        const after = plugin.runtime?.after;
+        if (!after) continue;
+        const result = await after({
+          ...this.createRuntimeBaseEvent(
+            plugin,
+            session.request,
+            session.options,
+            session.waitUntil
+          ),
+          ctx: session.ctx,
+          response,
+          durationMs: Date.now() - session.startedAt
+        });
+        if (result !== void 0) {
+          if (!(result instanceof Response)) {
+            throw new TypeError(
+              `Farm plugin "${plugin.name}" runtime.after must return a Response or undefined`
+            );
+          }
+          response = result;
+        }
+      }
+      return response;
+    } catch (error) {
+      await this.failRuntimeRequest(session, error);
+      throw error;
+    }
+  }
+  async failRuntimeRequest(session, error) {
+    if (this.failedRuntimeSessions.has(session)) return;
+    this.failedRuntimeSessions.add(session);
+    await this.runRuntimeErrorHooks(
+      session.request,
+      error,
+      session.ctx,
+      Date.now() - session.startedAt,
+      session.options,
+      session.waitUntil
+    );
+  }
+  async runRuntimeRequest(request, handler, options = {}) {
+    const session = await this.beginRuntimeRequest(request, options);
+    try {
+      const response = session.response ?? await handler(session.request);
+      if (!(response instanceof Response)) {
+        throw new TypeError("Farm plugin runtime handlers must return a Response");
+      }
+      return await this.endRuntimeRequest(session, response);
+    } catch (error) {
+      await this.failRuntimeRequest(session, error);
+      throw error;
+    }
+  }
+  async runHook(hookName, ...args) {
+    const plugins = this.getSortedPlugins();
+    for (const plugin of plugins) {
+      for (const hook of this.getPluginHooks(plugin, hookName)) {
+        const hookContext = this.getHookContext(plugin, hookName, args);
+        const result = await hook.apply(plugin, [...args, hookContext]);
+        if (result !== void 0) {
+          return result;
+        }
+      }
+    }
+  }
+  async runHookSerial(hookName, initialValue, ...args) {
+    const plugins = this.getSortedPlugins();
+    let value = initialValue;
+    for (const plugin of plugins) {
+      for (const hook of this.getPluginHooks(plugin, hookName)) {
+        const hookArgs = [value, ...args];
+        const hookContext = this.getHookContext(plugin, hookName, hookArgs);
+        const result = await hook.apply(plugin, [...hookArgs, hookContext]);
+        if (result !== void 0) {
+          if (hookName === "beforeApiHandler" && result !== value && value && result && typeof value === "object" && typeof result === "object") {
+            this.copyRequestStore(value, result);
+          }
+          value = result;
+        }
+      }
+    }
+    return value;
+  }
+  async runHookParallel(hookName, ...args) {
+    return this.runHookParallelFiltered(hookName, () => true, ...args);
+  }
+  /** @internal Runs hooks for only the plugins selected by the runtime adapter. */
+  async runHookParallelFiltered(hookName, include, ...args) {
+    if (hookName === "shutdown" && !this.runtimeShutdownHooksRunning) {
+      await this.closeRuntime(args[0]?.reason);
+      return false;
+    }
+    const plugins = this.getSortedPlugins().filter(include);
+    if (hookName === "onError") {
+      const failures = [];
+      const reports = [];
+      for (const plugin of plugins) {
+        for (const hook of this.getPluginHooks(plugin, hookName)) {
+          reports.push(
+            (async () => {
+              try {
+                const hookContext = this.getHookContext(plugin, hookName, args);
+                await hook.apply(plugin, [...args, hookContext]);
+              } catch (error) {
+                failures.push(error);
+              }
+            })()
+          );
+        }
+      }
+      await Promise.all(reports);
+      if (failures.length > 0) throw failures[0];
+      return false;
+    }
+    const sequentialHooks = /* @__PURE__ */ new Set([
+      "ready",
+      "shutdown",
+      "beforeRequest",
+      "afterResponse",
+      "beforeApiHandler",
+      "afterApiHandler",
+      "beforeRouteMatch",
+      "afterRouteMatch",
+      "beforeRender",
+      "afterRender"
+    ]);
+    if (sequentialHooks.has(hookName)) {
+      const shutdownErrors = [];
+      for (const plugin of plugins) {
+        for (const hook of this.getPluginHooks(plugin, hookName)) {
+          if (hookName === "beforeRequest") {
+            const res = args[1];
+            if (res && (res.writableEnded || res[FARM_NODE_RESPONSE_END_PENDING])) {
+              return true;
+            }
+          }
+          const hookContext = this.getHookContext(plugin, hookName, args);
+          try {
+            await hook.apply(plugin, [...args, hookContext]);
+          } catch (error) {
+            if (hookName !== "shutdown") throw error;
+            shutdownErrors.push(error);
+          }
+          if (hookName === "beforeRequest") {
+            const res = args[1];
+            if (res && res.writableEnded) {
+              return true;
+            }
+          }
+        }
+      }
+      if (hookName === "shutdown" && shutdownErrors.length > 0) {
+        throw new FarmRuntimeShutdownError("Farm plugin shutdown hooks failed", shutdownErrors);
+      }
+    } else {
+      const promises = [];
+      try {
+        for (const plugin of plugins) {
+          for (const hook of this.getPluginHooks(plugin, hookName)) {
+            const hookContext = this.getHookContext(plugin, hookName, args);
+            promises.push(hook.apply(plugin, [...args, hookContext]));
+          }
+        }
+      } catch (error) {
+        void Promise.all(promises).catch(() => {
+        });
+        throw error;
+      }
+      await Promise.all(promises);
+    }
+    if (hookName === "init") this.initialized = true;
+    if (hookName === "ready") this.runtimeReady = true;
+    return false;
+  }
+  updateContext(updates) {
+    this.context = {
+      ...this.context,
+      ...updates,
+      requestContext: this.context.requestContext
+    };
+  }
+};
+function definePlugin(plugin) {
+  if (!isPluginOptionsSchema(plugin.options)) return declarePluginSchema(plugin);
+  return createPluginFactory(
+    plugin
+  );
+}
+function createPluginFactory(definition) {
+  const { options: schema, configure, setup, ...plugin } = definition;
+  return (input) => {
+    const options = parsePluginOptions(schema, input);
+    const resolveState = (state) => state === void 0 ? options : state;
+    return declarePluginSchema({
+      ...plugin,
+      ...configure ? {
+        configure: (config, context) => configure(config, { ...context, options })
+      } : {},
+      setup(context) {
+        const state = setup?.({ ...context, options });
+        return state instanceof Promise ? state.then(resolveState) : resolveState(state);
+      }
+    });
+  };
+}
+function pluginSchemaName(pluginName) {
+  const name = pluginShortName(pluginName);
+  if (!/^[a-z0-9][a-z0-9_-]*$/iu.test(name)) {
+    throw new Error(
+      `Plugin "${pluginName}" declares a schema, so its name must end in a word made of letters, numbers, "-" or "_": that word becomes \`farm <name> migrate\`.`
+    );
+  }
+  return name;
+}
+function declarePluginSchema(plugin) {
+  if (plugin.migrations && !plugin.schema) {
+    throw new Error(
+      `Plugin "${plugin.name}" sets \`migrations\` without a \`schema\`: its steps change the schema's tables.`
+    );
+  }
+  if (plugin.database && !plugin.schema) {
+    throw new Error(
+      `Plugin "${plugin.name}" sets \`database\` without a \`schema\`: it only says where the schema's tables live.`
+    );
+  }
+  if (!plugin.schema || readSchemaTables(plugin)) return plugin;
+  const name = pluginSchemaName(plugin.name);
+  const models = resolveSchemaModels(name, plugin.schema);
+  collectSchemaExtensions(name, plugin.schema);
+  validateSchemaSteps(name, plugin.schema, plugin.migrations);
+  const database = plugin.database;
+  return declareSchemaTables(plugin, {
+    name,
+    schema: plugin.schema,
+    // Also listed by key, which tooling from before `external` existed reads.
+    models: Object.keys(models).filter((key) => !models[key].external),
+    ...plugin.dependsOn ? { dependsOn: plugin.dependsOn.map(pluginShortName) } : {},
+    ...plugin.version ? { version: plugin.version } : {},
+    ...plugin.migrations?.length ? { migrations: plugin.migrations } : {},
+    dialect: database?.dialect,
+    resolveClient: async (config) => {
+      if (database?.client !== void 0 && database.client !== null) {
+        const client2 = typeof database.client === "function" ? await database.client() : database.client;
+        if (client2 === void 0 || client2 === null) {
+          throw new Error(`The ${name} plugin's \`database.client\` returned no connection.`);
+        }
+        return client2;
+      }
+      const { resolveIntegrationOrmRuntimeClient } = await import("./integration-orm-CO23MSFE.mjs");
+      const client = await resolveIntegrationOrmRuntimeClient({ config });
+      if (client === void 0 || client === null) {
+        throw new Error(
+          `The ${name} plugin keeps its tables in the app's database: set \`storage.client\` in farm.config.`
+        );
+      }
+      return client;
+    }
+  });
+}
+((definePlugin2) => {
+  function forIntegration() {
+    return function defineBoundPlugin(plugin) {
+      return declarePluginSchema(plugin);
+    };
+  }
+  definePlugin2.forIntegration = forIntegration;
+})(definePlugin || (definePlugin = {}));
+
+export {
+  FarmPluginOptionsError,
+  FARM_NODE_RESPONSE_END_PENDING,
+  FarmRuntimeShutdownError,
+  PluginManager,
+  definePlugin
+};