lumen-framework 3.1.1 → 4.0.0

package/dist/cli.cjs

@@ -40,20 +40,27 @@ __export(index_exports, {
   destroy: () => destroy2,
   generate: () => generate,
   repl: () => repl,
-  serve: () => serve,
-  test: () => test
+  serve: () => serve
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/packages/cli/commands/build.ts
+// src/packages/cli/utils/create-spinner.ts
 var import_ora = __toESM(require("ora"));
+function createSpinner(text) {
+  const { isTTY, columns } = process.stderr;
+  return (0, import_ora.default)({
+    text,
+    spinner: "dots",
+    ...isTTY && !columns ? { isEnabled: false } : {}
+  });
+}
 
 // src/constants.ts
 var import_os = require("os");
 var { env: ENV } = process;
 var CWD = process.cwd();
 var PID = process.pid;
-var PORT = parseInt(ENV.PORT, 10) || 4e3;
+var PORT = parseInt(ENV.PORT ?? "", 10) || 4e3;
 var NODE_ENV = ENV.NODE_ENV || "development";
 var DATABASE_URL = ENV.DATABASE_URL;
 var LUMEN_CONSOLE = ENV.LUMEN_CONSOLE || false;
@@ -90,13 +97,9 @@ function exec(cmd, opts) {
   });
 }
 
-// src/utils/k.ts
-function K() {
-  return this;
-}
-
 // src/utils/try-catch.ts
