@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-3EEET2Q5.cjs

@@ -1,1044 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-var _chunkSYW346ZNcjs = require('./chunk-SYW346ZN.cjs');
-
-
-var _chunkGBMWLDCCcjs = require('./chunk-GBMWLDCC.cjs');
-
-
-
-var _chunk47JV57DAcjs = require('./chunk-47JV57DA.cjs');
-
-
-var _chunkLSHX2H5Gcjs = require('./chunk-LSHX2H5G.cjs');
-
-
-var _chunk3EIPOTZVcjs = require('./chunk-3EIPOTZV.cjs');
-
-
-var _chunkDUIP64BFcjs = require('./chunk-DUIP64BF.cjs');
-
-
-
-
-
-
-
-
-var _chunkJYT7AN37cjs = require('./chunk-JYT7AN37.cjs');
-
-
-
-var _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
-
-// 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 = _chunkGBMWLDCCcjs.resolveSchemaModels.call(void 0, owner, schema);
-  const ids = /* @__PURE__ */ new Set();
-  for (const step of steps) {
-    const where = `${owner} migration "${_optionalChain([step, 'optionalAccess', _ => _.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(_nullishCoalesce(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 (!_optionalChain([path, 'optionalAccess', _2 => _2.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 _optionalChain([standard, 'optionalAccess', _3 => _3.validate]) === "function";
-}
-function parsePluginOptions(schema, options) {
-  const standard = _optionalChain([schema, 'optionalAccess', _4 => _4["~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) {
-          _chunkJYT7AN37cjs.setRequestContext.call(void 0, target, key, value, options);
-        },
-        get(target, key) {
-          return _chunkJYT7AN37cjs.getRequestContext.call(void 0, target, key);
-        },
-        has(target, key) {
-          return _chunkJYT7AN37cjs.hasRequestContext.call(void 0, target, key);
-        },
-        delete(target, key) {
-          return _chunkJYT7AN37cjs.deleteRequestContext.call(void 0, target, key);
-        },
-        clear(target) {
-          _chunkJYT7AN37cjs.clearRequestContext.call(void 0, target);
-        },
-        getAll(target, options) {
-          return _chunkJYT7AN37cjs.getRequestContextSnapshot.call(void 0, target, options);
-        }
-      }
-    };
-  }
-  createPluginHookContext(plugin, context = this.context) {
-    const integration = _chunkDUIP64BFcjs.getFarmPluginIntegrationContext.call(void 0, 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) {
-    _chunkJYT7AN37cjs.copyRequestContext.call(void 0, 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: _nullishCoalesce(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 = _optionalChain([plugin, 'access', _5 => _5.runtime, 'optionalAccess', _6 => _6.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 = _chunk47JV57DAcjs.normalizeFarmPluginRuntimeEndpointPath.call(void 0, 
-          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 = _chunkD22BUQKWcjs.normalizeFarmBasePath.call(void 0, this.context.config.basePath);
-    if (basePath && requestPathname !== basePath && !requestPathname.startsWith(`${basePath}/`)) {
-      return void 0;
-    }
-    const pathname = _chunk47JV57DAcjs.normalizeRuntimeEndpointRequestPath.call(void 0, 
-      _chunkD22BUQKWcjs.stripFarmBasePath.call(void 0, 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 = _optionalChain([plugin, 'access', _7 => _7.runtime, 'optionalAccess', _8 => _8.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 = _optionalChain([plugin, 'access', _9 => _9.runtime, 'optionalAccess', _10 => _10.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: _nullishCoalesce(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) => _optionalChain([plugin, 'access', _11 => _11.configure, 'optionalCall', _12 => _12(config, context)])
-          );
-        }
-        break;
-      case "ready":
-        if (_optionalChain([plugin, 'access', _13 => _13.runtime, 'optionalAccess', _14 => _14.start])) {
-          hooks.push((context) => _optionalChain([plugin, 'access', _15 => _15.runtime, 'optionalAccess', _16 => _16.start, 'optionalCall', _17 => _17(withState(context))]));
-        }
-        break;
-      case "shutdown":
-        if (_optionalChain([plugin, 'access', _18 => _18.runtime, 'optionalAccess', _19 => _19.close])) {
-          hooks.push(
-            (payload, context) => _optionalChain([plugin, 'access', _20 => _20.runtime, 'optionalAccess', _21 => _21.close, 'optionalCall', _22 => _22({
-              ...withState(context),
-              reason: payload.reason
-            })])
-          );
-        }
-        break;
-      case "routeDiscovered":
-        if (_optionalChain([plugin, 'access', _23 => _23.router, 'optionalAccess', _24 => _24.discovered])) {
-          hooks.push(
-            (route, context) => _optionalChain([plugin, 'access', _25 => _25.router, 'optionalAccess', _26 => _26.discovered, 'optionalCall', _27 => _27(route, withState(context))])
-          );
-        }
-        break;
-      case "middlewareDiscovered":
-        if (_optionalChain([plugin, 'access', _28 => _28.router, 'optionalAccess', _29 => _29.discovered])) {
-          hooks.push(
-            (route, context) => _optionalChain([plugin, 'access', _30 => _30.router, 'optionalAccess', _31 => _31.discovered, 'optionalCall', _32 => _32({ kind: "middleware", ...route }, withState(context))])
-          );
-        }
-        break;
-      case "apiRouteDiscovered":
-        if (_optionalChain([plugin, 'access', _33 => _33.router, 'optionalAccess', _34 => _34.discovered])) {
-          hooks.push(
-            (route, context) => _optionalChain([plugin, 'access', _35 => _35.router, 'optionalAccess', _36 => _36.discovered, 'optionalCall', _37 => _37({ kind: "api", ...route }, withState(context))])
-          );
-        }
-        break;
-      case "routesGenerated":
-        if (_optionalChain([plugin, 'access', _38 => _38.router, 'optionalAccess', _39 => _39.generated])) {
-          hooks.push(
-            (routes, context) => _optionalChain([plugin, 'access', _40 => _40.router, 'optionalAccess', _41 => _41.generated, 'optionalCall', _42 => _42(routes, withState(context))])
-          );
-        }
-        break;
-      case "beforeRouteMatch":
-        if (_optionalChain([plugin, 'access', _43 => _43.router, 'optionalAccess', _44 => _44.before])) {
-          hooks.push(
-            (route, context) => _optionalChain([plugin, 'access', _45 => _45.router, 'optionalAccess', _46 => _46.before, 'optionalCall', _47 => _47(route, withState(context))])
-          );
-        }
-        break;
-      case "afterRouteMatch":
-        if (_optionalChain([plugin, 'access', _48 => _48.router, 'optionalAccess', _49 => _49.after])) {
-          hooks.push(
-            (result, context) => _optionalChain([plugin, 'access', _50 => _50.router, 'optionalAccess', _51 => _51.after, 'optionalCall', _52 => _52(result, withState(context))])
-          );
-        }
-        break;
-      case "beforeRender":
-        if (_optionalChain([plugin, 'access', _53 => _53.render, 'optionalAccess', _54 => _54.before])) {
-          hooks.push(
-            (render, context) => _optionalChain([plugin, 'access', _55 => _55.render, 'optionalAccess', _56 => _56.before, 'optionalCall', _57 => _57(render, withState(context))])
-          );
-        }
-        break;
-      case "afterRender":
-        if (_optionalChain([plugin, 'access', _58 => _58.render, 'optionalAccess', _59 => _59.html])) {
-          hooks.push(
-            (html, render, context) => _optionalChain([plugin, 'access', _60 => _60.render, 'optionalAccess', _61 => _61.html, 'optionalCall', _62 => _62(html, render, withState(context))])
-          );
-        }
-        break;
-      case "beforeBundle":
-        if (_optionalChain([plugin, 'access', _63 => _63.build, 'optionalAccess', _64 => _64.before])) {
-          hooks.push(
-            (bundle, context) => _optionalChain([plugin, 'access', _65 => _65.build, 'optionalAccess', _66 => _66.before, 'optionalCall', _67 => _67(bundle, withState(context))])
-          );
-        }
-        break;
-      case "beforeNitroBuild":
-        if (_optionalChain([plugin, 'access', _68 => _68.build, 'optionalAccess', _69 => _69.configure])) {
-          hooks.push(
-            (buildConfig, context) => _optionalChain([plugin, 'access', _70 => _70.build, 'optionalAccess', _71 => _71.configure, 'optionalCall', _72 => _72(buildConfig, withState(context))])
-          );
-        }
-        break;
-      case "afterBundle":
-        if (_optionalChain([plugin, 'access', _73 => _73.build, 'optionalAccess', _74 => _74.after])) {
-          hooks.push(
-            (result, context) => _optionalChain([plugin, 'access', _75 => _75.build, 'optionalAccess', _76 => _76.after, 'optionalCall', _77 => _77(result, withState(context))])
-          );
-        }
-        break;
-      case "devServerCreated":
-        if (_optionalChain([plugin, 'access', _78 => _78.dev, 'optionalAccess', _79 => _79.server])) {
-          hooks.push(
-            (server, context) => _optionalChain([plugin, 'access', _80 => _80.dev, 'optionalAccess', _81 => _81.server, 'optionalCall', _82 => _82(server, withState(context))])
-          );
-        }
-        break;
-      case "hmrUpdate":
-        if (_optionalChain([plugin, 'access', _83 => _83.dev, 'optionalAccess', _84 => _84.update])) {
-          hooks.push(
-            (update, context) => _optionalChain([plugin, 'access', _85 => _85.dev, 'optionalAccess', _86 => _86.update, 'optionalCall', _87 => _87(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 _optionalChain([plugin, 'access', _88 => _88.runtime, 'optionalAccess', _89 => _89[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: _chunk3EIPOTZVcjs.getResolvedEnv.call(void 0, )
-      });
-      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 = _optionalChain([plugin, 'access', _90 => _90.runtime, 'optionalAccess', _91 => _91.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) => _optionalChain([options, 'access', _92 => _92.waitUntil, 'optionalCall', _93 => _93(Promise.resolve(promise))]) : (promise) => {
-      void Promise.resolve(promise).catch(() => {
-      });
-    };
-    const result = await this.runBeforeHooks(
-      request,
-      options,
-      waitUntil,
-      _nullishCoalesce(this.runtimeRequestContexts.get(request), () => ( Object.freeze({})))
-    );
-    return _nullishCoalesce(result.response, () => ( result.request));
-  }
-  async beginRuntimeRequest(request, options = {}) {
-    await this.startRuntime();
-    const startedAt = Date.now();
-    const waitUntil = options.waitUntil ? (promise) => _optionalChain([options, 'access', _94 => _94.waitUntil, 'optionalCall', _95 => _95(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 = _optionalChain([plugin, 'access', _96 => _96.runtime, 'optionalAccess', _97 => _97.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 = await _asyncNullishCoalesce(session.response, async () => ( 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(_optionalChain([args, 'access', _98 => _98[0], 'optionalAccess', _99 => _99.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 = _optionalChain([setup, 'optionalCall', _100 => _100({ ...context, options })]);
-        return state instanceof Promise ? state.then(resolveState) : resolveState(state);
-      }
-    });
-  };
-}
-function pluginSchemaName(pluginName) {
-  const name = _chunkLSHX2H5Gcjs.pluginShortName.call(void 0, 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 || _chunkSYW346ZNcjs.readSchemaTables.call(void 0, plugin)) return plugin;
-  const name = pluginSchemaName(plugin.name);
-  const models = _chunkGBMWLDCCcjs.resolveSchemaModels.call(void 0, name, plugin.schema);
-  _chunkSYW346ZNcjs.collectSchemaExtensions.call(void 0, name, plugin.schema);
-  validateSchemaSteps(name, plugin.schema, plugin.migrations);
-  const database = plugin.database;
-  return _chunkSYW346ZNcjs.declareSchemaTables.call(void 0, 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(_chunkLSHX2H5Gcjs.pluginShortName) } : {},
-    ...plugin.version ? { version: plugin.version } : {},
-    ..._optionalChain([plugin, 'access', _101 => _101.migrations, 'optionalAccess', _102 => _102.length]) ? { migrations: plugin.migrations } : {},
-    dialect: _optionalChain([database, 'optionalAccess', _103 => _103.dialect]),
-    resolveClient: async (config) => {
-      if (_optionalChain([database, 'optionalAccess', _104 => _104.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-52GPGTHO.cjs");
-      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 = exports.definePlugin = {}));
-
-
-
-
-
-
-
-exports.FarmPluginOptionsError = FarmPluginOptionsError; exports.FARM_NODE_RESPONSE_END_PENDING = FARM_NODE_RESPONSE_END_PENDING; exports.FarmRuntimeShutdownError = FarmRuntimeShutdownError; exports.PluginManager = PluginManager; exports.definePlugin = definePlugin;