-async function tryCatch(fn, rescue = K) {
+var noop = () => void 0;
+async function tryCatch(fn, rescue = noop) {
   let result;
   try {
     result = await fn();
@@ -132,7 +135,7 @@ function freezeProps(target, makePublic, ...props) {
       (obj, key) => ({
         ...obj,
         [key]: {
-          value: Reflect.get(target, key),
+          value: target[key],
           writable: false,
           enumerable: makePublic,
           configurable: false
@@ -378,7 +381,7 @@ function chain(source) {
       return source;
     },
     construct(constructor) {
-      return chain(Reflect.construct(constructor, [source]));
+      return chain(new constructor(source));
     }
   };
 }
@@ -588,10 +591,9 @@ async function createManifest(dir, assets, { useStrict }) {
   await writeFile(file, useStrict ? "'use strict';\n\n" : "");
   await Promise.all(
     Array.from(assets).map(([key, value]) => {
-      const write = Reflect.get(writer, key);
-      if (write) {
-        return write(value);
-      } else if (!write && typeof value === "string") {
+      if (Object.hasOwn(writer, key)) {
+        return writer[key](value);
+      } else if (typeof value === "string") {
         return appendFile(file, createExportStatement(key, value));
       }
       return Promise.resolve();
@@ -706,11 +708,15 @@ async function compile(dir, env, opts = {}) {
     bundle: true,
     platform: "node",
     format: "cjs",
-    target: "node20",
+    target: "node22",
     sourcemap: true,
     // Reproduces `rollup-plugin-lumen`: preserves each class's `.name` (Lumen keys
     // models/controllers/serializers off it) against esbuild's own renaming.
     keepNames: true,
+    // Strictness follows `useStrict` alone. Without this, esbuild would apply
+    // whatever tsconfig.json it finds above the app (its `strict` implies
+    // `alwaysStrict`, even for .js files), silently overriding `--use-weak`.
+    tsconfigRaw: { compilerOptions: { alwaysStrict: useStrict } },
     // Bare specifiers stay external (knex, inflection, the app's own deps);
     // relative paths and the two aliases below are bundled in. This matches the
     // old `is-external` split, with the framework itself pulled in via LUMEN_LOCAL.
@@ -727,10 +733,7 @@ async function compile(dir, env, opts = {}) {
 
 // src/packages/cli/commands/build.ts
 async function build2(useStrict = false) {
-  const spinner = new import_ora.default({
-    text: "Building your application...",
-    spinner: "dots"
-  });
+  const spinner = createSpinner("Building your application...");
   spinner.start();
   await compile(CWD, NODE_ENV, {
     useStrict
@@ -740,17 +743,24 @@ async function build2(useStrict = false) {
 
 // src/packages/cli/commands/create.ts
 var import_os3 = require("os");
-var import_ora2 = __toESM(require("ora"));
-var import_chalk10 = require("chalk");
+
+// src/utils/chalk.ts
+var import_chalk = require("chalk");
+var chalk = new import_chalk.Chalk();
+var chalk_default = chalk;
+
+// src/packages/database/constants.ts
+var SQLITE_DRIVER = "better-sqlite3";
+var VALID_DRIVERS = ["pg", SQLITE_DRIVER, "mssql", "mysql", "mysql2"];
 
 // src/packages/cli/utils/driver-for.ts
 var drivers = /* @__PURE__ */ new Map([
   ["postgres", "pg"],
-  ["sqlite", "sqlite3"],
+  ["sqlite", SQLITE_DRIVER],
   ["mysql", "mysql2"]
 ]);
 function driverFor(database = "sqlite") {
-  return drivers.get(database) || "sqlite3";
+  return drivers.get(database) || SQLITE_DRIVER;
 }
 
 // src/packages/cli/templates/application.ts
@@ -778,6 +788,7 @@ var config_default = (name, env) => {
         level: ${isProdENV ? "'INFO'" : "'DEBUG'"},
         format: ${isProdENV ? "'json'" : "'text'"},
         enabled: ${(!isTestENV).toString()},
+        requestBody: ${(!isProdENV).toString()},
 
         filter: {
           params: []
@@ -800,23 +811,28 @@ function indent(amount = 1) {
 }
 
 // src/packages/cli/templates/database.ts
+var SUFFIXES = {
+  development: "dev",
+  test: "test",
+  production: "prod"
+};
 var database_default = (name, driver) => {
   const schemaName = underscore(name);
   let driverName = driver;
   let template2 = "export default {\n";
   let username;
   if (!driverName) {
-    driverName = "sqlite3";
+    driverName = SQLITE_DRIVER;
   }
   if (driverName === "pg") {
     username = "postgres";
-  } else if (driverName !== "pg" && driverName !== "sqlite3") {
+  } else if (driverName !== "pg" && driverName !== SQLITE_DRIVER) {
     username = "root";
   }
   ["development", "test", "production"].forEach((environment) => {
     template2 += `${indent(2)}${environment}: {
 `;
-    if (driverName !== "sqlite3") {
+    if (driverName !== SQLITE_DRIVER) {
       template2 += `${indent(4)}pool: 5,
 `;
     }
@@ -826,23 +842,12 @@ var database_default = (name, driver) => {
       template2 += `${indent(4)}username: '${username}',
 `;
     }
-    switch (environment) {
-      case "development":
-        template2 += `${indent(4)}database: '${schemaName}_dev'
+    if (driverName === SQLITE_DRIVER) {
+      template2 += `${indent(4)}database: '${schemaName}'
 `;
-        break;
-      case "test":
-        template2 += `${indent(4)}database: '${schemaName}_test'
-`;
-        break;
-      case "production":
-        template2 += `${indent(4)}database: '${schemaName}_prod'
-`;
-        break;
-      default:
-        template2 += `${indent(4)}database: '${schemaName}_${environment}'
+    } else {
+      template2 += `${indent(4)}database: '${schemaName}_${SUFFIXES[environment]}'
 `;
-        break;
     }
     template2 += `${indent(2)}}`;
     if (environment !== "production") {
@@ -861,24 +866,23 @@ var seed_default = () => template`
 `;
 
 // package.json
-var version = "3.1.1";
+var version = "4.0.0";
 
 // src/packages/cli/templates/package-json.ts
 var LUMEN_VERSION = version;
 var DRIVER_DEPS = {
-  sqlite3: { name: "sqlite3", version: "^5.1.7" },
-  pg: { name: "pg", version: "^8.16.3" },
-  mysql2: { name: "mysql2", version: "^3.15.3" }
+  [SQLITE_DRIVER]: { name: SQLITE_DRIVER, version: "^13.0.3" },
+  pg: { name: "pg", version: "^8.23.1" },
+  mysql2: { name: "mysql2", version: "^3.24.5" }
 };
 var package_json_default = (name, driver) => {
-  const dbDriver = DRIVER_DEPS[driver] || DRIVER_DEPS.sqlite3;
+  const dbDriver = DRIVER_DEPS[driver] || DRIVER_DEPS[SQLITE_DRIVER];
   const pkg = {
     name,
     version: "0.0.1",
     description: "",
     scripts: {
       start: "lumen serve",
-      test: "lumen test",
       lint: "eslint ."
     },
     author: "",
@@ -889,21 +893,32 @@ var package_json_default = (name, driver) => {
       [dbDriver.name]: dbDriver.version
     },
     devDependencies: {
-      "@eslint/js": "^9.39.5",
-      eslint: "^9.39.5",
-      globals: "^17.7.0"
+      "@eslint/js": "^10.0.1",
+      eslint: "^10.12.0",
+      globals: "^17.13.0"
     },
     engines: {
-      node: ">= 20"
+      node: ">= 22.14"
     }
   };
-  if (dbDriver.name === "sqlite3") {
-    pkg.pnpm = { onlyBuiltDependencies: ["sqlite3"] };
-  }
   return `${JSON.stringify(pkg, null, 2)}
 `;
 };
 
+// src/packages/cli/templates/pnpm-workspace.ts
+var pnpm_workspace_default = (driver) => {
+  const builds = [
+    "esbuild",
+    ...driver === SQLITE_DRIVER ? [SQLITE_DRIVER] : []
+  ];
+  return [
+    "# Build scripts pnpm may skip: these packages work without them.",
+    "allowBuilds:",
+    ...builds.map((name) => `  ${name}: false`),
+    ""
+  ].join("\n");
+};
+
 // src/packages/cli/templates/eslint-config.ts
 var eslint_config_default = () => `import js from '@eslint/js';
 import globals from 'globals';
@@ -936,13 +951,8 @@ var readme_default = (name) => template`
 
   *   \`lumen serve\`
 
-  ## Testing
-
-  *   \`lumen test\`
-
   ## Further Reading / Useful Links
   *   [Lumen](https://github.com/nickschot/lux/)
-  *   [Chai](http://chaijs.com/) / [Mocha](http://mochajs.org/)
 `;
 
 // src/packages/cli/templates/license.ts
@@ -994,9 +1004,6 @@ var gitignore_default = () => template`
   *.DS_Store
 `;
 
-// src/packages/cli/generator/index.ts
-var import_chalk9 = require("chalk");
-
 // src/packages/cli/utils/create-prompt.ts
 var import_readline = require("readline");
 var YES = /^y(es)?$/i;
@@ -1033,11 +1040,9 @@ __export(generate_type_exports, {
   util: () => util
 });
 var import_path12 = require("path");
-var import_chalk8 = require("chalk");
-var import_inflection20 = require("inflection");
+var import_inflection22 = require("inflection");
 
 // src/packages/cli/generator/constants.ts
-var import_chalk = require("chalk");
 var NAMESPACED_RESOURCE_MESSAGE = template`
 
   🎉  It looks like the resource you generated is within a namespace!
@@ -1051,38 +1056,31 @@ var NAMESPACED_RESOURCE_MESSAGE = template`
     Example:
 
     export default function routes() {
-      ${(0, import_chalk.dim)("// this resource will be accessible at /users")}
+      ${chalk_default.dim("// this resource will be accessible at /users")}
       this.resource('users');
 
       this.namespace('admin', function () {
-        ${(0, import_chalk.dim)("// this resource will be accessible at /admin/users")}
+        ${chalk_default.dim("// this resource will be accessible at /admin/users")}
         this.resource('users');
       });
     }
 
 `;
 
-// src/packages/database/errors/invalid-driver-error.ts
-var import_chalk5 = require("chalk");
-
-// src/packages/database/constants.ts
-var VALID_DRIVERS = [
-  "pg",
-  "sqlite3",
-  "mssql",
-  "mysql",
-  "mysql2",
-  "mariasql",
-  "strong-oracle",
-  "oracle"
-];
+// src/utils/k.ts
+function K() {
+  return this;
+}
 
 // src/packages/logger/constants.ts
 var DEBUG = "DEBUG";
 var INFO = "INFO";
 var WARN = "WARN";
 var ERROR = "ERROR";
-var FORMATS = new set_default(["text", "json"]);
+var FORMATS = new set_default([
+  "text",
+  "json"
+]);
 FORMATS.freeze();
 var LEVELS = new map_default([
   [DEBUG, 0],
@@ -1092,9 +1090,26 @@ var LEVELS = new map_default([
 ]);
 LEVELS.freeze();
 
+// src/packages/logger/errors/invalid-config-error.ts
+var InvalidConfigError = class extends Error {
+  constructor(key, value, allowed) {
+    super(
+      `Invalid logging.${key} ${JSON.stringify(value)}; expected one of: ${Array.from(allowed).join(", ")}.`
+    );
+  }
+};
+var invalid_config_error_default = InvalidConfigError;
+
 // src/packages/logger/writer/index.ts
 var import_tty = require("tty");
-var import_chalk2 = require("chalk");
+
+// src/packages/logger/utils/error-name.ts
+function errorName(err) {
+  if (!(err instanceof Error)) {
+    return "Error";
+  }
+  return err.name === "Error" ? err.constructor.name : err.name;
+}
 
 // src/utils/entries.ts
 function entries(source) {
@@ -1113,11 +1128,12 @@ function omit(src, ...omitted) {
 }
 
 // src/packages/logger/writer/constants.ts
-var import_ansi_regex = __toESM(require("ansi-regex"));
-var ANSI = (0, import_ansi_regex.default)();
 var STDOUT = /^(DEBUG|INFO)$/;
 var STDERR = /^(WARN|ERROR)$/;
 
+// src/packages/logger/writer/utils/format-message.ts
+var import_util = require("util");
+
 // src/utils/stringify.ts
 function stringify(value, spaces) {
   if (isObject(value) || Array.isArray(value)) {
@@ -1131,7 +1147,7 @@ function formatMessage(data, format) {
   if (data instanceof Error) {
     return data.stack;
   } else if (format === "json") {
-    return stringify(data).replace(ANSI, "");
+    return (0, import_util.stripVTControlCharacters)(stringify(data));
   }
   return stringify(data, 2);
 }
@@ -1140,17 +1156,31 @@ function formatMessage(data, format) {
 function isMessageObject(value) {
   return Boolean(value) && typeof value === "object";
 }
-function createWriter2(format) {
+function shortRequestId(context) {
+  const id = context?.requestId;
+  return typeof id === "string" && id ? `[${id.slice(0, 8)}]` : "";
+}
+function createWriter2(format, { timestamps = true } = {}) {
   return function write(data) {
-    const { level, ...etc } = data;
-    let { message, timestamp } = etc;
+    const { level, context, timestamp, ...etc } = data;
+    let { message } = etc;
     let output;
     if (format === "json") {
-      output = {};
-      if (isMessageObject(message) && message.message) {
+      if (message instanceof Error) {
         output = {
           timestamp,
           level,
+          ...context,
+          message: message.message,
+          name: errorName(message),
+          ...omit(message, "message"),
+          stack: message.stack
+        };
+      } else if (isMessageObject(message) && message.message) {
+        output = {
+          timestamp,
+          level,
+          ...context,
           message: message.message,
           ...omit(message, "message")
         };
@@ -1158,6 +1188,7 @@ function createWriter2(format) {
         output = {
           timestamp,
           level,
+          ...context,
           message
         };
       }
@@ -1168,21 +1199,27 @@ function createWriter2(format) {
         columns = process.stdout.columns;
       }
       message = formatMessage(message, "text");
+      let label = level.padEnd(5);
       switch (level) {
         case WARN:
-          timestamp = (0, import_chalk2.yellow)(`[${timestamp}]`);
+          label = chalk_default.yellow(label);
           break;
         case ERROR:
-          timestamp = (0, import_chalk2.red)(`[${timestamp}]`);
+          label = chalk_default.red(label);
           break;
         default:
-          timestamp = (0, import_chalk2.dim)(`[${timestamp}]`);
+          label = chalk_default.dim(label);
           break;
       }
-      output = `${timestamp} ${message}
-
-${(0, import_chalk2.dim)("-").repeat(columns)}
-`;
+      const prefix = [
+        timestamps ? chalk_default.dim(`[${timestamp}]`) : "",
+        label,
+        shortRequestId(context)
+      ].filter(Boolean).join(" ");
+      output = columns ? `${prefix} ${message}
+
+${chalk_default.dim("-").repeat(columns)}
+` : `${prefix} ${message}`;
     }
     if (STDOUT.test(level)) {
       process.stdout.write(`${output}
@@ -1194,12 +1231,6 @@ ${(0, import_chalk2.dim)("-").repeat(columns)}
   };
 }
 
-// src/packages/logger/request-logger/utils/log-text.ts
-var import_chalk4 = __toESM(require("chalk"));
-
-// src/packages/logger/request-logger/templates.ts
-var import_chalk3 = require("chalk");
-
 // src/packages/logger/utils/line.ts
 function line(strings, ...values) {
   return insertValues(strings, ...values).replace(/(\r\n|\n|\r|)/gm, "").replace(/\s+/g, " ").trim();
@@ -1214,6 +1245,13 @@ function pad(startTime, endTime, duration) {
   const maxLength = countDigits(endTime - startTime);
   return " ".repeat(maxLength - countDigits(duration)) + duration;
 }
+function handledBy(route) {
+  if (!route) {
+    return "";
+  }
+  const { controller: controller2, action } = route;
+  return ` by ${chalk_default.yellow(controller2.constructor.name)}#${chalk_default.blue(action)}`;
+}
 var debugTemplate = ({
   path: path6,
   stats,
@@ -1227,23 +1265,23 @@ var debugTemplate = ({
   statusMessage,
   remoteAddress
 }) => `${line`
-  Processed ${(0, import_chalk3.cyan)(`${method}`)} "${path6}" from ${remoteAddress}
-  with ${Reflect.apply(colorStr, null, [`${statusCode}`])}
-  ${Reflect.apply(colorStr, null, [`${statusMessage}`])} by ${route ? `${(0, import_chalk3.yellow)(route.controller.constructor.name)}#${(0, import_chalk3.blue)(route.action)}` : null}
+  Processed ${chalk_default.cyan(`${method}`)} "${path6}" from ${remoteAddress}
+  with ${colorStr(`${statusCode}`)}
+  ${colorStr(`${statusMessage}`)}${handledBy(route)}
 `}
 
-${(0, import_chalk3.magenta)("Params")}
+${chalk_default.magenta("Params")}
 
 ${JSON.stringify(params, null, 2)}
 
-${(0, import_chalk3.magenta)("Stats")}
+${chalk_default.magenta("Stats")}
 
 ${stats.map((stat2) => {
   const { type, duration, controller: controller2 } = stat2;
   let { name } = stat2;
-  name = (0, import_chalk3.blue)(name);
+  name = chalk_default.blue(name);
   if (type === "action") {
-    name = `${(0, import_chalk3.yellow)(controller2)}#${name}`;
+    name = `${chalk_default.yellow(controller2)}#${name}`;
   }
   return `${pad(startTime, endTime, duration)} ms ${name}`;
 }).join("\n")}
@@ -1264,29 +1302,68 @@ var infoTemplate = ({
   statusCode,
   statusMessage,
   remoteAddress
-}) => line`
-Processed ${(0, import_chalk3.cyan)(`${method}`)} "${path6}" ${(0, import_chalk3.magenta)("Params")} ${JSON.stringify(
-  params
-)} from ${remoteAddress} in ${(endTime - startTime).toString()} ms with ${Reflect.apply(
-  colorStr,
-  null,
-  [`${statusCode}`]
-)} ${Reflect.apply(colorStr, null, [`${statusMessage}`])} by ${route ? `${(0, import_chalk3.yellow)(route.controller.constructor.name)}#${(0, import_chalk3.blue)(route.action)}` : null}
-`;
+}) => (
+  // Built directly rather than with `line`, which would also collapse runs
+  // of spaces inside param values.
+  [
+    chalk_default.cyan(method),
+    path6,
+    colorStr(`${statusCode} ${statusMessage}`),
+    `in ${endTime - startTime} ms${handledBy(route)}`,
+    remoteAddress ? `from ${remoteAddress}` : "",
+    Object.keys(params).length ? JSON.stringify(params) : ""
+  ].filter(Boolean).join(" ")
+);
 
 // src/packages/logger/request-logger/utils/filter-params.ts
-function filterParams(params, ...filtered) {
-  return entries(params).map(([key, value]) => [
-    key,
-    filtered.indexOf(key) >= 0 ? "[FILTERED]" : value
-  ]).reduce(
-    (result, [key, value]) => ({
-      ...result,
-      [key]: value && typeof value === "object" && !Array.isArray(value) ? filterParams(value, ...filtered) : value
-    }),
+var FILTERED_PARAMS = [
+  "password",
+  "secret",
+  "token"
+];
+var FILTERED = "[FILTERED]";
+function isFiltered(key, filtered) {
+  const name = key.toLowerCase();
+  return filtered.some((item) => name.includes(item.toLowerCase()));
+}
+function filterValue(value, filtered) {
+  if (Array.isArray(value)) {
+    return value.map((item) => filterValue(item, filtered));
+  }
+  if (value && typeof value === "object") {
+    return filterKeys(value, filtered);
+  }
+  return value;
+}
+function filterKeys(params, filtered) {
+  return entries(params).reduce(
+    (result, [key, value]) => {
+      result[key] = isFiltered(key, filtered) ? FILTERED : filterValue(value, filtered);
+      return result;
+    },
     {}
   );
 }
+function filterParams(params, ...filtered) {
+  return filterKeys(params, [...FILTERED_PARAMS, ...filtered]);
+}
+
+// src/packages/logger/request-logger/utils/params-for.ts
+var DOCUMENT_MEMBERS = [
+  "data",
+  "meta",
+  "included",
+  "links",
+  "jsonapi",
+  "errors"
+];
+function paramsFor(logger, req) {
+  let params = req.params;
+  if (!logger.requestBody) {
+    params = omit(params, ...DOCUMENT_MEMBERS);
+  }
+  return filterParams(params, ...logger.filter.params);
+}
 
 // src/packages/logger/request-logger/utils/log-text.ts
 function logText(logger, {
@@ -1297,15 +1374,18 @@ function logText(logger, {
   res.once("finish", () => {
     const endTime = Date.now();
     const {
+      id: requestId,
+      ip: remoteAddress,
       route,
       method,
-      url: { path: path6 },
-      connection: { remoteAddress }
+      // `pathname`, not `path`: the query string would bypass the param filter;
+      // query params are logged, filtered, under `params`.
+      url: { pathname: path6 }
     } = req;
     const { stats, statusCode, statusMessage } = res;
-    const params = filterParams(req.params, ...logger.filter.params);
+    const params = paramsFor(logger, req);
     const statusColor = statusCode >= 200 && statusCode < 400 ? "green" : "red";
-    let colorStr = Reflect.get(import_chalk4.default, statusColor);
+    let colorStr = chalk_default[statusColor];
     if (typeof colorStr === "undefined") {
       colorStr = (str) => str;
     }
@@ -1322,10 +1402,11 @@ function logText(logger, {
       statusMessage,
       remoteAddress
     };
+    const context = { requestId };
     if (logger.level === DEBUG) {
-      logger.debug(debugTemplate(templateData));
+      logger.debug(debugTemplate(templateData), context);
     } else {
-      logger.info(infoTemplate(templateData));
+      logger.info(infoTemplate(templateData), context);
     }
   });
 }
@@ -1333,31 +1414,41 @@ function logText(logger, {
 // src/packages/logger/request-logger/utils/log-json.ts
 var MESSAGE = "Processed Request";
 function logJSON(logger, {
+  startTime,
   request: req,
   response: res
 }) {
   res.once("finish", () => {
     const {
+      id: requestId,
+      ip: remoteAddress,
+      route,
       method,
       headers,
       httpVersion,
-      url: { path: path6 },
-      connection: { remoteAddress }
+      // `pathname`, not `path`: the query string would bypass the param filter;
+      // query params are logged, filtered, under `params`.
+      url: { pathname: path6 }
     } = req;
     const { statusCode: status } = res;
     const userAgent = headers.get("user-agent");
     const protocol = `HTTP/${httpVersion}`;
-    const params = filterParams(req.params, ...logger.filter.params);
-    logger.info({
-      message: MESSAGE,
-      method,
-      path: path6,
-      params,
-      status,
-      protocol,
-      userAgent,
-      remoteAddress
-    });
+    logger.info(
+      {
+        message: MESSAGE,
+        method,
+        path: path6,
+        status,
+        durationMs: Date.now() - startTime,
+        controller: route?.controller.constructor.name,
+        action: route?.action,
+        params: paramsFor(logger, req),
+        protocol,
+        userAgent,
+        remoteAddress
+      },
+      { requestId }
+    );
   });
 }
 
@@ -1380,24 +1471,28 @@ function createRequestLogger(logger) {
   };
 }
 
-// src/packages/logger/utils/sql.ts
-var PATTERN = /(?:,?`|'|").+(?:`|'|"),?/;
-function sql(strings, ...values) {
-  return insertValues(strings, ...values).split(" ").map((part) => {
-    if (PATTERN.test(part)) {
-      return part;
-    }
-    return part.toUpperCase();
-  }).join(" ");
-}
-
 // src/packages/logger/index.ts
 var Logger = class {
-  constructor({ level, format, filter, enabled }) {
+  constructor({
+    level,
+    format,
+    filter,
+    enabled,
+    requestBody = false,
+    timestamps = true
+  }) {
     let write = K;
     let request = K;
+    if (enabled) {
+      if (!LEVELS.has(level)) {
+        throw new invalid_config_error_default("level", level, LEVELS.keys());
+      }
+      if (!FORMATS.has(format)) {
+        throw new invalid_config_error_default("format", format, FORMATS);
+      }
+    }
     if (!LUMEN_CONSOLE && enabled) {
-      write = createWriter2(format);
+      write = createWriter2(format, { timestamps });
       request = createRequestLogger(this);
     }
     Object.defineProperties(this, {
@@ -1425,6 +1520,18 @@ var Logger = class {
         enumerable: true,
         configurable: false
       },
+      requestBody: {
+        value: Boolean(requestBody),
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      timestamps: {
+        value: Boolean(timestamps),
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
       request: {
         value: request,
         writable: false,
@@ -1434,13 +1541,14 @@ var Logger = class {
     });
     const levelNum = LEVELS.get(level) || 0;
     LEVELS.forEach((val, key) => {
-      Reflect.defineProperty(this, key.toLowerCase(), {
+      Object.defineProperty(this, key.toLowerCase(), {
         writable: false,
         enumerable: false,
         configurable: false,
-        value: val >= levelNum ? (message) => {
+        value: val >= levelNum ? (message, context) => {
           write({
             message,
+            context,
             level: key,
             timestamp: this.getTimestamp()
           });
@@ -1449,9 +1557,8 @@ var Logger = class {
     });
   }
   /**
-   * @method getTimestamp
-   * @return {String} The current time as an ISO8601 string.
-   * @private
+   * @returns The current time as an ISO8601 string.
+   * @internal
    */
   getTimestamp() {
     return (/* @__PURE__ */ new Date()).toISOString();
@@ -1462,11 +1569,19 @@ var logger_default = Logger;
 // src/packages/database/errors/invalid-driver-error.ts
 var InvalidDriverError = class extends Error {
   constructor(driver) {
-    super(line`
-      Invalid database driver ${(0, import_chalk5.yellow)(driver)} in ./config/database.js.
-      Please use one of the following database drivers:
-      ${VALID_DRIVERS.map((str) => (0, import_chalk5.green)(str)).join(", ")}.
-    `);
+    super(
+      driver === "sqlite3" ? line`
+          The database driver ${chalk_default.yellow("sqlite3")} is no longer
+          supported: it is unmaintained. Set ${chalk_default.green(
+        `driver: '${SQLITE_DRIVER}'`
+      )} in ./config/database.js, and replace the sqlite3 dependency with
+          ${chalk_default.green(SQLITE_DRIVER)}. The database files stay the same.
+        ` : line`
+          Invalid database driver ${chalk_default.yellow(driver)} in
+          ./config/database.js. Please use one of the following database
+          drivers: ${VALID_DRIVERS.map((str) => chalk_default.green(str)).join(", ")}.
+        `
+    );
   }
 };
 var invalid_driver_error_default = InvalidDriverError;
@@ -1480,30 +1595,30 @@ var ModelMissingError = class extends Error {
 var model_missing_error_default = ModelMissingError;
 
 // src/packages/database/errors/migrations-pending-error.ts
-var import_chalk6 = require("chalk");
 var MigrationsPendingError = class extends Error {
   constructor(migrations = []) {
-    const pending = migrations.map((str) => (0, import_chalk6.yellow)(str.substr(0, str.length - 3))).join(", ");
+    const pending = migrations.map((str) => chalk_default.yellow(str.substr(0, str.length - 3))).join(", ");
     super(line`
       The following migrations are pending ${pending}.
-      Please run ${(0, import_chalk6.green)("lumen db:migrate")} before starting your application.
+      Please run ${chalk_default.green("lumen db:migrate")} before starting your application.
     `);
   }
 };
 var migrations_pending_error_default = MigrationsPendingError;
 
 // src/packages/server/utils/create-server-error.ts
-function createServerError(Target, statusCode) {
-  const ServerError = class extends Target {
+function createServerError(Target, statusCode, { isPublic = false } = {}) {
+  const StatusError = class extends Target {
     constructor(...args) {
       super(...args);
       this.statusCode = statusCode;
+      this.isPublic = isPublic;
     }
   };
-  Reflect.defineProperty(ServerError, "name", {
+  Object.defineProperty(StatusError, "name", {
     value: Target.name
   });
-  return ServerError;
+  return StatusError;
 }
 
 // src/packages/database/errors/unique-constraint-error.ts
@@ -1519,38 +1634,63 @@ var ConfigMissingError = class extends Error {
 };
 var config_missing_error_default = ConfigMissingError;
 
+// src/packages/database/errors/relationship-config-error.ts
+var RelationshipConfigError = class extends TypeError {
+  constructor(problems) {
+    super(
+      [
+        "Invalid relationships. Each must name its `inverse`: the relationship on the related model that points back:",
+        ...problems.sort().map((problem) => `  - ${problem}`)
+      ].join("\n")
+    );
+  }
+};
+var relationship_config_error_default = RelationshipConfigError;
+
 // src/packages/database/initialize.ts
 var import_cluster = __toESM(require("cluster"));
 
 // src/packages/database/utils/connect.ts
 var import_path10 = require("path");
+function connectionFor(path6, config, databaseUrl = DATABASE_URL) {
+  const { host, socket, driver, database, username, password, port, ssl, url } = config;
+  const connectionUrl = databaseUrl || url;
+  if (connectionUrl) {
+    if (driver === SQLITE_DRIVER || ssl === void 0) {
+      return connectionUrl;
+    }
+    return driver === "pg" ? { connectionString: connectionUrl, ssl } : { uri: connectionUrl, ssl };
+  }
+  return {
+    host,
+    database,
+    password,
+    port,
+    ssl,
+    user: username,
+    socketPath: socket,
+    filename: driver === SQLITE_DRIVER ? (0, import_path10.join)(path6, "db", `${database || "default"}_${NODE_ENV}.sqlite`) : void 0
+  };
+}
 function connect(path6, config) {
   let { pool } = config;
-  const { host, socket, driver, database, username, password, port, ssl, url } = config;
+  const { driver } = config;
   if (VALID_DRIVERS.indexOf(driver) < 0) {
     throw new invalid_driver_error_default(driver);
   }
-  if (pool && typeof pool === "number") {
+  const usingSQLite = driver === SQLITE_DRIVER;
+  if (usingSQLite) {
+    pool = { min: 1, max: 1 };
+  } else if (pool && typeof pool === "number") {
     pool = {
       min: pool > 1 ? 2 : 1,
       max: pool
     };
   }
   const knex = require((0, import_path10.join)(path6, "node_modules", "knex"));
-  const usingSQLite = driver === "sqlite3";
-  const connection = DATABASE_URL || url || {
-    host,
-    database,
-    password,
-    port,
-    ssl,
-    user: username,
-    socketPath: socket,
-    filename: usingSQLite ? (0, import_path10.join)(path6, "db", `${database || "default"}_${NODE_ENV}.sqlite`) : void 0
-  };
   return knex({
     pool,
-    connection,
+    connection: connectionFor(path6, config),
     debug: false,
     client: driver,
     useNullAsDefault: usingSQLite
@@ -1579,10 +1719,91 @@ async function pendingMigrations(appPath, table) {
   );
 }
 
+// src/packages/database/utils/validate-relationships.ts
+var import_inflection5 = require("inflection");
+function pairs(model2, opts, inverse) {
+  const viaJoin = inverse.through === model2;
+  if (inverse.model !== model2 && !viaJoin) {
+    return `points at ${inverse.model.name}, not ${model2.name}`;
+  }
+  if (opts.through) {
+    if (inverse.type !== "hasMany" || inverse.through !== opts.through) {
+      return `is not a hasMany through ${opts.through.name}`;
+    }
+  } else if (opts.type === "belongsTo") {
+    if (inverse.type === "belongsTo") {
+      return "is a belongsTo too; one side must be a hasOne or hasMany";
+    }
+  } else if (!viaJoin && inverse.type !== "belongsTo") {
+    return `is a ${inverse.type}; the other side of a ${opts.type} must be a belongsTo`;
+  }
+  return null;
+}
+function keyHolder(model2, opts) {
+  if (opts.through) {
+    return opts.through;
+  }
+  return opts.type === "belongsTo" ? model2 : opts.model;
+}
+function validateRelationships(models) {
+  const problems = [];
+  for (const model2 of models) {
+    for (const name of model2.relationshipNames) {
+      const opts = model2.relationshipFor(name);
+      if (!opts) {
+        continue;
+      }
+      const { type, inverse, model: related, foreignKey } = opts;
+      const where = `${model2.name}.${type}.${name}`;
+      if (!inverse) {
+        problems.push(`${where} has no \`inverse\``);
+        continue;
+      }
+      const inverseOpts = related.relationshipFor(inverse);
+      if (!inverseOpts) {
+        const names = related.relationshipNames.join(", ") || "none";
+        problems.push(
+          `${where} has inverse '${inverse}', but ${related.name} has no relationship '${inverse}' (it has: ${names})`
+        );
+        continue;
+      }
+      const mismatch = pairs(model2, opts, inverseOpts);
+      if (mismatch) {
+        problems.push(
+          `${where} has inverse '${inverse}', but ${related.name}.${inverseOpts.type}.${inverse} ${mismatch}`
+        );
+        continue;
+      }
+      if (!opts.through && !inverseOpts.through && inverseOpts.foreignKey !== foreignKey) {
+        problems.push(
+          `${where} has foreign key \`${foreignKey}\`, but ${related.name}.${inverseOpts.type}.${inverse} has \`${inverseOpts.foreignKey}\`; both sides must name the same column`
+        );
+        continue;
+      }
+      const holder = keyHolder(model2, opts);
+      const column = (0, import_inflection5.camelize)(foreignKey, true);
+      if (!holder.attributeNames.includes(column)) {
+        problems.push(
+          `${where} needs the foreign key column \`${foreignKey}\` on \`${holder.tableName}\`, which has no such column`
+        );
+      }
+    }
+  }
+  if (problems.length) {
+    throw new relationship_config_error_default(problems);
+  }
+}
+
 // src/packages/database/initialize.ts
 async function initialize2(instance, opts) {
-  const { path: path6, models, logger, checkMigrations } = opts;
-  const config = Reflect.get(opts.config, NODE_ENV);
+  const {
+    path: path6,
+    models,
+    logger,
+    checkMigrations,
+    checkRelationships = true
+  } = opts;
+  const config = opts.config[NODE_ENV];
   if (!config) {
     throw new config_missing_error_default(NODE_ENV);
   }
@@ -1648,21 +1869,24 @@ async function initialize2(instance, opts) {
       (model2) => model2.initialize(instance, () => instance.connection(model2.tableName))
     )
   );
+  if (checkRelationships) {
+    validateRelationships(models.values());
+  }
   return instance;
 }
 
 // src/packages/database/utils/normalize-model-name.ts
-var import_inflection5 = require("inflection");
-var normalize_model_name_default = compose(import_inflection5.singularize, import_inflection5.dasherize, underscore);
+var import_inflection6 = require("inflection");
+var normalize_model_name_default = compose(import_inflection6.singularize, import_inflection6.dasherize, underscore);
 
 // src/packages/database/model/index.ts
-var import_inflection13 = require("inflection");
+var import_inflection15 = require("inflection");
 
 // src/packages/database/query/index.ts
-var import_inflection8 = require("inflection");
+var import_inflection9 = require("inflection");
 
 // src/packages/database/query/utils/format-select.ts
-var import_inflection6 = require("inflection");
+var import_inflection7 = require("inflection");
 
 // src/packages/database/query/errors/record-not-found-error.ts
 var RecordNotFoundError = class extends Error {
@@ -1672,24 +1896,27 @@ var RecordNotFoundError = class extends Error {
     );
   }
 };
-var record_not_found_error_default = createServerError(RecordNotFoundError, 404);
+var record_not_found_error_default = createServerError(RecordNotFoundError, 404, { isPublic: true });
 
 // src/packages/database/query/runner/utils/build-results.ts
-var import_inflection7 = require("inflection");
+var import_inflection8 = require("inflection");
 
 // src/packages/database/relationship/index.ts
-var import_inflection10 = require("inflection");
+var import_inflection12 = require("inflection");
 
 // src/packages/database/relationship/utils/getters.ts
-var import_inflection9 = require("inflection");
+var import_inflection10 = require("inflection");
 
-// src/packages/database/model/initialize-class.ts
+// src/packages/database/relationship/utils/update-relationship.ts
 var import_inflection11 = require("inflection");
 
+// src/packages/database/model/initialize-class.ts
+var import_inflection13 = require("inflection");
+
 // src/packages/server/utils/source-for.ts
-var import_inflection12 = require("inflection");
+var import_inflection14 = require("inflection");
 function memberName(key) {
-  return (0, import_inflection12.dasherize)(underscore(key));
+  return (0, import_inflection14.dasherize)(underscore(key));
 }
 function escapePointer(segment) {
   return segment.replace(/~/g, "~0").replace(/\//g, "~1");
@@ -1716,21 +1943,12 @@ var ValidationError = class extends Error {
     this.source = sourceFor(`data.attributes.${key}`);
   }
 };
-var validation_error_default = createServerError(ValidationError, 422);
+var validation_error_default = createServerError(ValidationError, 422, { isPublic: true });
 
 // src/packages/database/migration/utils/generate-timestamp.ts
-function formatInt(int) {
-  return (int / 10).toString().replace(".", "").substr(0, 2);
-}
-function* padding(char, amount) {
-  for (let i = 0; i < amount; i += 1) {
-    yield char;
-  }
-}
-function generateTimestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const timestamp = now.toISOString().substr(0, 10).split("-").join("") + formatInt(now.getHours()) + formatInt(now.getMinutes()) + formatInt(now.getSeconds()) + formatInt(now.getMilliseconds());
-  return timestamp + Array.from(padding("0", 16 - timestamp.length)).join("");
+var pad2 = (int) => String(int).padStart(2, "0");
+function generateTimestamp(now = /* @__PURE__ */ new Date()) {
+  return String(now.getUTCFullYear()) + pad2(now.getUTCMonth() + 1) + pad2(now.getUTCDate()) + pad2(now.getUTCHours()) + pad2(now.getUTCMinutes()) + pad2(now.getUTCSeconds()) + pad2(Math.floor(now.getUTCMilliseconds() / 10));
 }
 
 // src/packages/database/migration/index.ts
@@ -1761,11 +1979,11 @@ var database_default2 = Database;
 
 // src/packages/cli/templates/model.ts
 var import_os2 = require("os");
-var import_inflection14 = require("inflection");
+var import_inflection16 = require("inflection");
 var VALID_ATTR = /^(\w|-)+:(\w|-)+$/;
 var RELATIONSHIP = /^belongs-to|has-(one|many)$/;
 var model_default2 = (name, attrs) => {
-  const normalized = chain(name).pipe(underscore).pipe(import_inflection14.classify).value();
+  const normalized = chain(name).pipe(underscore).pipe(import_inflection16.classify).value();
   return template`
     import { Model } from 'lumen-framework';
 
@@ -1773,11 +1991,12 @@ var model_default2 = (name, attrs) => {
     ${entries(
     (attrs || []).filter((attr) => VALID_ATTR.test(attr)).map((attr) => attr.split(":")).filter(([, type]) => RELATIONSHIP.test(type)).reduce(
       (types, [related, type]) => {
-        const key = chain(type).pipe(underscore).pipe((str) => (0, import_inflection14.camelize)(str, true)).value();
-        const value = Reflect.get(types, key);
+        const key = chain(type).pipe(underscore).pipe((str) => (0, import_inflection16.camelize)(str, true)).value();
+        const value = types[key];
         if (value) {
-          const inverse = (0, import_inflection14.camelize)(normalized, true);
-          const relatedKey = chain(related).pipe(underscore).pipe((str) => (0, import_inflection14.camelize)(str, true)).value();
+          const singular = (0, import_inflection16.camelize)(normalized, true);
+          const inverse = key === "belongsTo" ? (0, import_inflection16.pluralize)(singular) : singular;
+          const relatedKey = chain(related).pipe(underscore).pipe((str) => (0, import_inflection16.camelize)(str, true)).value();
           return {
             ...types,
             [key]: [
@@ -1812,11 +2031,11 @@ var model_default2 = (name, attrs) => {
 };
 
 // src/packages/cli/templates/serializer.ts
-var import_inflection15 = require("inflection");
+var import_inflection17 = require("inflection");
 var serializer_default = (name, attrs) => {
-  let normalized = chain(name).pipe(underscore).pipe(import_inflection15.classify).value();
+  let normalized = chain(name).pipe(underscore).pipe(import_inflection17.classify).value();
   if (!normalized.endsWith("Application")) {
-    normalized = (0, import_inflection15.pluralize)(normalized);
+    normalized = (0, import_inflection17.pluralize)(normalized);
   }
   const body = entries(
     attrs.filter((attr) => /^(\w|-)+:(\w|-)+$/g.test(attr)).map((attr) => attr.split(":")).reduce(
@@ -1824,7 +2043,7 @@ var serializer_default = (name, attrs) => {
         const [, type] = parts;
         let [attr] = parts;
         let { hasOne, hasMany, attributes } = obj;
-        attr = `${indent(8)}'${(0, import_inflection15.camelize)(underscore(attr), true)}'`;
+        attr = `${indent(8)}'${(0, import_inflection17.camelize)(underscore(attr), true)}'`;
         switch (type) {
           case "belongs-to":
           case "has-one":
@@ -1877,11 +2096,11 @@ ${indent(6)}];`;
 };
 
 // src/packages/cli/templates/controller.ts
-var import_inflection16 = require("inflection");
+var import_inflection18 = require("inflection");
 var controller_default = (name, attrs) => {
-  let normalized = chain(name).pipe(underscore).pipe(import_inflection16.classify).value();
+  let normalized = chain(name).pipe(underscore).pipe(import_inflection18.classify).value();
   if (!normalized.endsWith("Application")) {
-    normalized = (0, import_inflection16.pluralize)(normalized);
+    normalized = (0, import_inflection18.pluralize)(normalized);
   }
   const body = entries(
     attrs.filter((attr) => /^(\w|-)+:(\w|-)+$/g.test(attr)).map((attr) => attr.split(":")[0]).reduce(
@@ -1889,7 +2108,7 @@ var controller_default = (name, attrs) => {
         ...obj,
         params: [
           ...obj.params,
-          `${indent(8)}'${(0, import_inflection16.camelize)(underscore(attr), true)}'`
+          `${indent(8)}'${(0, import_inflection18.camelize)(underscore(attr), true)}'`
         ]
       }),
       { params: [] }
@@ -1931,10 +2150,10 @@ var empty_migration_default = () => template`
 `;
 
 // src/packages/cli/templates/model-migration.ts
-var import_inflection17 = require("inflection");
+var import_inflection19 = require("inflection");
 var model_migration_default = (name, attrs) => {
   const indices = ["id"];
-  const table = chain(name).pipe((str) => str.substr(24)).pipe(underscore).pipe(import_inflection17.pluralize).value();
+  const table = chain(name).pipe((str) => str.substr(24)).pipe(underscore).pipe(import_inflection19.pluralize).value();
   let body = "";
   if (Array.isArray(attrs)) {
     body = attrs.filter((attr) => /^(\w|-)+:(\w|-)+$/g.test(attr)).map((attr) => attr.split(":")).filter(([, type]) => !/^has-(one|many)$/g.test(type)).map((attr) => {
@@ -1975,9 +2194,9 @@ var model_migration_default = (name, attrs) => {
 };
 
 // src/packages/cli/templates/middleware.ts
-var import_inflection18 = require("inflection");
+var import_inflection20 = require("inflection");
 var middleware_default = (name) => {
-  const normalized = chain(name).pipe(underscore).pipe((str) => (0, import_inflection18.camelize)(str, true)).value();
+  const normalized = chain(name).pipe(underscore).pipe((str) => (0, import_inflection20.camelize)(str, true)).value();
   return template`
     export default function ${normalized}(/*request, response*/) {
 
@@ -1986,9 +2205,9 @@ var middleware_default = (name) => {
 };
 
 // src/packages/cli/templates/util.ts
-var import_inflection19 = require("inflection");
+var import_inflection21 = require("inflection");
 var util_default = (name) => {
-  const normalized = chain(name).pipe(underscore).pipe((str) => (0, import_inflection19.camelize)(str, true)).value();
+  const normalized = chain(name).pipe(underscore).pipe((str) => (0, import_inflection21.camelize)(str, true)).value();
   return template`
     export default function ${normalized}() {
 
@@ -2009,7 +2228,6 @@ function log(data) {
 
 // src/packages/cli/generator/utils/create-generator.ts
 var import_path11 = require("path");
-var import_chalk7 = require("chalk");
 var FORWARD_SLASH = /\//g;
 function createGenerator({
   dir,
@@ -2019,18 +2237,18 @@ function createGenerator({
   return async ({ cwd, attrs, onConflict, ...opts }) => {
     const path6 = resolvePath(cwd, dir, `${opts.name}.js`);
     const name = opts.name.replace(FORWARD_SLASH, "-");
-    let action = (0, import_chalk7.green)("create");
+    let action = chalk_default.green("create");
     await mkdirRec(path6.dir);
     if (await hasConflict(path6.absolute)) {
       const shouldContinue = await onConflict(path6.relative);
       if (shouldContinue && typeof shouldContinue === "string") {
         await rmrf_default((0, import_path11.join)(path6.dir, shouldContinue));
-        log(`${(0, import_chalk7.red)("remove")} ${(0, import_path11.join)(dir, shouldContinue)}`);
+        log(`${chalk_default.red("remove")} ${(0, import_path11.join)(dir, shouldContinue)}`);
       } else if (shouldContinue && typeof shouldContinue === "boolean") {
-        action = (0, import_chalk7.yellow)("overwrite");
+        action = chalk_default.yellow("overwrite");
         await rmrf_default(path6.absolute);
       } else {
-        log(`${(0, import_chalk7.yellow)("skip")} ${path6.relative}`);
+        log(`${chalk_default.yellow("skip")} ${path6.relative}`);
         return;
       }
     }
@@ -2069,7 +2287,7 @@ async function controller(opts) {
     template: controller_default
   });
   if (!name.endsWith("application")) {
-    name = (0, import_inflection20.pluralize)(name);
+    name = (0, import_inflection22.pluralize)(name);
   }
   await generate2({
     ...opts,
@@ -2100,7 +2318,7 @@ async function serializer(opts) {
     template: serializer_default
   });
   if (!name.endsWith("application")) {
-    name = (0, import_inflection20.pluralize)(name);
+    name = (0, import_inflection22.pluralize)(name);
   }
   await generate2({
     ...opts,
@@ -2151,7 +2369,7 @@ function modelMigration(opts) {
     template: model_migration_default,
     hasConflict: detectConflict
   });
-  name = chain(name).pipe(import_path12.posix.basename).pipe(import_inflection20.pluralize).pipe((str) => `${generateTimestamp()}-create-${str}`).value();
+  name = chain(name).pipe(import_path12.posix.basename).pipe(import_inflection22.pluralize).pipe((str) => `${generateTimestamp()}-create-${str}`).value();
   return generate2({
     ...opts,
     cwd,
@@ -2169,7 +2387,7 @@ async function model(opts) {
     template: model_default2
   });
   await modelMigration({ ...opts, name });
-  name = chain(name).pipe(import_path12.posix.basename).pipe(import_inflection20.singularize).value();
+  name = chain(name).pipe(import_path12.posix.basename).pipe(import_inflection22.singularize).value();
   return generate2({
     ...opts,
     name
@@ -2219,20 +2437,20 @@ async function resource(opts) {
 `;
       }
       if (index + 1 === closeIndex) {
-        str += `  this.resource('${(0, import_inflection20.pluralize)(opts.name)}');
+        str += `  this.resource('${(0, import_inflection22.pluralize)(opts.name)}');
 `;
       }
       return str;
     }, "")
   ).value();
   await writeFile(path6, routes);
-  log(`${(0, import_chalk8.green)("update")} app/routes.js`);
+  log(`${chalk_default.green("update")} app/routes.js`);
 }
 
 // src/packages/cli/generator/utils/generator-for.ts
 function generatorFor(type) {
   const normalized = type.toLowerCase();
-  const generator = Reflect.get(generate_type_exports, normalized);
+  const generator = generate_type_exports[normalized];
   if (!generator) {
     throw new Error(`Could not find a generator for '${type}'.`);
   }
@@ -2253,7 +2471,9 @@ async function runGenerator({
     type,
     name,
     attrs,
-    onConflict: (path6) => prompt.question(`${(0, import_chalk9.green)("?")} ${(0, import_chalk9.red)("Overwrite")} ${path6}? (Y/n)\r`)
+    onConflict: (path6) => prompt.question(
+      `${chalk_default.green("?")} ${chalk_default.red("Overwrite")} ${path6}? (Y/n)\r`
+    )
   });
   prompt.close();
 }
@@ -2313,23 +2533,24 @@ async function create2(name, database) {
     writeFile(`${project}/LICENSE`, license_default()),
     writeFile(`${project}/package.json`, package_json_default(name, driver)),
     writeFile(`${project}/eslint.config.mjs`, eslint_config_default()),
-    writeFile(`${project}/.gitignore`, gitignore_default())
+    writeFile(`${project}/.gitignore`, gitignore_default()),
+    writeFile(`${project}/pnpm-workspace.yaml`, pnpm_workspace_default(driver))
   ]);
   const logOutput = template`
-    ${(0, import_chalk10.green)("create")} app/index.js
-    ${(0, import_chalk10.green)("create")} app/routes.js
-    ${(0, import_chalk10.green)("create")} bin/app.js
-    ${(0, import_chalk10.green)("create")} config/environments/development.js
-    ${(0, import_chalk10.green)("create")} config/environments/test.js
-    ${(0, import_chalk10.green)("create")} config/environments/production.js
-    ${(0, import_chalk10.green)("create")} config/database.js
-    ${(0, import_chalk10.green)("create")} db/migrate
-    ${(0, import_chalk10.green)("create")} db/seed.js
-    ${(0, import_chalk10.green)("create")} README.md
-    ${(0, import_chalk10.green)("create")} LICENSE
-    ${(0, import_chalk10.green)("create")} package.json
-    ${(0, import_chalk10.green)("create")} eslint.config.mjs
-    ${(0, import_chalk10.green)("create")} .gitignore
+    ${chalk_default.green("create")} app/index.js
+    ${chalk_default.green("create")} app/routes.js
+    ${chalk_default.green("create")} config/environments/development.js
+    ${chalk_default.green("create")} config/environments/test.js
+    ${chalk_default.green("create")} config/environments/production.js
+    ${chalk_default.green("create")} config/database.js
+    ${chalk_default.green("create")} db/migrate
+    ${chalk_default.green("create")} db/seed.js
+    ${chalk_default.green("create")} README.md
+    ${chalk_default.green("create")} LICENSE
+    ${chalk_default.green("create")} package.json
+    ${chalk_default.green("create")} eslint.config.mjs
+    ${chalk_default.green("create")} .gitignore
+    ${chalk_default.green("create")} pnpm-workspace.yaml
   `;
   process.stdout.write(logOutput.substr(0, logOutput.length - 1));
   process.stdout.write(import_os3.EOL);
@@ -2348,12 +2569,9 @@ async function create2(name, database) {
   await exec("git init && git add .", {
     cwd: project
   });
-  process.stdout.write(`${(0, import_chalk10.green)("initialize")} git`);
+  process.stdout.write(`${chalk_default.green("initialize")} git`);
   process.stdout.write(import_os3.EOL);
-  const spinner = new import_ora2.default({
-    text: "Installing dependencies from npm...",
-    spinner: "dots"
-  });
+  const spinner = createSpinner("Installing dependencies from npm...");
   spinner.start();
   await exec("npm install", {
     cwd: project
@@ -2362,7 +2580,7 @@ async function create2(name, database) {
 }
 
 // src/packages/cli/commands/dbcreate.ts
-var import_os4 = require("os");
+var import_os5 = require("os");
 
 // src/utils/github.ts
 var GITHUB_URL = "https://github.com/nickschot/lux";
@@ -2410,12 +2628,14 @@ function createDefaultConfig() {
     server: {
       cors: {
         enabled: false
-      }
+      },
+      trustProxy: false
     },
     logging: {
       level: isProdENV ? "INFO" : "DEBUG",
       format: isProdENV ? "json" : "text",
       enabled: !isTestENV,
+      requestBody: !isProdENV,
       filter: {
         params: []
       }
@@ -2424,14 +2644,11 @@ function createDefaultConfig() {
 }
 
 // src/utils/merge.ts
-function hasOwnProperty2(target, key) {
-  return Reflect.apply(Object.prototype.hasOwnProperty, target, [key]);
-}
 function merge(dest, source) {
   return entries(source).reduce(
     (result, [key, value]) => {
-      if (hasOwnProperty2(result, key) && isObject(value)) {
-        const currentValue = Reflect.get(result, key);
+      if (Object.hasOwn(result, key) && isObject(value)) {
+        const currentValue = result[key];
         if (isObject(currentValue)) {
           return {
             ...result,
@@ -2449,7 +2666,7 @@ function merge(dest, source) {
 }
 
 // src/packages/loader/utils/format-key.ts
-var import_inflection21 = require("inflection");
+var import_inflection23 = require("inflection");
 var NAMESPACE_DELIMITER = /\$-/g;
 function formatKey(key, formatter) {
   return chain(key).pipe((str) => {
@@ -2457,7 +2674,7 @@ function formatKey(key, formatter) {
       return formatter(str);
     }
     return str;
-  }).pipe(underscore).pipe(import_inflection21.dasherize).pipe((str) => str.replace(NAMESPACE_DELIMITER, "/")).value();
+  }).pipe(underscore).pipe(import_inflection23.dasherize).pipe((str) => str.replace(NAMESPACE_DELIMITER, "/")).value();
 }
 
 // src/packages/loader/utils/bundle-for.ts
@@ -2477,10 +2694,7 @@ function normalize(manifest) {
             break;
           case "Up":
           case "Down":
-            obj.migrations.set(
-              formatKey(key),
-              Reflect.construct(migration_default, [value])
-            );
+            obj.migrations.set(formatKey(key), new migration_default(value));
             break;
           default:
             break;
@@ -2490,21 +2704,21 @@ function normalize(manifest) {
           case "Application":
           case "routes":
           case "seed":
-            Reflect.set(obj, formatKey(key), value);
+            obj[formatKey(key)] = value;
             break;
           case "config":
-            Reflect.set(obj, "config", {
+            obj.config = {
               ...merge(createDefaultConfig(), {
                 ...obj.config,
                 ...value
               })
-            });
+            };
             break;
           case "database":
-            Reflect.set(obj, "config", {
+            obj.config = {
               ...obj.config,
               database: value
-            });
+            };
             break;
           default:
             obj.models.set(formatKey(key), value);
@@ -2523,10 +2737,8 @@ function normalize(manifest) {
   );
 }
 function bundleFor(path6) {
-  const manifest = Reflect.apply(require, null, [
-    (0, import_path13.join)(path6, "dist", "bundle")
-  ]);
-  return chain(manifest).pipe(normalize).pipe(entries).pipe((pairs) => new map_default(pairs)).value().freeze();
+  const manifest = require((0, import_path13.join)(path6, "dist", "bundle"));
+  return chain(manifest).pipe(normalize).pipe(entries).pipe((pairs2) => new map_default(pairs2)).value().freeze();
 }
 
 // src/packages/loader/index.ts
@@ -2540,57 +2752,87 @@ function createLoader(path6) {
   };
 }
 
+// src/packages/cli/utils/server-database.ts
+var import_os4 = require("os");
+function serverConfigFor(config) {
+  return {
+    ...config,
+    pool: 1,
+    database: config.driver === "pg" ? "postgres" : void 0
+  };
+}
+function statementFor(connection, action, driver, database) {
+  if (action === "create") {
+    return connection.raw("CREATE DATABASE ??", [database]);
+  }
+  return connection.raw(
+    driver === "pg" ? "DROP DATABASE IF EXISTS ?? WITH (FORCE)" : "DROP DATABASE IF EXISTS ??",
+    [database]
+  );
+}
+async function provision(path6, config, action) {
+  const connection = connect(path6, serverConfigFor(config));
+  try {
+    const statement = statementFor(
+      connection,
+      action,
+      config.driver,
+      config.database
+    );
+    process.stdout.write(`${statement.toString()};${import_os4.EOL}`);
+    await statement;
+  } finally {
+    await connection.destroy();
+  }
+}
+
 // src/packages/cli/commands/dbcreate.ts
 function dbcreate() {
   const load = createLoader(CWD);
-  const config = Reflect.get(load("config").database, NODE_ENV);
+  const config = load("config").database[NODE_ENV];
   if (!config) {
     throw new database_config_missing_default(NODE_ENV);
   }
-  if (config.driver === "sqlite3") {
+  if (config.driver === SQLITE_DRIVER) {
     return writeFile(`${CWD}/db/${config.database}_${NODE_ENV}.sqlite`, "");
   }
   if (DATABASE_URL || config.url) {
     process.stderr.write(CONNECTION_STRING_MESSAGE);
-    process.stderr.write(import_os4.EOL);
+    process.stderr.write(import_os5.EOL);
     return Promise.resolve();
   }
-  const { schema } = connect(CWD, config);
-  const query = `CREATE DATABASE ${config.database}`;
-  const raw = schema.raw(query);
-  return raw.once("query", () => {
-    process.stdout.write(query);
-    process.stdout.write(import_os4.EOL);
-  });
+  return provision(CWD, config, "create");
 }
 
 // src/packages/cli/commands/dbdrop.ts
-var import_os5 = require("os");
+var import_os6 = require("os");
 function dbdrop() {
   const load = createLoader(CWD);
-  const config = Reflect.get(load("config").database, NODE_ENV);
+  const config = load("config").database[NODE_ENV];
   if (!config) {
     throw new database_config_missing_default(NODE_ENV);
   }
-  if (config.driver === "sqlite3") {
+  if (config.driver === SQLITE_DRIVER) {
     return rmrf_default(`${CWD}/db/${config.database}_${NODE_ENV}.sqlite`);
   }
   if (DATABASE_URL || config.url) {
     process.stderr.write(CONNECTION_STRING_MESSAGE);
-    process.stderr.write(import_os5.EOL);
+    process.stderr.write(import_os6.EOL);
     return Promise.resolve();
   }
-  const { schema } = connect(CWD, config);
-  const query = `DROP DATABASE IF EXISTS ${config.database}`;
-  const raw = schema.raw(query);
-  return raw.once("query", () => {
-    process.stdout.write(query);
-    process.stdout.write(import_os5.EOL);
+  return provision(CWD, config, "drop");
+}
+
+// src/packages/cli/utils/print-statements.ts
+var import_os7 = require("os");
+function printStatements(builder, connection, write = (text) => process.stdout.write(text)) {
+  builder.on("query", ({ sql, bindings }) => {
+    write(`${connection.raw(sql, bindings ?? []).toString()};${import_os7.EOL}`);
   });
+  return builder;
 }
 
 // src/packages/cli/commands/dbmigrate.ts
-var import_os6 = require("os");
 async function dbmigrate() {
   const load = createLoader(CWD);
   const { database: config } = load("config");
@@ -2601,6 +2843,7 @@ async function dbmigrate() {
     models,
     path: CWD,
     checkMigrations: false,
+    checkRelationships: false,
     logger: new logger_default({ enabled: false })
   });
   const pending = await pendingMigrations(CWD, () => connection("migrations"));
@@ -2610,11 +2853,7 @@ async function dbmigrate() {
       const key = name.replace(new RegExp(`${version2}-(.+)\\.js`), "$1");
       return [version2, migrations.get(`${key}-up`)];
     }).filter(([, migration2]) => Boolean(migration2)).reverse().map(([version2, migration2]) => () => {
-      const query = migration2.run(schema());
-      return query.on("query", () => {
-        process.stdout.write(sql`${query.toString()}`);
-        process.stdout.write(import_os6.EOL);
-      }).then(
+      return printStatements(migration2.run(schema()), connection).then(
         () => connection("migrations").insert({
           version: version2
         })
@@ -2626,7 +2865,6 @@ async function dbmigrate() {
 }
 
 // src/packages/cli/commands/dbrollback.ts
-var import_os7 = require("os");
 async function dbrollback() {
   const load = createLoader(CWD);
   const { database: config } = load("config");
@@ -2637,6 +2875,7 @@ async function dbrollback() {
     models,
     path: CWD,
     checkMigrations: false,
+    checkRelationships: false,
     logger: new logger_default({ enabled: false })
   });
   const migrationFiles = await readdir(`${CWD}/db/migrate`);
@@ -2651,11 +2890,7 @@ async function dbrollback() {
       migration2 = target.replace(new RegExp(`${version2}-(.+)\\.js`), "$1");
       migration2 = migrations.get(`${migration2}-down`);
       if (migration2) {
-        const query = migration2.run(schema());
-        await query.on("query", () => {
-          process.stdout.write(sql`${query.toString()}`);
-          process.stdout.write(import_os7.EOL);
-        });
+        await printStatements(migration2.run(schema()), connection);
         await connection("migrations").where({
           version: version2
         }).del();
@@ -2682,80 +2917,107 @@ function dbseed() {
 
 // src/packages/cli/commands/destroy.ts
 var import_os8 = require("os");
-var import_chalk11 = require("chalk");
-var import_inflection22 = require("inflection");
-async function destroyType(type, name) {
+var import_path14 = require("path");
+var import_inflection24 = require("inflection");
+function log2(text) {
+  process.stdout.write(text);
+  process.stdout.write(import_os8.EOL);
+}
+async function destroyType(type, name, cwd = CWD) {
   const normalizedType = type.toLowerCase();
   let normalizedName = name;
   let path6;
   let migrations;
   switch (normalizedType) {
     case "model":
-      normalizedName = (0, import_inflection22.singularize)(normalizedName);
-      path6 = `app/${(0, import_inflection22.pluralize)(normalizedType)}/${normalizedName}.js`;
+      normalizedName = (0, import_inflection24.singularize)(import_path14.posix.basename(normalizedName));
+      path6 = `app/${(0, import_inflection24.pluralize)(normalizedType)}/${normalizedName}.js`;
       break;
     case "migration":
-      migrations = await readdir(`${CWD}/db/migrate`);
+      migrations = await readdir(`${cwd}/db/migrate`);
       normalizedName = migrations.find(
-        (file) => `${normalizedName}.js` === file.substr(17)
+        (file) => `${import_path14.posix.basename(normalizedName)}.js` === file.substring(17)
       );
       path6 = `db/migrate/${normalizedName}`;
       break;
     case "controller":
     case "serializer":
-      normalizedName = (0, import_inflection22.pluralize)(normalizedName);
-      path6 = `app/${(0, import_inflection22.pluralize)(normalizedType)}/${normalizedName}.js`;
+      normalizedName = (0, import_inflection24.pluralize)(normalizedName);
+      path6 = `app/${(0, import_inflection24.pluralize)(normalizedType)}/${normalizedName}.js`;
       break;
     case "middleware":
       path6 = `app/${normalizedType}/${normalizedName}.js`;
       break;
     case "util":
-      path6 = `app/${(0, import_inflection22.pluralize)(normalizedType)}/${normalizedName}.js`;
+      path6 = `app/${(0, import_inflection24.pluralize)(normalizedType)}/${normalizedName}.js`;
       break;
     default:
       return;
   }
-  if (await exists(`${CWD}/${path6}`)) {
-    await rmrf_default(`${CWD}/${path6}`);
-    process.stdout.write(`${(0, import_chalk11.red)("remove")} ${path6}`);
-    process.stdout.write(import_os8.EOL);
+  if (await exists(`${cwd}/${path6}`)) {
+    await rmrf_default(`${cwd}/${path6}`);
+    log2(`${chalk_default.red("remove")} ${path6}`);
   }
 }
-async function destroy2({ type, name }) {
+async function otherControllersOf(name, cwd) {
+  const dir = `${cwd}/app/controllers`;
+  const own = `${(0, import_inflection24.pluralize)(name)}.js`;
+  const file = import_path14.posix.basename(own);
+  if (!await exists(dir)) {
+    return [];
+  }
+  return (await readdirRec(dir)).map((path6) => path6.split("\\").join("/")).filter((path6) => import_path14.posix.basename(path6) === file && path6 !== own).map((path6) => `app/controllers/${path6}`);
+}
+async function destroy2({
+  type,
+  name,
+  cwd = CWD
+}) {
   if (type === "resource") {
-    const routes = (await readFile(`${CWD}/app/routes.js`)).toString("utf8").split("\n").reduce((lines, line2) => {
+    const model2 = (0, import_inflection24.singularize)(import_path14.posix.basename(name));
+    const others = await otherControllersOf(name, cwd);
+    await destroyType("controller", name, cwd);
+    await destroyType("serializer", name, cwd);
+    if (others.length) {
+      log2(
+        `${chalk_default.yellow("keep")} app/models/${model2}.js and its migration (used by ${others.join(", ")})`
+      );
+    } else {
+      await destroyType("model", model2, cwd);
+      await destroyType("migration", `create-${(0, import_inflection24.pluralize)(model2)}`, cwd);
+    }
+    if (import_path14.posix.dirname(name) === ".") {
+      const path6 = `${cwd}/app/routes.js`;
+      const before = (await readFile(path6)).toString("utf8");
       const pattern = new RegExp(
-        `\\s*this.resource\\(('|"|\`)${(0, import_inflection22.pluralize)(name)}('|"|\`)\\);?`
+        `\\s*this.resource\\(('|"|\`)${(0, import_inflection24.pluralize)(name)}('|"|\`)\\);?`
       );
-      return pattern.test(line2) ? lines : [...lines, line2];
-    }, []).join("\n");
-    await Promise.all([
-      destroyType("model", name),
-      destroyType("migration", `create-${(0, import_inflection22.pluralize)(name)}`),
-      destroyType("serializer", name),
-      destroyType("controller", name)
-    ]);
-    await writeFile(`${CWD}/app/routes.js`, routes);
-    process.stdout.write(`${(0, import_chalk11.green)("update")} app/routes.js`);
-    process.stdout.write(import_os8.EOL);
+      const after = before.split("\n").filter((line2) => !pattern.test(line2)).join("\n");
+      if (after !== before) {
+        await writeFile(path6, after);
+        log2(`${chalk_default.green("update")} app/routes.js`);
+      }
+    }
   } else if (type === "model") {
     await Promise.all([
-      destroyType(type, name),
-      destroyType("migration", `create-${(0, import_inflection22.pluralize)(name)}`)
+      destroyType(type, name, cwd),
+      destroyType(
+        "migration",
+        `create-${(0, import_inflection24.pluralize)((0, import_inflection24.singularize)(import_path14.posix.basename(name)))}`,
+        cwd
+      )
     ]);
   } else {
-    await destroyType(type, name);
+    await destroyType(type, name, cwd);
   }
 }
 
 // src/packages/cli/commands/repl.ts
-var import_path14 = __toESM(require("path"));
+var import_path15 = __toESM(require("path"));
 var import_repl = require("repl");
 function repl() {
   return new Promise(async (resolve2) => {
-    const app = await Reflect.apply(require, null, [
-      import_path14.default.join(CWD, "dist", "boot")
-    ]);
+    const app = await require(import_path15.default.join(CWD, "dist", "boot"));
     const instance = (0, import_repl.start)({
       prompt: "> "
     });
@@ -2790,15 +3052,11 @@ function repl() {
   });
 }
 
-// src/packages/cli/commands/serve.ts
-var import_chalk13 = require("chalk");
-
 // src/packages/pm/cluster/index.ts
 var import_events2 = __toESM(require("events"));
 var import_os9 = __toESM(require("os"));
 var import_cluster2 = __toESM(require("cluster"));
-var import_path15 = require("path");
-var import_chalk12 = require("chalk");
+var import_path16 = require("path");
 
 // src/utils/range.ts
 function* range(start, end) {
@@ -2808,8 +3066,21 @@ function* range(start, end) {
 }
 
 // src/packages/pm/cluster/index.ts
+var BOOT_TIMEOUT = 3e4;
+var SHUTDOWN_TIMEOUT = 8e3;
+var WorkerBootError = class extends Error {
+  constructor(pid, reason) {
+    super(`Worker process ${pid} failed to start: ${reason}`);
+  }
+};
 var Cluster = class extends import_events2.default {
-  constructor({ path: path6, port, logger, maxWorkers }) {
+  constructor({
+    path: path6,
+    port,
+    logger,
+    maxWorkers,
+    shutdownTimeout = SHUTDOWN_TIMEOUT
+  }) {
     super();
     Object.defineProperties(this, {
       path: {
@@ -2841,128 +3112,219 @@ var Cluster = class extends import_events2.default {
         writable: false,
         enumerable: true,
         configurable: false
+      },
+      shutdownTimeout: {
+        value: shutdownTimeout,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      retiring: {
+        value: /* @__PURE__ */ new WeakSet(),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      },
+      stopping: {
+        value: false,
+        writable: true,
+        enumerable: false,
+        configurable: false
       }
     });
     import_cluster2.default.setupMaster({
-      exec: (0, import_path15.join)(path6, "dist", "boot.js")
+      exec: (0, import_path16.join)(path6, "dist", "boot.js")
     });
     process.on("update", (changed) => {
       changed.forEach(({ name: filename }) => {
-        logger.info(`${(0, import_chalk12.green)("update")} ${filename}`);
+        logger.info(`${chalk_default.green("update")} ${filename}`);
       });
       this.reload();
     });
-    this.forkAll().then(() => this.emit("ready"));
+    this.forkAll().then(
+      () => this.emit("ready"),
+      (err) => {
+        if (!this.stopping) {
+          this.emit("error", err);
+        }
+      }
+    );
   }
+  /**
+   * Fork a worker. Resolves with it once it is listening (or with `null`
+   * when the cluster is full or stopping); rejects with a `WorkerBootError`
+   * when it fails to start — it reports an error, exits, or does not listen
+   * within `BOOT_TIMEOUT` twice in a row.
+   */
   fork(retry = true) {
-    return new Promise((resolve2) => {
-      if (this.workers.size < this.maxWorkers) {
-        const worker = import_cluster2.default.fork({
-          NODE_ENV,
-          PORT: this.port
-        });
-        const timeout = setTimeout(() => {
-          this.logger.info(line`
-            Removing worker process: ${(0, import_chalk12.red)(`${worker.process.pid}`)}
-          `);
-          clearTimeout(timeout);
-          worker.removeAllListeners();
-          worker.kill();
-          this.workers.delete(worker);
-          resolve2(worker);
-          if (retry) {
-            this.fork(false);
-          }
-        }, 3e4);
-        const handleError = (err) => {
-          if (err) {
-            this.logger.error(err);
-          }
-          this.logger.info(line`
-            Removing worker process: ${(0, import_chalk12.red)(`${worker.process.pid}`)}
-          `);
+    if (this.stopping || this.workers.size >= this.maxWorkers) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve2, reject) => {
+      const worker = import_cluster2.default.fork({
+        NODE_ENV,
+        PORT: this.port
+      });
+      const { pid } = worker.process;
+      let booted = false;
+      const fail = (reason) => {
+        clearTimeout(timeout);
+        worker.removeAllListeners();
+        worker.kill();
+        this.logger.info(`Removing worker process: ${chalk_default.red(`${pid}`)}`);
+        reject(new WorkerBootError(pid, reason));
+      };
+      const timeout = setTimeout(() => {
+        if (retry) {
           clearTimeout(timeout);
           worker.removeAllListeners();
           worker.kill();
-          this.workers.delete(worker);
-          resolve2(worker);
-        };
-        worker.on("message", (msg) => {
-          let data = {};
-          let message = msg;
-          if (typeof message === "object") {
-            data = omit(message, "message");
-            message = message.message;
-          }
-          switch (message) {
-            case "ready":
-              this.logger.info(line`
-                Adding worker process: ${(0, import_chalk12.green)(`${worker.process.pid}`)}
-              `);
-              this.workers.add(worker);
-              clearTimeout(timeout);
-              worker.removeListener("error", handleError);
-              resolve2(worker);
-              break;
-            case "error":
-              handleError(data.error);
-              break;
-            default:
-              break;
-          }
-        });
-        worker.once("error", handleError);
-        worker.once("exit", (code) => {
-          const {
-            process: { pid }
-          } = worker;
-          if (typeof code === "number") {
+          this.logger.info(`Removing worker process: ${chalk_default.red(`${pid}`)}`);
+          this.fork(false).then(resolve2, reject);
+        } else {
+          fail(`not listening after ${BOOT_TIMEOUT / 1e3} s`);
+        }
+      }, BOOT_TIMEOUT);
+      worker.on("message", (msg) => {
+        let data = {};
+        let message = msg;
+        if (typeof message === "object") {
+          data = omit(message, "message");
+          message = message.message;
+        }
+        switch (message) {
+          case "ready":
+            booted = true;
+            clearTimeout(timeout);
             this.logger.info(line`
-              Worker process: ${(0, import_chalk12.red)(`${pid}`)} exited with code ${code}
+              Adding worker process: ${chalk_default.green(`${pid}`)}
             `);
-          }
-          this.logger.info(`Removing worker process: ${(0, import_chalk12.red)(`${pid}`)}`);
-          clearTimeout(timeout);
-          worker.removeAllListeners();
-          this.workers.delete(worker);
-          this.fork();
-        });
-      }
+            this.workers.add(worker);
+            resolve2(worker);
+            break;
+          case "error":
+            if (data.error) {
+              this.logger.error(data.error);
+            }
+            if (!booted) {
+              fail("it reported an error while booting");
+            }
+            break;
+          default:
+            break;
+        }
+      });
+      worker.once("error", (err) => {
+        this.logger.error(err);
+        if (!booted) {
+          fail(err.message);
+        }
+      });
+      worker.once("exit", (code, signal) => {
+        clearTimeout(timeout);
+        worker.removeAllListeners();
+        this.workers.delete(worker);
+        if (!booted) {
+          reject(
+            new WorkerBootError(
+              pid,
+              `it exited with ${code === null ? signal : `code ${code}`}`
+            )
+          );
+          return;
+        }
+        if (this.retiring.has(worker)) {
+          return;
+        }
+        this.logger.info(line`
+          Worker process: ${chalk_default.red(`${pid}`)} exited with
+          ${code === null ? `signal ${signal}` : `code ${code}`}
+        `);
+        this.logger.info(`Removing worker process: ${chalk_default.red(`${pid}`)}`);
+        this.fork().catch((err) => this.replacementFailed(err));
+      });
     });
   }
+  /**
+   * A replacement for a crashed worker did not start. With none left, the
+   * application is down: stop, so the platform can restart it.
+   */
+  replacementFailed(err) {
+    this.logger.error(err);
+    if (!this.stopping && !this.workers.size) {
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Shut `worker` down gracefully: it stops accepting connections, finishes
+   * the requests in flight, closes its database connections and exits. It is
+   * killed if it has not exited after `shutdownTimeout`.
+   */
   shutdown(worker) {
     return new Promise((resolve2) => {
       this.workers.delete(worker);
-      const timeout = setTimeout(() => worker.kill(), 5e3);
-      worker.once("disconnect", () => {
-        worker.kill();
-      });
-      worker.once("exit", () => {
+      this.retiring.add(worker);
+      if (worker.isDead()) {
         resolve2(worker);
+        return;
+      }
+      const timeout = setTimeout(() => {
+        this.logger.warn(line`
+          Worker process: ${chalk_default.red(`${worker.process.pid}`)} did not exit
+          within ${this.shutdownTimeout} ms; killing it.
+        `);
+        worker.kill("SIGKILL");
+      }, this.shutdownTimeout);
+      worker.once("exit", () => {
         clearTimeout(timeout);
+        resolve2(worker);
       });
-      worker.send("shutdown");
-      worker.disconnect();
+      if (worker.isConnected()) {
+        worker.send("shutdown");
+      } else {
+        worker.kill();
+      }
     });
   }
-  reload() {
-    if (this.workers.size) {
-      const groups = Array.from(this.workers).reduce((arr, item, idx, src) => {
-        if ((idx + 1) % 2) {
-          const group = src.slice(idx, idx + 2);
-          return [
-            ...arr,
-            () => Promise.all(group.map((worker) => this.shutdown(worker)))
-          ];
-        }
-        return arr;
-      }, []);
-      return composeAsync(...groups)();
+  /**
+   * Shut every worker down gracefully, booting ones included, and fork no
+   * more. Resolves once all have exited.
+   */
+  async stop() {
+    this.stopping = true;
+    const workers = Object.values(import_cluster2.default.workers ?? {}).filter(
+      (worker) => Boolean(worker)
+    );
+    await Promise.all(workers.map((worker) => this.shutdown(worker)));
+  }
+  /**
+   * Replace every worker with one running the rebuilt application, two at a
+   * time. A replacement that fails to start is logged, and the cluster keeps
+   * watching: saving a fix reloads again.
+   */
+  async reload() {
+    if (this.stopping) {
+      return;
+    }
+    const workers = Array.from(this.workers);
+    const failed = (err) => {
+      this.logger.error(`${err.message}. Save a fix to reload.`);
+    };
+    if (!workers.length) {
+      await this.forkAll().catch(failed);
+      return;
+    }
+    for (let i = 0; i < workers.length; i += 2) {
+      await Promise.all(
+        workers.slice(i, i + 2).map(async (worker) => {
+          await this.shutdown(worker);
+          await this.fork().catch(failed);
+        })
+      );
     }
-    return this.fork();
   }
   forkAll() {
-    return Promise.race(
+    return Promise.all(
       Array.from(range(1, this.maxWorkers)).map(() => this.fork())
     );
   }
@@ -2974,13 +3336,15 @@ function createCluster({
   path: path6,
   port,
   logger,
-  maxWorkers
+  maxWorkers,
+  shutdownTimeout
 }) {
   return new cluster_default({
     path: path6,
     port,
     logger,
-    maxWorkers
+    maxWorkers,
+    shutdownTimeout
   });
 }
 
@@ -2991,7 +3355,7 @@ async function serve({
   useStrict = false
 }) {
   const load = createLoader(CWD);
-  const { logging } = load("config");
+  const { logging, server } = load("config");
   const logger = new logger_default(logging);
   if (hot) {
     const watcher = await watch(CWD);
@@ -3000,22 +3364,36 @@ async function serve({
       process.emit("update", changed);
     });
   }
-  createCluster({
+  const pm = createCluster({
     logger,
     path: CWD,
     port: PORT,
-    maxWorkers: cluster3 ? void 0 : 1
-  }).once("ready", () => {
-    logger.info(`Lumen Server listening on port: ${(0, import_chalk13.cyan)(`${PORT}`)}`);
+    maxWorkers: cluster3 ? void 0 : 1,
+    shutdownTimeout: server?.shutdownTimeout
+  });
+  let stopping = false;
+  const stop = async (code) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    await pm.stop();
+    logger.info("Lumen Server stopped");
+    process.exit(code);
+  };
+  pm.once("ready", () => {
+    logger.info(`Lumen Server listening on port: ${chalk_default.cyan(`${PORT}`)}`);
+  });
+  pm.on("error", (err) => {
+    logger.error(err.message);
+    stop(1);
+  });
+  ["SIGTERM", "SIGINT"].forEach((signal) => {
+    process.once(signal, () => {
+      logger.info(`Received ${signal}; finishing requests in flight`);
+      stop(0);
+    });
   });
-}
-
-// src/packages/cli/commands/test.ts
-var import_os10 = require("os");
-function test() {
-  process.stdout.write("Coming Soon!");
-  process.stdout.write(import_os10.EOL);
-  return Promise.resolve();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -3029,7 +3407,6 @@ function test() {
   destroy,
   generate,
   repl,
-  serve,
-  test
+  serve
 });
 //# sourceMappingURL=cli.cjs.map