@nexusts/cli 0.7.0 → 0.7.2

package/dist/index.js

@@ -1,26 +1,483 @@
 #!/usr/bin/env bun
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __require = import.meta.require;
 
 // packages/cli/src/commands/info.ts
+import { resolve as resolve3 } from "path";
+
+// packages/cli/src/core/args.ts
+var LONG_RE = /^--([^=]+)(?:=(.*))?$/;
+var SHORT_RE = /^-([A-Za-z])$/;
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  let endOfOptions = false;
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--") {
+      endOfOptions = true;
+      i++;
+      continue;
+    }
+    if (endOfOptions || !arg.startsWith("-")) {
+      positional.push(arg);
+      i++;
+      continue;
+    }
+    const longMatch = LONG_RE.exec(arg);
+    if (longMatch) {
+      const [, name, inline] = longMatch;
+      const flagName = name;
+      if (inline !== undefined) {
+        setFlag(flags, flagName, inline);
+        i++;
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        setFlag(flags, flagName, next);
+        i += 2;
+      } else {
+        setFlag(flags, flagName, true);
+        i++;
+      }
+      continue;
+    }
+    const shortMatch = SHORT_RE.exec(arg);
+    if (shortMatch) {
+      const flagName = shortMatch[1];
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        setFlag(flags, flagName, next);
+        i += 2;
+      } else {
+        setFlag(flags, flagName, true);
+        i++;
+      }
+      continue;
+    }
+    positional.push(arg);
+    i++;
+  }
+  const command = positional.shift();
+  return { command, positional, flags };
+}
+function setFlag(flags, name, value) {
+  if (name.startsWith("no-") && value === true) {
+    const key = name.slice(3);
+    flags[key] = false;
+    return;
+  }
+  const existing = flags[name];
+  if (existing === undefined) {
+    flags[name] = value;
+  } else if (Array.isArray(existing)) {
+    existing.push(typeof value === "string" ? value : String(value));
+  } else {
+    flags[name] = [
+      String(existing),
+      typeof value === "string" ? value : String(value)
+    ];
+  }
+}
+function flagBool(flags, name, fallback = false) {
+  const v = flags[name];
+  if (v === undefined)
+    return fallback;
+  if (typeof v === "boolean")
+    return v;
+  return v !== "false" && v !== "0" && v !== "no";
+}
+function flagList(flags, name) {
+  const v = flags[name];
+  if (v === undefined)
+    return [];
+  if (Array.isArray(v))
+    return v;
+  if (typeof v === "string")
+    return [v];
+  return [String(v)];
+}
+// packages/cli/src/core/config.ts
+import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
-import { colors, logger } from "@nexusts/core/index.js";
+var DEFAULT_CONFIG = {
+  routing: "nest",
+  view: "inertia",
+  orm: "drizzle",
+  database: {
+    driver: "bun-sqlite",
+    url: "app.db"
+  },
+  inertia: {
+    frontend: "react",
+    ssr: true,
+    version: "1.0.0"
+  },
+  paths: {
+    app: "app",
+    controllers: "app/controllers",
+    services: "app/services",
+    modules: "app/modules",
+    models: "app/models",
+    migrations: "app/database/migrations",
+    seeds: "db/seeds",
+    middleware: "app/middleware",
+    dto: "app/dto"
+  },
+  moduleStyle: "nest",
+  auth: undefined,
+  queue: undefined
+};
+var CONFIG_CANDIDATES = [
+  "nx.config.ts",
+  "nx.config.js",
+  "nx.config.mjs",
+  ".nxrc.json"
+];
+async function loadConfig(cwd = process.cwd()) {
+  let config = {};
+  let configSource = "<defaults>";
+  for (const candidate of CONFIG_CANDIDATES) {
+    const path = resolve(cwd, candidate);
+    if (!existsSync(path))
+      continue;
+    try {
+      if (candidate.endsWith(".json")) {
+        const raw = readFileSync(path, "utf8");
+        config = JSON.parse(raw);
+      } else {
+        try {
+          const mod = await import(path);
+          config = mod.default ?? mod;
+        } catch (importErr) {
+          console.warn(`[nx] Could not dynamically import ${candidate}: ${importErr.message ?? importErr}. Falling back to defaults.`);
+          config = {};
+        }
+      }
+      configSource = candidate;
+      break;
+    } catch (err) {
+      throw new Error(`Failed to load ${candidate}: ${err.message ?? String(err)}`);
+    }
+  }
+  const merged = mergeWithEnv(DEFAULT_CONFIG, config);
+  assertEnum("routing", merged.routing, [
+    "nest",
+    "adonis",
+    "functional",
+    "mixed"
+  ]);
+  assertEnum("view", merged.view, ["rendu", "edge", "inertia", "none"]);
+  assertEnum("orm", merged.orm, ["drizzle", "prisma", "kysely", "none"]);
+  assertEnum("database.driver", merged.database.driver, [
+    "bun-sqlite",
+    "node-sqlite",
+    "libsql",
+    "postgres",
+    "mysql",
+    "none"
+  ]);
+  assertEnum("inertia.frontend", merged.inertia.frontend, [
+    "react",
+    "vue",
+    "svelte",
+    "solid"
+  ]);
+  if (process.env["NX_DEBUG"] === "1") {
+    console.log(`[nx] config source: ${configSource}`);
+  }
+  return merged;
+}
+function mergeWithEnv(base, override) {
+  const env = process.env;
+  const merged = {
+    ...base,
+    ...override,
+    database: { ...base.database, ...override.database ?? {} },
+    inertia: { ...base.inertia, ...override.inertia ?? {} },
+    paths: { ...base.paths, ...override.paths ?? {} }
+  };
+  if (env["NX_ROUTING"])
+    merged.routing = env["NX_ROUTING"];
+  if (env["NX_VIEW"])
+    merged.view = env["NX_VIEW"];
+  if (env["NX_ORM"])
+    merged.orm = env["NX_ORM"];
+  if (env["NX_DATABASE_DRIVER"])
+    merged.database.driver = env["NX_DATABASE_DRIVER"];
+  if (env["NX_DATABASE_URL"])
+    merged.database.url = env["NX_DATABASE_URL"];
+  if (env["NX_INERTIA_FRONTEND"])
+    merged.inertia.frontend = env["NX_INERTIA_FRONTEND"];
+  if (env["NX_INERTIA_SSR"])
+    merged.inertia.ssr = env["NX_INERTIA_SSR"] !== "false" && env["NX_INERTIA_SSR"] !== "0";
+  if (env["NX_INERTIA_VERSION"])
+    merged.inertia.version = env["NX_INERTIA_VERSION"];
+  return merged;
+}
+function assertEnum(key, value, allowed) {
+  if (!allowed.includes(value)) {
+    throw new Error(`Invalid value for ${key}: "${value}". Allowed: ${allowed.join(", ")}.`);
+  }
+}
+// packages/cli/src/core/fs.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, isAbsolute, relative, resolve as resolve2 } from "path";
+function writeFile(path, contents, opts = {}) {
+  const base = opts.base ?? process.cwd();
+  const target = isAbsolute(path) ? path : resolve2(base, path);
+  if (opts.skipIfExists && existsSync2(target)) {
+    return false;
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, contents);
+  return true;
+}
+function nameVariants(input) {
+  const trimmed = input.replace(/\.(ts|js|tsx|jsx)$/, "");
+  const pascal = trimmed.split(/[\s_-]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).filter(Boolean).join("") || input;
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  const snake = pascal.split(/(?=[A-Z])/).map((w) => w.toLowerCase()).filter(Boolean).join("_");
+  const kebab = snake.replace(/_/g, "-");
+  return {
+    pascal,
+    camel,
+    snake,
+    kebab,
+    plural: pluralize(pascal),
+    pluralSnake: pluralize(snake),
+    pluralKebab: pluralize(kebab)
+  };
+}
+function pluralize(s) {
+  if (!s)
+    return s;
+  if (/(s|x|z|ch|sh)$/i.test(s))
+    return `${s}es`;
+  if (/[^aeiou]y$/i.test(s))
+    return `${s.slice(0, -1)}ies`;
+  if (/y$/i.test(s))
+    return `${s}s`;
+  return `${s}s`;
+}
+// packages/cli/src/core/logger.ts
+var USE_COLOR = process.env["NO_COLOR"] === undefined && process.env["FORCE_COLOR"] !== "0" && process.stdout.isTTY === true;
+var wrap = (open, close) => (s) => USE_COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var c = {
+  reset: wrap(0, 0),
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan: wrap(36, 39),
+  gray: wrap(90, 39)
+};
+var PREFIXES = {
+  info: `${c.cyan("\u2139")}`,
+  success: `${c.green("\u2714")}`,
+  warn: `${c.yellow("\u26A0")}`,
+  error: `${c.red("\u2716")}`,
+  debug: `${c.gray("\xB7")}`,
+  finger: `${c.magenta("\u279C")}`
+};
+
+class Logger {
+  verbose = false;
+  setVerbose(v) {
+    this.verbose = v;
+  }
+  info(message) {
+    console.log(`${PREFIXES.info}  ${message}`);
+  }
+  success(message) {
+    console.log(`${PREFIXES.success}  ${message}`);
+  }
+  warn(message) {
+    console.warn(`${PREFIXES.warn}  ${c.yellow(message)}`);
+  }
+  error(message) {
+    console.error(`${PREFIXES.error}  ${c.red(message)}`);
+  }
+  debug(message) {
+    if (!this.verbose)
+      return;
+    console.log(`${PREFIXES.debug}  ${c.gray(message)}`);
+  }
+  finger(message) {
+    console.log(`${PREFIXES.finger}  ${c.magenta(message)}`);
+  }
+  table(rows) {
+    const labelWidth = Math.max(...rows.map(([l]) => l.length));
+    for (const [label, value] of rows) {
+      const padded = label.padEnd(labelWidth);
+      console.log(`  ${c.dim(padded)}  ${value}`);
+    }
+  }
+  heading(text) {
+    const bar = "\u2500".repeat(text.length + 4);
+    console.log(`
+${c.bold(c.cyan(bar))}`);
+    console.log(`${c.bold(c.cyan(`  ${text}  `))}`);
+    console.log(`${c.bold(c.cyan(bar))}
+`);
+  }
+  blank() {
+    console.log("");
+  }
+}
+var logger = new Logger;
+var colors = c;
+// packages/cli/src/core/loose-json.ts
+function parseJsonLoose(text) {
+  return Bun.JSON5.parse(text);
+}
+// packages/cli/src/core/prompts.ts
+import { createInterface } from "readline";
+async function prompt(message, options = {}) {
+  const interactive = options.interactive ?? true;
+  const fallback = options.default ?? options.choices?.[0];
+  if (!interactive || !process.stdin.isTTY) {
+    if (fallback === undefined) {
+      throw new Error(`No default provided for non-interactive prompt: ${message}`);
+    }
+    return fallback;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve3) => {
+    const suffix = options.choices ? ` [${options.choices.join("/")}]` : "";
+    const def = options.default ?? options.choices?.[0] ?? "";
+    const promptStr = `  ${message}${suffix} (${def}): `;
+    rl.question(promptStr, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve3(trimmed === "" ? def : trimmed);
+    });
+  });
+}
+async function select(message, choices, options = {}) {
+  return prompt(message, { ...options, choices });
+}
+// packages/cli/src/core/template.ts
+var VAR_RE = /\{\{\s*([\w.]+)(?:\s*\|\s*(\w+))?\s*\}\}/;
+var SECTION_RE = /\{\{\s*([#^])\s*([\w.]+)\s*\}\}([\s\S]*?)\{\{\s*\/\s*\2\s*\}\}/g;
+function render(template, context) {
+  let out = template.replace(SECTION_RE, (_, kind, key, body) => {
+    const v = lookup(context, key);
+    const truthy = isTruthy(v);
+    if (kind === "#")
+      return truthy ? body : "";
+    return truthy ? "" : body;
+  });
+  let prev;
+  do {
+    prev = out;
+    out = out.replace(VAR_RE, (_, key, filter) => {
+      const v = lookup(context, key);
+      return applyFilter(v === undefined || v === null ? "" : String(v), filter);
+    });
+  } while (out !== prev);
+  return out;
+}
+function lookup(ctx, dotted) {
+  if (dotted in ctx)
+    return ctx[dotted];
+  const parts = dotted.split(".");
+  let cur = ctx;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object")
+      return;
+    cur = cur[p];
+  }
+  return cur === undefined || cur === null ? undefined : cur;
+}
+function isTruthy(v) {
+  if (v === undefined || v === null)
+    return false;
+  if (typeof v === "string")
+    return v.length > 0 && v !== "false" && v !== "0";
+  if (typeof v === "number")
+    return v !== 0;
+  if (typeof v === "boolean")
+    return v;
+  if (Array.isArray(v))
+    return v.length > 0;
+  return Object.keys(v).length > 0;
+}
+function applyFilter(value, filter) {
+  switch (filter) {
+    case undefined:
+    case "raw":
+      return value;
+    case "upper":
+      return value.toUpperCase();
+    case "lower":
+      return value.toLowerCase();
+    case "pascal":
+      return toPascal(value);
+    case "camel":
+      return toCamel(value);
+    case "snake":
+      return toSnake(value);
+    case "kebab":
+      return toKebab(value);
+    case "plural":
+      return pluralize2(value);
+    case "singular":
+      return singularize(value);
+    default:
+      throw new Error(`Unknown template filter: ${filter}`);
+  }
+}
+function splitWords(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean);
+}
+function toPascal(s) {
+  return splitWords(s).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function toCamel(s) {
+  const p = toPascal(s);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+function toSnake(s) {
+  return splitWords(s).map((w) => w.toLowerCase()).join("_");
+}
+function toKebab(s) {
+  return splitWords(s).map((w) => w.toLowerCase()).join("-");
+}
+function pluralize2(s) {
+  if (!s)
+    return s;
+  if (/(s|x|z|ch|sh)$/i.test(s))
+    return `${s}es`;
+  if (/[^aeiou]y$/i.test(s))
+    return `${s.slice(0, -1)}ies`;
+  if (/y$/i.test(s))
+    return `${s}s`;
+  return `${s}s`;
+}
+function singularize(s) {
+  if (!s)
+    return s;
+  if (/(ses|xes|zes|ches|shes)$/i.test(s))
+    return s.slice(0, -2);
+  if (/ies$/i.test(s))
+    return `${s.slice(0, -3)}y`;
+  if (/s$/i.test(s) && s.length > 1)
+    return s.slice(0, -1);
+  return s;
+}
+// packages/cli/src/commands/info.ts
 var infoCommand = {
   name: "info",
   aliases: ["i"],
@@ -71,7 +528,7 @@ var infoCommand = {
     logger.blank();
     logger.info(colors.bold("Working directory"));
     logger.blank();
-    logger.info(`  ${resolve(ctx.cwd)}`);
+    logger.info(`  ${resolve3(ctx.cwd)}`);
     logger.blank();
     return 0;
   }
@@ -79,10 +536,8 @@ var infoCommand = {
 var info_default = infoCommand;
 
 // packages/cli/src/commands/init.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-import { flagBool, logger as logger2, render, select } from "@nexusts/core/index.js";
-import { parseJsonLoose } from "@nexusts/core/loose-json.js";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
 
 // packages/cli/src/templates/controller/adonis.ts
 var adonis_default = `
@@ -187,7 +642,7 @@ import { Body, Controller, Delete, Get, Inject, Param, Post, Put } from '@nexust
 import { z } from 'zod';
 import { Validate } from '@nexusts/core';
 import { {{ service }} } from '../services/{{ kebab }}.service.js';
-{{#hasInertia}}import { Inertia } from '@nexusts/view/inertia';{{/hasInertia}}
+{{#hasInertia}}import { Inertia } from '@nexusts/view';{{/hasInertia}}
 
 const Create{{ name }}Schema = z.object({
   // TODO: define fields
@@ -570,15 +1025,17 @@ export default defineConfig({
 
 // packages/cli/src/templates/repository/repository.ts
 var repository_default = `
-import { Injectable } from '@nexusts/core';
-import { DrizzleRepository } from '@nexusts/drizzle';
-import { {{ tableName }} } from '../models/{{ kebab }}.model.js';
+import { Injectable, Inject } from '@nexusts/core';
+import { DrizzleRepository, DrizzleService } from '@nexusts/drizzle';
+import { {{ snake }} } from '../models/{{ kebab }}.model.js';
 import type { {{ name }}, New{{ name }} } from '../models/{{ kebab }}.model.js';
 
 @Injectable()
-export class {{ repository }} extends DrizzleRepository<typeof {{ tableName }}, {{ name }}> {
-  constructor() {
-    super({{ tableName }});
+export class {{ repository }} extends DrizzleRepository<typeof {{ snake }}, {{ name }}> {
+  constructor(
+    @Inject(DrizzleService.TOKEN) db: DrizzleService,
+  ) {
+    super(db, {{ snake }});
   }
 }
 `.trimStart();
@@ -586,7 +1043,9 @@ export class {{ repository }} extends DrizzleRepository<typeof {{ tableName }},
 // packages/cli/src/templates/service/service.ts
 var service_default = `
 import { Inject, Injectable } from '@nexusts/core';
-{{#hasRepo}}import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';{{/hasRepo}}
+{{#hasRepo}}import { eq } from '@nexusts/drizzle';
+import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';
+import { {{ snake }} } from '../models/{{ kebab }}.model.js';{{/hasRepo}}
 
 @Injectable()
 export class {{ name }}Service {
@@ -600,7 +1059,7 @@ export class {{ name }}Service {
   }
 
   async findOne(id: number) {
-    {{#hasRepo}}return this.{{ repositoryCamel }}.findOne(id);{{/hasRepo}}
+    {{#hasRepo}}return this.{{ repositoryCamel }}.findOne(eq({{ snake }}.id, id));{{/hasRepo}}
     {{^hasRepo}}return { id }; // TODO: implement{{/hasRepo}}
   }
 
@@ -610,12 +1069,12 @@ export class {{ name }}Service {
   }
 
   async update(id: number, data: any) {
-    {{#hasRepo}}return this.{{ repositoryCamel }}.update(id, data);{{/hasRepo}}
+    {{#hasRepo}}return this.{{ repositoryCamel }}.update(eq({{ snake }}.id, id), data);{{/hasRepo}}
     {{^hasRepo}}return { id, ...data }; // TODO: implement{{/hasRepo}}
   }
 
   async delete(id: number) {
-    {{#hasRepo}}return this.{{ repositoryCamel }}.delete(id);{{/hasRepo}}
+    {{#hasRepo}}return this.{{ repositoryCamel }}.delete(eq({{ snake }}.id, id));{{/hasRepo}}
     {{^hasRepo}}return { removed: id }; // TODO: implement{{/hasRepo}}
   }
 }
@@ -706,10 +1165,10 @@ var initCommand = {
   async run(ctx) {
     const interactive = !flagBool(ctx.flags, "no-interaction", false);
     const force = flagBool(ctx.flags, "force", false);
-    const target = resolve2(ctx.cwd, ctx.flags["target"] ?? ".");
-    if (!existsSync(target)) {
-      logger2.error(`Target directory does not exist: ${target}`);
-      logger2.info(`Run \`nx new <name>\` to create a fresh project, or \`mkdir -p ${target}\` first.`);
+    const target = resolve4(ctx.cwd, ctx.flags["target"] ?? ".");
+    if (!existsSync3(target)) {
+      logger.error(`Target directory does not exist: ${target}`);
+      logger.info(`Run \`nx new <name>\` to create a fresh project, or \`mkdir -p ${target}\` first.`);
       return 1;
     }
     const routing = ctx.flags["style"] ?? await select("Routing style", ["nest", "adonis", "functional"], {
@@ -738,7 +1197,7 @@ var initCommand = {
       { path: "package.json", mode: "merge-pkg" },
       { path: "tsconfig.json", mode: "merge-tsconfig" },
       { path: "public/.gitkeep", mode: "write" },
-      { path: "resources/views/welcome.html", mode: "write" },
+      ...view !== "none" ? [{ path: "resources/views/welcome.html", mode: "write" }] : [],
       { path: ".env", mode: "skip" },
       { path: ".env.local", mode: "skip" },
       { path: ".gitignore", mode: "skip" },
@@ -750,23 +1209,33 @@ var initCommand = {
     const created = [];
     const skipped = [];
     const merged = [];
-    mkdirSync(resolve2(target, "app/controllers"), { recursive: true });
-    mkdirSync(resolve2(target, "public"), { recursive: true });
-    mkdirSync(resolve2(target, "resources/views"), { recursive: true });
+    mkdirSync2(resolve4(target, "app/controllers"), { recursive: true });
+    mkdirSync2(resolve4(target, "public"), { recursive: true });
+    if (view !== "none") {
+      mkdirSync2(resolve4(target, "resources/views"), { recursive: true });
+    }
     for (const entry of plan) {
-      const abs = resolve2(target, entry.path);
-      const exists = existsSync(abs);
+      const abs = resolve4(target, entry.path);
+      const exists = existsSync3(abs);
       if (entry.mode === "merge-pkg") {
+        const coreDeps = {
+          "@nexusts/core": "*",
+          "reflect-metadata": "^0.2.2",
+          hono: "^4.6.0",
+          zod: "^3.23.8"
+        };
+        if (orm === "drizzle") {
+          coreDeps["@nexusts/drizzle"] = "*";
+          coreDeps["drizzle-orm"] = "^0.45.0";
+        }
+        if (view !== "none") {
+          coreDeps["@nexusts/static"] = "*";
+        }
         if (exists) {
-          mergePackageJson(abs, {
-            "@nexusts/core": "*",
-            "reflect-metadata": "^0.2.2",
-            hono: "^4.6.0",
-            zod: "^3.23.8"
-          });
+          mergePackageJson(abs, coreDeps);
           merged.push(entry.path);
         } else {
-          writeFileSync(abs, JSON.stringify({
+          writeFileSync2(abs, JSON.stringify({
             name: target.split("/").pop() ?? "nexus-app",
             version: "0.1.0",
             type: "module",
@@ -778,12 +1247,7 @@ var initCommand = {
               test: "vitest",
               nx: "nx"
             },
-            dependencies: {
-              "@nexusts/core": "*",
-              "reflect-metadata": "^0.2.2",
-              hono: "^4.6.0",
-              zod: "^3.23.8"
-            }
+            dependencies: coreDeps
           }, null, 2));
           created.push(entry.path);
         }
@@ -797,7 +1261,7 @@ var initCommand = {
           });
           merged.push(entry.path);
         } else {
-          writeFileSync(abs, defaultTsconfig());
+          writeFileSync2(abs, defaultTsconfig());
           created.push(entry.path);
         }
         continue;
@@ -818,32 +1282,32 @@ var initCommand = {
         inertiaVersion: "1.0.0",
         targetName: target.split("/").pop() ?? "nexus-app"
       });
-      writeFileSync(abs, content);
+      writeFileSync2(abs, content);
       created.push(entry.path);
     }
-    logger2.success(`initialized NexusTS in ${target}`);
-    logger2.blank();
+    logger.success(`initialized NexusTS in ${target}`);
+    logger.blank();
     if (created.length) {
-      logger2.heading("Created");
+      logger.heading("Created");
       for (const f of created)
-        logger2.info(`  + ${f}`);
+        logger.info(`  + ${f}`);
     }
     if (merged.length) {
-      logger2.heading("Merged into existing files");
+      logger.heading("Merged into existing files");
       for (const f of merged)
-        logger2.info(`  ~ ${f}`);
+        logger.info(`  ~ ${f}`);
     }
     if (skipped.length) {
-      logger2.heading("Skipped (already exist; use --force to overwrite)");
+      logger.heading("Skipped (already exist; use --force to overwrite)");
       for (const f of skipped)
-        logger2.info(`  - ${f}`);
+        logger.info(`  - ${f}`);
     }
-    logger2.blank();
-    logger2.heading("Next steps");
-    logger2.info(`  cd ${target === ctx.cwd ? "." : target}`);
-    logger2.info(`  bun install`);
-    logger2.info(`  bun run dev`);
-    logger2.blank();
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info(`  cd ${target === ctx.cwd ? "." : target}`);
+    logger.info(`  bun install`);
+    logger.info(`  bun run dev`);
+    logger.blank();
     return 0;
   }
 };
@@ -910,44 +1374,66 @@ DATABASE_URL=app.db
 # DATABASE_URL=postgres://user:password@localhost:5432/myapp
 # SESSION_SECRET=my-local-secret
 `;
-    case "app/main.ts":
+    case "app/main.ts": {
+      const hasView = ctx.view !== "none";
+      const staticMw = hasView ? `import { StaticModule } from '@nexusts/static';
+` + `const staticMiddleware = StaticModule.mount({ root: './public', prefix: '/static' });
+` : "";
+      const staticOpt = hasView ? `
+  middleware: [staticMiddleware],` : "";
       return `import 'reflect-metadata';
 import { Application } from '@nexusts/core';
-import { StaticModule } from '@nexusts/static';
-import { AppModule } from './app.module.js';
+${staticMw}import { AppModule } from './app.module.js';
 
-const app = new Application(AppModule);
-// Serve ./public files under /static/*
-app.server.app.use('/static/*', StaticModule.mount({ root: './public', prefix: '/static' }));
+const app = new Application(AppModule, {
+  logging: true,
+  port: Number(process.env['PORT'] ?? 3000),${staticOpt}
+});
 
-const port = Number(process.env["PORT"] ?? 3000);
-await app.listen(port);
-console.log("[nexusjs] Listening on http://localhost:" + port);
+await app.listen();
+console.log('[nexus] Listening on http://localhost:' + (process.env['PORT'] ?? 3000));
 `;
-    case "app/app.module.ts":
-      return `import { Module } from '@nexusts/core';
+    }
+    case "app/app.module.ts": {
+      const hasOrm = ctx.orm === "drizzle";
+      const ormImport = hasOrm ? `import { DrizzleModule } from '@nexusts/drizzle';
+` : "";
+      const forRootDialect = ctx.dbDriver === "bun-sqlite" ? "bun-sqlite" : "sqlite";
+      const forRootFile = ctx.dbUrl || "app.db";
+      const ormBlock = hasOrm ? `    DrizzleModule.forRoot({
+      dialect: '` + forRootDialect + `',
+      connection: { filename: '` + forRootFile + `' },
+      logging: true,
+    })` : "";
+      return `${ormImport}import { Module } from '@nexusts/core';
 import { HomeController } from './controllers/home.controller.js';
 
 @Module({
-  imports: [],
+  imports: [${hasOrm ? `
+${ormBlock},
+` : ""}  ],
   controllers: [HomeController],
 })
 export class AppModule {}
 `;
-    case "app/controllers/home.controller.ts":
+    }
+    case "app/controllers/home.controller.ts": {
+      const hasView = ctx.view !== "none";
+      const body = hasView ? `{
+      view: 'welcome.html',
+      data: { year: new Date().getFullYear() },
+    }` : `{ status: 200, body: { message: 'Hello from NexusTS!' } }`;
       return `import { Controller, Get } from '@nexusts/core';
 
 @Controller('/')
 export class HomeController {
   @Get('/')
   index() {
-    return {
-      view: 'welcome.html',
-      data: { year: new Date().getFullYear() },
-    };
+    return ${body};
   }
 }
 `;
+    }
     case "README.md":
       return `# ${ctx.targetName}
 
@@ -988,7 +1474,7 @@ function defaultTsconfig() {
 `;
 }
 function mergePackageJson(path, additions) {
-  const raw = readFileSync(path, "utf8");
+  const raw = readFileSync3(path, "utf8");
   const pkg = parseJsonLoose(raw);
   let changed = false;
   if (!pkg["type"]) {
@@ -1025,12 +1511,12 @@ function mergePackageJson(path, additions) {
   }
   pkg["dependencies"] = deps;
   if (changed) {
-    writeFileSync(path, JSON.stringify(pkg, null, 2) + `
+    writeFileSync2(path, JSON.stringify(pkg, null, 2) + `
 `);
   }
 }
 function mergeTsconfig(path, additions) {
-  const raw = readFileSync(path, "utf8");
+  const raw = readFileSync3(path, "utf8");
   const cfg = parseJsonLoose(raw);
   const co = cfg.compilerOptions ?? {};
   let changed = false;
@@ -1052,20 +1538,14 @@ function mergeTsconfig(path, additions) {
   if (changed) {
     cfg.compilerOptions = co;
     cfg.include = inc;
-    writeFileSync(path, JSON.stringify(cfg, null, 2) + `
+    writeFileSync2(path, JSON.stringify(cfg, null, 2) + `
 `);
   }
 }
 var init_default = initCommand;
 
 // packages/cli/src/commands/make-auth.ts
-import { resolve as resolve3 } from "path";
-import {
-  flagList,
-  logger as logger3,
-  render as render2,
-  writeFile
-} from "@nexusts/core/index.js";
+import { resolve as resolve5 } from "path";
 var AUTH_INSTANCE_TEMPLATE = `/**
  * Better-auth instance \u2014 generated by \`nx make:auth\`.
  *
@@ -1157,7 +1637,7 @@ var makeAuthCommand = {
     }
   ],
   async run(ctx) {
-    logger3.heading("Scaffolding auth module");
+    logger.heading("Scaffolding auth module");
     const providers = flagList(ctx.flags, "provider");
     const jwtEnabled = ctx.flags["jwt"] === true;
     const passkeyEnabled = ctx.flags["passkey"] === true;
@@ -1171,7 +1651,7 @@ var makeAuthCommand = {
         envVar: known?.env ?? p.toUpperCase()
       };
     });
-    const authCode = render2(AUTH_INSTANCE_TEMPLATE, {
+    const authCode = render(AUTH_INSTANCE_TEMPLATE, {
       jwt: jwtEnabled,
       passkey: passkeyEnabled,
       providers: providers.length > 0,
@@ -1180,44 +1660,43 @@ var makeAuthCommand = {
       passkeyRpId: rpId,
       passkeyOrigin: Array.isArray(origin) ? origin.join(",") : origin
     });
-    const authOut = resolve3(ctx.cwd, "app/auth/auth.ts");
+    const authOut = resolve5(ctx.cwd, "app/auth/auth.ts");
     if (writeFile(authOut, authCode)) {
-      logger3.success(`created ${authOut}`);
+      logger.success(`created ${authOut}`);
     } else {
-      logger3.warn(`skipped (exists): ${authOut}`);
+      logger.warn(`skipped (exists): ${authOut}`);
     }
-    const envCode = render2(ENV_EXAMPLE_TEMPLATE, {
+    const envCode = render(ENV_EXAMPLE_TEMPLATE, {
       providers: providers.length > 0,
       entries
     });
-    const envOut = resolve3(ctx.cwd, ".env.example");
+    const envOut = resolve5(ctx.cwd, ".env.example");
     if (writeFile(envOut, envCode, { skipIfExists: true })) {
-      logger3.success(`created ${envOut}`);
+      logger.success(`created ${envOut}`);
     } else {
-      logger3.warn(`skipped (exists): ${envOut}`);
+      logger.warn(`skipped (exists): ${envOut}`);
     }
-    logger3.blank();
-    logger3.heading("Next steps");
-    logger3.info("1. Add a secret to .env:");
-    logger3.info("     BETTER_AUTH_SECRET=$(openssl rand -base64 32)");
-    logger3.info("2. Wire the module in AppModule:");
-    logger3.info(`     ${MODULE_UPDATE_HINT.trim()}`);
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info("1. Add a secret to .env:");
+    logger.info("     BETTER_AUTH_SECRET=$(openssl rand -base64 32)");
+    logger.info("2. Wire the module in AppModule:");
+    logger.info(`     ${MODULE_UPDATE_HINT.trim()}`);
     if (providers.length > 0) {
-      logger3.info(`3. Set up OAuth credentials for: ${providers.join(", ")}`);
+      logger.info(`3. Set up OAuth credentials for: ${providers.join(", ")}`);
     }
     if (passkeyEnabled) {
-      logger3.info("4. Configure passkey RP ID + origin for your domain.");
+      logger.info("4. Configure passkey RP ID + origin for your domain.");
     }
-    logger3.info("5. Run `bun --hot app/main.ts` to start the server.");
-    logger3.blank();
+    logger.info("5. Run `bun --hot app/main.ts` to start the server.");
+    logger.blank();
     return 0;
   }
 };
 var make_auth_default = makeAuthCommand;
 
 // packages/cli/src/commands/make-controller.ts
-import { resolve as resolve4 } from "path";
-import { logger as logger4, nameVariants, render as render3, writeFile as writeFile2 } from "@nexusts/core/index.js";
+import { resolve as resolve6 } from "path";
 var makeControllerCommand = {
   name: "make:controller",
   aliases: ["mc", "make-controller"],
@@ -1241,20 +1720,20 @@ var makeControllerCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger4.error("Usage: nx make:controller <Name>");
+      logger.error("Usage: nx make:controller <Name>");
       return 1;
     }
     const variants = nameVariants(name);
     const style = ctx.flags["style"] ?? ctx.config.routing;
     if (!["nest", "adonis", "functional"].includes(style)) {
-      logger4.error(`Unknown style: ${style}. Allowed: nest, adonis, functional.`);
+      logger.error(`Unknown style: ${style}. Allowed: nest, adonis, functional.`);
       return 1;
     }
     const skipService = ctx.flags["no-service"] === true;
     const serviceName = `${variants.pascal}Service`;
     const serviceCamel = variants.camel + "Service";
     const tpl = templates.controller[style];
-    const code = render3(tpl, {
+    const code = render(tpl, {
       name: variants.pascal,
       camel: variants.camel,
       kebab: variants.kebab,
@@ -1263,29 +1742,22 @@ var makeControllerCommand = {
       service: serviceName,
       serviceCamel
     }).replace(/import .*\n/g, skipService ? (m) => m.includes("services/") ? "" : m : (m) => m);
-    const out = resolve4(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
-    const ok = writeFile2(out, code, { skipIfExists: false });
+    const out = resolve6(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
+    const ok = writeFile(out, code, { skipIfExists: false });
     if (!ok) {
-      logger4.error(`Refusing to overwrite existing file: ${out}`);
+      logger.error(`Refusing to overwrite existing file: ${out}`);
       return 1;
     }
-    logger4.success(`created ${out}`);
-    logger4.finger(`edit ${variants.kebab}.controller.ts and add to a module.`);
+    logger.success(`created ${out}`);
+    logger.finger(`edit ${variants.kebab}.controller.ts and add to a module.`);
     return 0;
   }
 };
 var make_controller_default = makeControllerCommand;
 
 // packages/cli/src/commands/make-crud.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname, resolve as resolve5 } from "path";
-import {
-  flagBool as flagBool2,
-  logger as logger5,
-  nameVariants as nameVariants2,
-  render as render4,
-  writeFile as writeFile3
-} from "@nexusts/core/index.js";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve7 } from "path";
 
 // packages/cli/src/templates/model/drizzle-dialect.ts
 function renderDrizzleDialect(dialect) {
@@ -1299,8 +1771,8 @@ import { ${spec.imports.join(", ")} } from '${spec.importPath}';
 export const {{ snake }} = ${spec.tableFn}('{{ tableName }}', {
   id: ${spec.idHelper}('id').primaryKey(${spec.idOpts}),
 {{ columns }}
-  createdAt: ${spec.tsTimestamp}('created_at'${spec.tsDateMode}).notNull().$defaultFn(() => new Date()),
-  updatedAt: ${spec.tsTimestamp}('updated_at'${spec.tsDateMode}).notNull().$defaultFn(() => new Date()),
+  createdAt: ${spec.tsTimestamp}('created_at'${spec.tsDateMode}).notNull()${spec.defaultTs},
+  updatedAt: ${spec.tsTimestamp}('updated_at'${spec.tsDateMode})${spec.defaultTsUpdate},
 });
 
 export type {{ name }} = typeof {{ snake }}.$inferSelect;
@@ -1323,16 +1795,20 @@ var DIALECT_SPECS = {
     idHelper: "serial",
     idOpts: "",
     tsTimestamp: "timestamp",
-    tsDateMode: ""
+    tsDateMode: "",
+    defaultTs: ".defaultNow()",
+    defaultTsUpdate: ""
   },
   "bun-sqlite": {
-    imports: ["sqliteTable", "integer", "text", "real"],
+    imports: ["sqliteTable", "integer", "text"],
     importPath: "drizzle-orm/sqlite-core",
     tableFn: "sqliteTable",
     idHelper: "integer",
     idOpts: "{ autoIncrement: true }",
-    tsTimestamp: "integer",
-    tsDateMode: ", { mode: 'timestamp' }"
+    tsTimestamp: "text",
+    tsDateMode: "",
+    defaultTs: `.default("(datetime('now'))")`,
+    defaultTsUpdate: ""
   },
   sqlite: {
     imports: ["sqliteTable", "integer", "text", "real"],
@@ -1341,7 +1817,9 @@ var DIALECT_SPECS = {
     idHelper: "integer",
     idOpts: "{ autoIncrement: true }",
     tsTimestamp: "integer",
-    tsDateMode: ", { mode: 'timestamp' }"
+    tsDateMode: ", { mode: 'timestamp' }",
+    defaultTs: ".$defaultFn(() => Date.now())",
+    defaultTsUpdate: ".$defaultFn(() => Date.now())"
   },
   d1: {
     imports: ["sqliteTable", "integer", "text", "real"],
@@ -1350,7 +1828,9 @@ var DIALECT_SPECS = {
     idHelper: "integer",
     idOpts: "{ autoIncrement: true }",
     tsTimestamp: "integer",
-    tsDateMode: ", { mode: 'timestamp' }"
+    tsDateMode: ", { mode: 'timestamp' }",
+    defaultTs: ".$defaultFn(() => Date.now())",
+    defaultTsUpdate: ".$defaultFn(() => Date.now())"
   },
   mysql: {
     imports: [
@@ -1367,7 +1847,9 @@ var DIALECT_SPECS = {
     idHelper: "int",
     idOpts: "{ autoIncrement: true }",
     tsTimestamp: "timestamp",
-    tsDateMode: ""
+    tsDateMode: "",
+    defaultTs: ".defaultNow()",
+    defaultTsUpdate: ""
   }
 };
 function mapDrizzleType(dialect, type) {
@@ -1418,26 +1900,26 @@ var makeCrudCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger5.error("Usage: nx make:crud <Name>");
+      logger.error("Usage: nx make:crud <Name>");
       return 1;
     }
-    const variants = nameVariants2(name);
+    const variants = nameVariants(name);
     const style = ctx.flags["style"] ?? ctx.config.routing;
     const orm = ctx.flags["orm"] ?? ctx.config.orm;
     const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
-    const noRepo = flagBool2(ctx.flags, "no-repo", false) || orm === "none";
-    const noTest = flagBool2(ctx.flags, "no-test", false);
-    const hasInertia = ctx.config.view === "inertia" && !flagBool2(ctx.flags, "no-views", false);
+    const noRepo = flagBool(ctx.flags, "no-repo", false) || orm === "none";
+    const noTest = flagBool(ctx.flags, "no-test", false);
+    const hasInertia = ctx.config.view === "inertia" && !flagBool(ctx.flags, "no-views", false);
     const controller = `${variants.pascal}Controller`;
     const service = `${variants.pascal}Service`;
     const repository = `${variants.pascal}Repository`;
     const tableName = variants.pluralSnake;
     const viewComponent = `${variants.pascal}s/Index`;
     const viewShowComponent = `${variants.pascal}s/Show`;
-    logger5.heading(`Scaffolding ${variants.pascal} (style=${style}, view=${ctx.config.view}, orm=${orm})`);
+    logger.heading(`Scaffolding ${variants.pascal} (style=${style}, view=${ctx.config.view}, orm=${orm})`);
     const written = [];
     {
-      const code = render4(templates.crud.controller, {
+      const code = render(templates.crud.controller, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
@@ -1450,28 +1932,29 @@ var makeCrudCommand = {
         viewShowComponent,
         hasInertia
       });
-      const out = resolve5(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
-      if (!writeFile3(out, code, { skipIfExists: true })) {
-        logger5.warn(`skipped (exists): ${out}`);
+      const out = resolve7(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
+      if (!writeFile(out, code, { skipIfExists: true })) {
+        logger.warn(`skipped (exists): ${out}`);
       } else {
-        logger5.success(`created ${out}`);
+        logger.success(`created ${out}`);
         written.push(out);
       }
     }
     {
-      const code = render4(templates.service, {
+      const code = render(templates.service, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
+        snake: variants.snake,
         hasRepo: !noRepo,
         repository,
         repositoryCamel: variants.camel + "Repository"
       });
-      const out = resolve5(ctx.cwd, ctx.config.paths.services, `${variants.kebab}.service.ts`);
-      if (!writeFile3(out, code, { skipIfExists: true })) {
-        logger5.warn(`skipped (exists): ${out}`);
+      const out = resolve7(ctx.cwd, ctx.config.paths.services, `${variants.kebab}.service.ts`);
+      if (!writeFile(out, code, { skipIfExists: true })) {
+        logger.warn(`skipped (exists): ${out}`);
       } else {
-        logger5.success(`created ${out}`);
+        logger.success(`created ${out}`);
         written.push(out);
       }
     }
@@ -1480,7 +1963,7 @@ var makeCrudCommand = {
         let code;
         if (orm === "drizzle") {
           const tpl = renderDrizzleDialect(dialect);
-          code = render4(tpl, {
+          code = render(tpl, {
             name: variants.pascal,
             camel: variants.camel,
             kebab: variants.kebab,
@@ -1491,7 +1974,7 @@ var makeCrudCommand = {
           });
         } else {
           const tpl = templates.model[orm];
-          code = render4(tpl, {
+          code = render(tpl, {
             name: variants.pascal,
             camel: variants.camel,
             kebab: variants.kebab,
@@ -1501,46 +1984,47 @@ var makeCrudCommand = {
             prismaBlock: ""
           });
         }
-        const out = resolve5(ctx.cwd, ctx.config.paths.models, `${variants.kebab}.model.ts`);
-        if (!writeFile3(out, code, { skipIfExists: true })) {
-          logger5.warn(`skipped (exists): ${out}`);
+        const out = resolve7(ctx.cwd, ctx.config.paths.models, `${variants.kebab}.model.ts`);
+        if (!writeFile(out, code, { skipIfExists: true })) {
+          logger.warn(`skipped (exists): ${out}`);
         } else {
-          logger5.success(`created ${out}`);
+          logger.success(`created ${out}`);
           written.push(out);
         }
       }
-      const repoCode = render4(templates.repository, {
+      const repoCode = render(templates.repository, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
+        snake: variants.snake,
         tableName,
         repository
       });
-      const repoOut = resolve5(ctx.cwd, `${ctx.config.paths.app}/repositories`, `${variants.kebab}.repository.ts`);
-      mkdirSync2(dirname(repoOut), { recursive: true });
-      if (!writeFile3(repoOut, repoCode, { skipIfExists: true })) {
-        logger5.warn(`skipped (exists): ${repoOut}`);
+      const repoOut = resolve7(ctx.cwd, `${ctx.config.paths.app}/repositories`, `${variants.kebab}.repository.ts`);
+      mkdirSync3(dirname2(repoOut), { recursive: true });
+      if (!writeFile(repoOut, repoCode, { skipIfExists: true })) {
+        logger.warn(`skipped (exists): ${repoOut}`);
       } else {
-        logger5.success(`created ${repoOut}`);
+        logger.success(`created ${repoOut}`);
         written.push(repoOut);
       }
     }
     {
-      const code = render4(templates.crud.dto, {
+      const code = render(templates.crud.dto, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab
       });
-      const out = resolve5(ctx.cwd, ctx.config.paths.dto, `${variants.kebab}.dto.ts`);
-      if (!writeFile3(out, code, { skipIfExists: true })) {
-        logger5.warn(`skipped (exists): ${out}`);
+      const out = resolve7(ctx.cwd, ctx.config.paths.dto, `${variants.kebab}.dto.ts`);
+      if (!writeFile(out, code, { skipIfExists: true })) {
+        logger.warn(`skipped (exists): ${out}`);
       } else {
-        logger5.success(`created ${out}`);
+        logger.success(`created ${out}`);
         written.push(out);
       }
     }
     {
-      const code = render4(templates.crud.module, {
+      const code = render(templates.crud.module, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
@@ -1549,39 +2033,39 @@ var makeCrudCommand = {
         repository,
         hasRepo: !noRepo
       });
-      const out = resolve5(ctx.cwd, ctx.config.paths.modules, `${variants.kebab}.module.ts`);
-      if (!writeFile3(out, code, { skipIfExists: true })) {
-        logger5.warn(`skipped (exists): ${out}`);
+      const out = resolve7(ctx.cwd, ctx.config.paths.modules, `${variants.kebab}.module.ts`);
+      if (!writeFile(out, code, { skipIfExists: true })) {
+        logger.warn(`skipped (exists): ${out}`);
       } else {
-        logger5.success(`created ${out}`);
+        logger.success(`created ${out}`);
         written.push(out);
       }
     }
     if (!noTest) {
-      const code = render4(templates.crud.test, {
+      const code = render(templates.crud.test, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
         controller,
         service
       });
-      const out = resolve5(ctx.cwd, "tests", `${variants.kebab}.test.ts`);
-      if (!writeFile3(out, code, { skipIfExists: true })) {
-        logger5.warn(`skipped (exists): ${out}`);
+      const out = resolve7(ctx.cwd, "tests", `${variants.kebab}.test.ts`);
+      if (!writeFile(out, code, { skipIfExists: true })) {
+        logger.warn(`skipped (exists): ${out}`);
       } else {
-        logger5.success(`created ${out}`);
+        logger.success(`created ${out}`);
         written.push(out);
       }
     }
-    logger5.blank();
-    logger5.heading("Next steps");
-    logger5.info(`1. Review the generated files:`);
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info(`1. Review the generated files:`);
     for (const f of written)
-      logger5.info(`     ${f}`);
-    logger5.info(`2. Add ${variants.pascal}Module to AppModule.imports.`);
-    logger5.info(`3. ${noRepo ? "" : `Run \`bunx drizzle-kit migrate\` (or your migration tool).`}`);
-    logger5.info(`4. Start the dev server: \`bun --hot app/main.ts\`.`);
-    logger5.blank();
+      logger.info(`     ${f}`);
+    logger.info(`2. Add ${variants.pascal}Module to AppModule.imports.`);
+    logger.info(`3. ${noRepo ? "" : `Run \`bunx drizzle-kit migrate\` (or your migration tool).`}`);
+    logger.info(`4. Start the dev server: \`bun --hot app/main.ts\`.`);
+    logger.blank();
     return 0;
   }
 };
@@ -1601,8 +2085,7 @@ function renderDrizzleColumns(dialect) {
 var make_crud_default = makeCrudCommand;
 
 // packages/cli/src/commands/make-listener.ts
-import { resolve as resolve6 } from "path";
-import { logger as logger6, nameVariants as nameVariants3, render as render5, writeFile as writeFile4 } from "@nexusts/core/index.js";
+import { resolve as resolve8 } from "path";
 var LISTENER_TEMPLATE = `
 import { Inject, Injectable } from '@nexusts/core';
 import { EventService, OnEvent } from '@nexusts/events';
@@ -1645,36 +2128,35 @@ var makeListenerCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger6.error("Usage: nx make:listener <Name>");
+      logger.error("Usage: nx make:listener <Name>");
       return 1;
     }
-    const variants = nameVariants3(name);
-    const code = render5(LISTENER_TEMPLATE, {
+    const variants = nameVariants(name);
+    const code = render(LISTENER_TEMPLATE, {
       name: variants.pascal,
       kebab: variants.kebab
     });
-    const out = resolve6(ctx.cwd, "app/events/listeners", `${variants.kebab}.listener.ts`);
-    if (writeFile4(out, code, { skipIfExists: true })) {
-      logger6.success(`created ${out}`);
+    const out = resolve8(ctx.cwd, "app/events/listeners", `${variants.kebab}.listener.ts`);
+    if (writeFile(out, code, { skipIfExists: true })) {
+      logger.success(`created ${out}`);
     } else {
-      logger6.warn(`skipped (exists): ${out}`);
+      logger.warn(`skipped (exists): ${out}`);
     }
-    logger6.blank();
-    logger6.heading("Next steps");
-    logger6.info("1. Add @OnEvent('your.event') handlers to the class.");
-    logger6.info(`2. Import + register at boot:`);
-    logger6.info(`     scanForListeners(listener, events)`);
-    logger6.info(`3. Emit events from anywhere:`);
-    logger6.info(`     await events.emit('user.created', { userId: '1' })`);
-    logger6.blank();
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info("1. Add @OnEvent('your.event') handlers to the class.");
+    logger.info(`2. Import + register at boot:`);
+    logger.info(`     scanForListeners(listener, events)`);
+    logger.info(`3. Emit events from anywhere:`);
+    logger.info(`     await events.emit('user.created', { userId: '1' })`);
+    logger.blank();
     return 0;
   }
 };
 var make_listener_default = makeListenerCommand;
 
 // packages/cli/src/commands/make-middleware.ts
-import { resolve as resolve7 } from "path";
-import { logger as logger7, nameVariants as nameVariants4, render as render6, writeFile as writeFile5 } from "@nexusts/core/index.js";
+import { resolve as resolve9 } from "path";
 var makeMiddlewareCommand = {
   name: "make:middleware",
   aliases: ["mwm", "make-middleware"],
@@ -1684,25 +2166,24 @@ var makeMiddlewareCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger7.error("Usage: nx make:middleware <Name>");
+      logger.error("Usage: nx make:middleware <Name>");
       return 1;
     }
-    const variants = nameVariants4(name);
-    const code = render6(templates.middleware, {
+    const variants = nameVariants(name);
+    const code = render(templates.middleware, {
       name: variants.pascal
     });
-    const out = resolve7(ctx.cwd, ctx.config.paths.middleware, `${variants.kebab}.middleware.ts`);
-    writeFile5(out, code);
-    logger7.success(`created ${out}`);
-    logger7.finger(`register with: app.server.app.use('*', new ${variants.pascal}Middleware().handle)`);
+    const out = resolve9(ctx.cwd, ctx.config.paths.middleware, `${variants.kebab}.middleware.ts`);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
+    logger.finger(`register with: app.server.app.use('*', new ${variants.pascal}Middleware().handle)`);
     return 0;
   }
 };
 var make_middleware_default = makeMiddlewareCommand;
 
 // packages/cli/src/commands/make-migration.ts
-import { resolve as resolve8 } from "path";
-import { logger as logger8, nameVariants as nameVariants5, render as render7, writeFile as writeFile6 } from "@nexusts/core/index.js";
+import { resolve as resolve10 } from "path";
 var makeMigrationCommand = {
   name: "make:migration",
   aliases: ["mkm", "make-migration"],
@@ -1730,14 +2211,14 @@ var makeMigrationCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger8.error("Usage: nx make:migration <Name> [--dialect ...]");
+      logger.error("Usage: nx make:migration <Name> [--dialect ...]");
       return 1;
     }
     const orm = ctx.flags["orm"] ?? ctx.config.orm;
     const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
     const isDrizzle = orm === "drizzle";
     const useGenericSql = orm === "none" || orm === "prisma" || orm === "kysely";
-    const variants = nameVariants5(name);
+    const variants = nameVariants(name);
     const tableName = inferTableName(name);
     const colsFlag = ctx.flags["columns"];
     const cols = parseColumns(colsFlag ?? "title:text");
@@ -1747,11 +2228,11 @@ var makeMigrationCommand = {
     let extension;
     if (isDrizzle) {
       if (!isValidDialect(dialect)) {
-        logger8.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
+        logger.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
         return 1;
       }
       code = renderDrizzleDialect(dialect);
-      code = render7(code, {
+      code = render(code, {
         name: variants.pascal,
         snake: variants.snake,
         tableName,
@@ -1761,7 +2242,7 @@ var makeMigrationCommand = {
       extension = "ts";
     } else if (useGenericSql) {
       const tpl = templates.migration.sql;
-      code = render7(tpl, {
+      code = render(tpl, {
         name: variants.pascal,
         snake: variants.snake,
         tableName,
@@ -1770,17 +2251,17 @@ var makeMigrationCommand = {
       });
       extension = "sql";
     } else {
-      logger8.error(`Unsupported ORM for migration: ${orm}. Allowed: drizzle, none, prisma, kysely.`);
+      logger.error(`Unsupported ORM for migration: ${orm}. Allowed: drizzle, none, prisma, kysely.`);
       return 1;
     }
     const filename = `${formatTimestamp(new Date)}_${variants.snake}.${extension}`;
-    const out = resolve8(ctx.cwd, ctx.config.paths.migrations, filename);
-    writeFile6(out, code);
-    logger8.success(`created ${out}`);
+    const out = resolve10(ctx.cwd, ctx.config.paths.migrations, filename);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
     if (isDrizzle) {
-      logger8.finger(`run \`nx migrate\` to apply pending migrations.`);
+      logger.finger(`run \`nx migrate\` to apply pending migrations.`);
     } else {
-      logger8.finger(`run \`bunx drizzle-kit migrate\` or your migration tool.`);
+      logger.finger(`run \`bunx drizzle-kit migrate\` or your migration tool.`);
     }
     return 0;
   }
@@ -1799,8 +2280,8 @@ function inferTableName(input) {
 }
 function parseColumns(input) {
   const list = Array.isArray(input) ? input : input.split(",");
-  return list.map((s) => s.trim()).filter(Boolean).map((c) => {
-    const [name, type = "text"] = c.split(":");
+  return list.map((s) => s.trim()).filter(Boolean).map((c2) => {
+    const [name, type = "text"] = c2.split(":");
     return [name, type];
   });
 }
@@ -1862,14 +2343,7 @@ function formatTimestamp(d) {
 var make_migration_default = makeMigrationCommand;
 
 // packages/cli/src/commands/make-model.ts
-import { resolve as resolve9 } from "path";
-import {
-  flagList as flagList2,
-  logger as logger9,
-  nameVariants as nameVariants6,
-  render as render8,
-  writeFile as writeFile7
-} from "@nexusts/core/index.js";
+import { resolve as resolve11 } from "path";
 var makeModelCommand = {
   name: "make:model",
   aliases: ["mmodel", "make-model"],
@@ -1898,17 +2372,17 @@ var makeModelCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger9.error("Usage: nx make:model <Name> [--columns name:type,...] [--dialect ...]");
+      logger.error("Usage: nx make:model <Name> [--columns name:type,...] [--dialect ...]");
       return 1;
     }
     const orm = ctx.flags["orm"] ?? ctx.config.orm;
     if (orm !== "drizzle" && orm !== "prisma" && orm !== "kysely") {
-      logger9.error(`Unsupported ORM: ${orm}. Allowed: drizzle, prisma, kysely. Use --orm or set "orm" in nx.config.ts.`);
+      logger.error(`Unsupported ORM: ${orm}. Allowed: drizzle, prisma, kysely. Use --orm or set "orm" in nx.config.ts.`);
       return 1;
     }
-    const variants = nameVariants6(name);
+    const variants = nameVariants(name);
     const tableName = variants.pluralSnake;
-    const colsFlag = flagList2(ctx.flags, "columns");
+    const colsFlag = flagList(ctx.flags, "columns");
     const columns = colsFlag.length > 0 ? colsFlag : ["title:text"];
     const columnLines = renderColumns(columns, orm, ctx.flags["dialect"]);
     const prismaBlock = renderPrismaBlock(variants.pascal, columns);
@@ -1916,11 +2390,11 @@ var makeModelCommand = {
     if (orm === "drizzle") {
       const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
       if (!isValidDialect2(dialect)) {
-        logger9.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
+        logger.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
         return 1;
       }
       code = renderDrizzleDialect(dialect);
-      code = render8(code, {
+      code = render(code, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
@@ -1931,7 +2405,7 @@ var makeModelCommand = {
       });
     } else {
       const tpl = templates.model[orm];
-      code = render8(tpl, {
+      code = render(tpl, {
         name: variants.pascal,
         camel: variants.camel,
         kebab: variants.kebab,
@@ -1941,12 +2415,12 @@ var makeModelCommand = {
         prismaBlock
       });
     }
-    const out = resolve9(ctx.cwd, ctx.config.paths.models, `${variants.kebab}.model.ts`);
-    writeFile7(out, code);
-    logger9.success(`created ${out}`);
-    logger9.finger(`run \`nx make:migration create_${tableName}_table\` to scaffold a migration.`);
+    const out = resolve11(ctx.cwd, ctx.config.paths.models, `${variants.kebab}.model.ts`);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
+    logger.finger(`run \`nx make:migration create_${tableName}_table\` to scaffold a migration.`);
     if (orm === "drizzle") {
-      logger9.finger(`run \`nx migrate\` to apply pending migrations to the database.`);
+      logger.finger(`run \`nx migrate\` to apply pending migrations to the database.`);
     }
     return 0;
   }
@@ -1955,10 +2429,10 @@ function isValidDialect2(d) {
   return ["postgres", "mysql", "sqlite", "bun-sqlite", "d1"].includes(d);
 }
 function renderColumns(cols, orm, dialect) {
-  const flat = cols.flatMap((c) => c.split(",")).map((c) => c.trim()).filter(Boolean);
+  const flat = cols.flatMap((c2) => c2.split(",")).map((c2) => c2.trim()).filter(Boolean);
   return flat.map((col) => {
     const [colName, colType = "text"] = col.split(":");
-    const tsName = toCamel(colName);
+    const tsName = toCamel2(colName);
     switch (orm) {
       case "drizzle": {
         const d = dialect ?? "bun-sqlite";
@@ -1977,8 +2451,8 @@ function renderColumns(cols, orm, dialect) {
 `);
 }
 function renderPrismaBlock(modelName, cols) {
-  const fieldLines = cols.map((c) => {
-    const [name, type = "String"] = c.split(":");
+  const fieldLines = cols.map((c2) => {
+    const [name, type = "String"] = c2.split(":");
     return `  ${name.padEnd(16)} ${capitalize(type)}`;
   }).join(`
 `);
@@ -1991,8 +2465,8 @@ ${fieldLines.split(`
  *   updatedAt   DateTime @updatedAt
  * }`;
 }
-function toCamel(s) {
-  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+function toCamel2(s) {
+  return s.replace(/_([a-z])/g, (_, c2) => c2.toUpperCase());
 }
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
@@ -2000,14 +2474,7 @@ function capitalize(s) {
 var make_model_default = makeModelCommand;
 
 // packages/cli/src/commands/make-module.ts
-import { resolve as resolve10 } from "path";
-import {
-  flagBool as flagBool3,
-  logger as logger10,
-  nameVariants as nameVariants7,
-  render as render9,
-  writeFile as writeFile8
-} from "@nexusts/core/index.js";
+import { resolve as resolve12 } from "path";
 var makeModuleCommand = {
   name: "make:module",
   aliases: ["mm", "make-module"],
@@ -2025,14 +2492,14 @@ var makeModuleCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger10.error("Usage: nx make:module <Name>");
+      logger.error("Usage: nx make:module <Name>");
       return 1;
     }
-    const variants = nameVariants7(name);
-    const hasController = !flagBool3(ctx.flags, "no-controller", false);
-    const hasService = !flagBool3(ctx.flags, "no-service", false);
-    const hasRepo = !flagBool3(ctx.flags, "no-repo", false) && ctx.config.orm !== "none";
-    const code = render9(templates.module, {
+    const variants = nameVariants(name);
+    const hasController = !flagBool(ctx.flags, "no-controller", false);
+    const hasService = !flagBool(ctx.flags, "no-service", false);
+    const hasRepo = !flagBool(ctx.flags, "no-repo", false) && ctx.config.orm !== "none";
+    const code = render(templates.module, {
       name: variants.pascal,
       kebab: variants.kebab,
       controller: `${variants.pascal}Controller`,
@@ -2041,24 +2508,17 @@ var makeModuleCommand = {
       hasService,
       hasRepo
     });
-    const out = resolve10(ctx.cwd, ctx.config.paths.modules, `${variants.kebab}.module.ts`);
-    writeFile8(out, code);
-    logger10.success(`created ${out}`);
-    logger10.finger(`add ${variants.pascal}Module to AppModule.imports.`);
+    const out = resolve12(ctx.cwd, ctx.config.paths.modules, `${variants.kebab}.module.ts`);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
+    logger.finger(`add ${variants.pascal}Module to AppModule.imports.`);
     return 0;
   }
 };
 var make_module_default = makeModuleCommand;
 
 // packages/cli/src/commands/make-queue.ts
-import { resolve as resolve11 } from "path";
-import {
-  flagBool as flagBool4,
-  logger as logger11,
-  nameVariants as nameVariants8,
-  render as render10,
-  writeFile as writeFile9
-} from "@nexusts/core/index.js";
+import { resolve as resolve13 } from "path";
 var WORKER_TEMPLATE = `
 import { Inject, Injectable } from '@nexusts/core';
 import { QueueService, OnQueueReady } from '@nexusts/queue';
@@ -2171,58 +2631,57 @@ var makeQueueCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger11.error("Usage: nx make:queue <Name>");
+      logger.error("Usage: nx make:queue <Name>");
       return 1;
     }
-    const variants = nameVariants8(name);
+    const variants = nameVariants(name);
     const backend = ctx.flags["backend"] ?? ctx.config.queue?.backend ?? "memory";
     if (!["bullmq", "cloudflare", "memory"].includes(backend)) {
-      logger11.error(`Unknown backend: ${backend}. Allowed: bullmq, cloudflare, memory.`);
+      logger.error(`Unknown backend: ${backend}. Allowed: bullmq, cloudflare, memory.`);
       return 1;
     }
-    logger11.heading(`Scaffolding ${variants.pascal} (backend=${backend})`);
-    if (!flagBool4(ctx.flags, "no-worker", false)) {
-      const code = render10(WORKER_TEMPLATE, {
+    logger.heading(`Scaffolding ${variants.pascal} (backend=${backend})`);
+    if (!flagBool(ctx.flags, "no-worker", false)) {
+      const code = render(WORKER_TEMPLATE, {
         name: variants.pascal,
         kebab: variants.kebab
       });
-      const out = resolve11(ctx.cwd, "app/queue/workers", `${variants.kebab}.worker.ts`);
-      if (writeFile9(out, code, { skipIfExists: true })) {
-        logger11.success(`created ${out}`);
+      const out = resolve13(ctx.cwd, "app/queue/workers", `${variants.kebab}.worker.ts`);
+      if (writeFile(out, code, { skipIfExists: true })) {
+        logger.success(`created ${out}`);
       } else {
-        logger11.warn(`skipped (exists): ${out}`);
+        logger.warn(`skipped (exists): ${out}`);
       }
     }
-    if (!flagBool4(ctx.flags, "no-job", false)) {
-      const code = render10(JOB_HELPER_TEMPLATE, {
+    if (!flagBool(ctx.flags, "no-job", false)) {
+      const code = render(JOB_HELPER_TEMPLATE, {
         name: variants.pascal,
         kebab: variants.kebab
       });
-      const out = resolve11(ctx.cwd, "app/queue/jobs", `${variants.kebab}.job.ts`);
-      if (writeFile9(out, code, { skipIfExists: true })) {
-        logger11.success(`created ${out}`);
+      const out = resolve13(ctx.cwd, "app/queue/jobs", `${variants.kebab}.job.ts`);
+      if (writeFile(out, code, { skipIfExists: true })) {
+        logger.success(`created ${out}`);
       } else {
-        logger11.warn(`skipped (exists): ${out}`);
+        logger.warn(`skipped (exists): ${out}`);
       }
     }
-    logger11.blank();
-    logger11.heading("Next steps");
-    logger11.info(`1. Add QueueModule.forRoot() to your AppModule.imports:`);
-    logger11.info(`     QueueModule.forRoot({ backend: '${backend}', ... })`);
-    logger11.info(`2. Wire the worker + helper as providers:`);
-    logger11.info(render10(WIRE_HINT, { name: variants.pascal, kebab: variants.kebab }).split(`
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info(`1. Add QueueModule.forRoot() to your AppModule.imports:`);
+    logger.info(`     QueueModule.forRoot({ backend: '${backend}', ... })`);
+    logger.info(`2. Wire the worker + helper as providers:`);
+    logger.info(render(WIRE_HINT, { name: variants.pascal, kebab: variants.kebab }).split(`
 `).map((l) => "     " + l).join(`
 `));
-    logger11.info(`3. Replace the TODO in ${variants.pascal}Worker.handle() with your logic.`);
-    logger11.blank();
+    logger.info(`3. Replace the TODO in ${variants.pascal}Worker.handle() with your logic.`);
+    logger.blank();
     return 0;
   }
 };
 var make_queue_default = makeQueueCommand;
 
 // packages/cli/src/commands/make-schedule.ts
-import { resolve as resolve12 } from "path";
-import { logger as logger12, nameVariants as nameVariants9, render as render11, writeFile as writeFile10 } from "@nexusts/core/index.js";
+import { resolve as resolve14 } from "path";
 var TASK_TEMPLATE = `
 import { Inject, Injectable } from '@nexusts/core';
 import { Cron, Interval, Timeout, ScheduleService } from '@nexusts/schedule';
@@ -2270,35 +2729,34 @@ var makeScheduleCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger12.error("Usage: nx make:schedule <Name>");
+      logger.error("Usage: nx make:schedule <Name>");
       return 1;
     }
-    const variants = nameVariants9(name);
-    const code = render11(TASK_TEMPLATE, {
+    const variants = nameVariants(name);
+    const code = render(TASK_TEMPLATE, {
       name: variants.pascal,
       kebab: variants.kebab
     });
-    const out = resolve12(ctx.cwd, "app/schedule/tasks", `${variants.kebab}.task.ts`);
-    if (writeFile10(out, code, { skipIfExists: true })) {
-      logger12.success(`created ${out}`);
+    const out = resolve14(ctx.cwd, "app/schedule/tasks", `${variants.kebab}.task.ts`);
+    if (writeFile(out, code, { skipIfExists: true })) {
+      logger.success(`created ${out}`);
     } else {
-      logger12.warn(`skipped (exists): ${out}`);
+      logger.warn(`skipped (exists): ${out}`);
     }
-    logger12.blank();
-    logger12.heading("Next steps");
-    logger12.info("1. Add @Cron / @Interval / @Timeout handlers to the class.");
-    logger12.info(`2. Import + register at boot:`);
-    logger12.info(`     scanForSchedulers(task, schedule)`);
-    logger12.info(`3. Don't forget to call \`schedule.start()\` to begin the tick.`);
-    logger12.blank();
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info("1. Add @Cron / @Interval / @Timeout handlers to the class.");
+    logger.info(`2. Import + register at boot:`);
+    logger.info(`     scanForSchedulers(task, schedule)`);
+    logger.info(`3. Don't forget to call \`schedule.start()\` to begin the tick.`);
+    logger.blank();
     return 0;
   }
 };
 var make_schedule_default = makeScheduleCommand;
 
 // packages/cli/src/commands/make-service.ts
-import { resolve as resolve13 } from "path";
-import { logger as logger13, nameVariants as nameVariants10, render as render12, writeFile as writeFile11 } from "@nexusts/core/index.js";
+import { resolve as resolve15 } from "path";
 var makeServiceCommand = {
   name: "make:service",
   aliases: ["ms", "make-service"],
@@ -2314,14 +2772,14 @@ var makeServiceCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger13.error("Usage: nx make:service <Name>");
+      logger.error("Usage: nx make:service <Name>");
       return 1;
     }
-    const variants = nameVariants10(name);
+    const variants = nameVariants(name);
     const hasRepo = ctx.flags["no-repo"] !== true && ctx.config.orm !== "none";
     const repository = `${variants.pascal}Repository`;
     const repositoryCamel = variants.camel + "Repository";
-    const code = render12(templates.service, {
+    const code = render(templates.service, {
       name: variants.pascal,
       camel: variants.camel,
       kebab: variants.kebab,
@@ -2329,17 +2787,16 @@ var makeServiceCommand = {
       repository,
       repositoryCamel
     });
-    const out = resolve13(ctx.cwd, ctx.config.paths.services, `${variants.kebab}.service.ts`);
-    writeFile11(out, code);
-    logger13.success(`created ${out}`);
+    const out = resolve15(ctx.cwd, ctx.config.paths.services, `${variants.kebab}.service.ts`);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
     return 0;
   }
 };
 var make_service_default = makeServiceCommand;
 
 // packages/cli/src/commands/make-session.ts
-import { resolve as resolve14 } from "path";
-import { logger as logger14, nameVariants as nameVariants11, render as render13, writeFile as writeFile12 } from "@nexusts/core/index.js";
+import { resolve as resolve16 } from "path";
 var SESSION_TEMPLATE = `
 import { Inject, Injectable } from '@nexusts/core';
 import { SessionService } from '@nexusts/session';
@@ -2393,34 +2850,33 @@ var makeSessionCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger14.error("Usage: nx make:session <Name>");
+      logger.error("Usage: nx make:session <Name>");
       return 1;
     }
-    const variants = nameVariants11(name);
-    const code = render13(SESSION_TEMPLATE, {
+    const variants = nameVariants(name);
+    const code = render(SESSION_TEMPLATE, {
       name: variants.pascal,
       kebab: variants.kebab
     });
-    const out = resolve14(ctx.cwd, "app/session/services", `${variants.kebab}.session.ts`);
-    if (writeFile12(out, code, { skipIfExists: true })) {
-      logger14.success(`created ${out}`);
+    const out = resolve16(ctx.cwd, "app/session/services", `${variants.kebab}.session.ts`);
+    if (writeFile(out, code, { skipIfExists: true })) {
+      logger.success(`created ${out}`);
     } else {
-      logger14.warn(`skipped (exists): ${out}`);
+      logger.warn(`skipped (exists): ${out}`);
     }
-    logger14.blank();
-    logger14.heading("Next steps");
-    logger14.info("1. Define the typed payload (replace the TODO interface).");
-    logger14.info(`2. Inject {{name}}Session in your controllers / services.`);
-    logger14.info("3. Bind it in the module's providers array.");
-    logger14.blank();
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info("1. Define the typed payload (replace the TODO interface).");
+    logger.info(`2. Inject {{name}}Session in your controllers / services.`);
+    logger.info("3. Bind it in the module's providers array.");
+    logger.blank();
     return 0;
   }
 };
 var make_session_default = makeSessionCommand;
 
 // packages/cli/src/commands/make-validator.ts
-import { resolve as resolve15 } from "path";
-import { logger as logger15, nameVariants as nameVariants12, render as render14, writeFile as writeFile13 } from "@nexusts/core/index.js";
+import { resolve as resolve17 } from "path";
 var makeValidatorCommand = {
   name: "make:validator",
   aliases: ["mv", "make-validator"],
@@ -2430,16 +2886,16 @@ var makeValidatorCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger15.error("Usage: nx make:validator <Name>");
+      logger.error("Usage: nx make:validator <Name>");
       return 1;
     }
-    const variants = nameVariants12(name);
-    const code = render14(templates.validator, {
+    const variants = nameVariants(name);
+    const code = render(templates.validator, {
       name: variants.pascal
     });
-    const out = resolve15(ctx.cwd, ctx.config.paths.dto, `${variants.kebab}.dto.ts`);
-    writeFile13(out, code);
-    logger15.success(`created ${out}`);
+    const out = resolve17(ctx.cwd, ctx.config.paths.dto, `${variants.kebab}.dto.ts`);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
     return 0;
   }
 };
@@ -2447,9 +2903,8 @@ var make_validator_default = makeValidatorCommand;
 
 // packages/cli/src/commands/db-migrate.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { resolve as resolve16 } from "path";
-import { logger as logger16 } from "@nexusts/core/index.js";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve18 } from "path";
 var dbMigrateCommand = {
   name: "db:migrate",
   aliases: ["db:m", "migrate"],
@@ -2484,15 +2939,15 @@ var dbMigrateCommand = {
     }
   ],
   async run(ctx) {
-    const folder = ctx.flags["folder"] ?? resolve16(ctx.cwd, ctx.config.paths.migrations);
+    const folder = ctx.flags["folder"] ?? resolve18(ctx.cwd, ctx.config.paths.migrations);
     const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
-    const configPath = ctx.flags["config"] ?? resolve16(ctx.cwd, "drizzle.config.ts");
+    const configPath = ctx.flags["config"] ?? resolve18(ctx.cwd, "drizzle.config.ts");
     const wantStatus = Boolean(ctx.flags["status"]);
     const generateName = ctx.flags["generate"];
     if (generateName) {
       return runDrizzleKit(ctx.cwd, [
         "generate",
-        ...existsSync2(configPath) ? [`--config=${configPath}`] : [],
+        ...existsSync4(configPath) ? [`--config=${configPath}`] : [],
         "--name",
         generateName
       ]);
@@ -2502,34 +2957,34 @@ var dbMigrateCommand = {
     }
     return runDrizzleKit(ctx.cwd, [
       "migrate",
-      ...existsSync2(configPath) ? [`--config=${configPath}`] : []
+      ...existsSync4(configPath) ? [`--config=${configPath}`] : []
     ]);
   }
 };
-function runDrizzleKit(cwd, args) {
+function runDrizzleKit(cwd, args2) {
   return new Promise((resolveP) => {
     const cmd = "bunx";
-    logger16.info(`$ ${cmd} drizzle-kit ${args.join(" ")}`);
-    const child = spawn(cmd, ["drizzle-kit", ...args], {
+    logger.info(`$ ${cmd} drizzle-kit ${args2.join(" ")}`);
+    const child = spawn(cmd, ["drizzle-kit", ...args2], {
       cwd,
       stdio: "inherit",
       shell: process.platform === "win32"
     });
     child.on("exit", (code) => resolveP(code ?? 0));
     child.on("error", (err) => {
-      logger16.error(`failed to spawn drizzle-kit: ${err.message}`);
+      logger.error(`failed to spawn drizzle-kit: ${err.message}`);
       resolveP(1);
     });
   });
 }
 async function runStatus(cwd, folder, dialect, configUrl = "") {
-  if (!existsSync2(folder)) {
-    logger16.warn(`migrations folder not found: ${folder}`);
+  if (!existsSync4(folder)) {
+    logger.warn(`migrations folder not found: ${folder}`);
     return 0;
   }
   const url = readEnvUrl(dialect) ?? configUrl;
   if (!url) {
-    logger16.error(`could not read ${dialect} URL from environment. Set DATABASE_URL or NEXUS_DB_URL.`);
+    logger.error(`could not read ${dialect} URL from environment. Set DATABASE_URL or NEXUS_DB_URL.`);
     return 1;
   }
   const script = `
@@ -2547,7 +3002,7 @@ const applied = await svc.appliedMigrations();
 console.log(JSON.stringify({ total: applied.length, applied }, null, 2));
 await svc.close();
 `;
-  const tmpFile = resolve16(cwd, ".nx-migrate-status.mjs");
+  const tmpFile = resolve18(cwd, ".nx-migrate-status.mjs");
   await import("fs/promises").then((m) => m.writeFile(tmpFile, script, "utf-8"));
   try {
     const code = await new Promise((resP) => {
@@ -2556,7 +3011,7 @@ await svc.close();
         stdio: "inherit",
         shell: process.platform === "win32"
       });
-      child.on("exit", (c) => resP(c ?? 0));
+      child.on("exit", (c2) => resP(c2 ?? 0));
       child.on("error", () => resP(1));
     });
     return code;
@@ -2571,8 +3026,7 @@ function readEnvUrl(dialect) {
 var db_migrate_default = dbMigrateCommand;
 
 // packages/cli/src/commands/db-generate.ts
-import { resolve as resolve17 } from "path";
-import { logger as logger17 } from "@nexusts/core/index.js";
+import { resolve as resolve19 } from "path";
 var dbGenerateCommand = {
   name: "db:generate",
   aliases: ["db:g", "db-generate", "generate-migration"],
@@ -2599,25 +3053,25 @@ var dbGenerateCommand = {
     const isSql = ctx.flags["sql"] === true;
     if (isSql) {
       if (!name) {
-        logger17.error("Usage: nx db:generate <name> --sql");
+        logger.error("Usage: nx db:generate <name> --sql");
         return 1;
       }
-      logger17.info(`Generating raw SQL migration: ${name} (dialect=${dialect})`);
+      logger.info(`Generating raw SQL migration: ${name} (dialect=${dialect})`);
       return runSqlTemplate(ctx.cwd, name, dialect);
     }
-    const configPath = resolve17(ctx.cwd, "drizzle.config.ts");
-    const args = ["generate", "--config", configPath];
+    const configPath = resolve19(ctx.cwd, "drizzle.config.ts");
+    const args2 = ["generate", "--config", configPath];
     if (name)
-      args.push("--name", name);
-    logger17.info(`Generating migration: ${name} (dialect=${dialect})`);
-    return runDrizzleKit(ctx.cwd, args);
+      args2.push("--name", name);
+    logger.info(`Generating migration: ${name} (dialect=${dialect})`);
+    return runDrizzleKit(ctx.cwd, args2);
   }
 };
 async function runSqlTemplate(cwd, name, dialect) {
-  const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync2 } = await import("fs");
+  const { mkdirSync: mkdirSync4, writeFileSync: writeFileSync3 } = await import("fs");
   const { join } = await import("path");
   const migrationsDir = join(cwd, "app", "database", "migrations");
-  mkdirSync3(migrationsDir, { recursive: true });
+  mkdirSync4(migrationsDir, { recursive: true });
   const timestamp = Date.now();
   const filename = `${timestamp}_${name.replace(/[^a-z0-9_]+/g, "_")}.sql`;
   const filepath = join(migrationsDir, filename);
@@ -2630,19 +3084,18 @@ async function runSqlTemplate(cwd, name, dialect) {
 -- Generated: ${new Date().toISOString()}
 
 `;
-  writeFileSync2(filepath, header);
-  logger17.success(`created ${filepath}`);
-  logger17.info("Edit the SQL file, then run `nx db:migrate` to apply it.");
+  writeFileSync3(filepath, header);
+  logger.success(`created ${filepath}`);
+  logger.info("Edit the SQL file, then run `nx db:migrate` to apply it.");
   return 0;
 }
 var db_generate_default = dbGenerateCommand;
 
 // packages/cli/src/commands/db-seed.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { mkdir, readdir, writeFile as writeFile14, unlink } from "fs/promises";
-import { resolve as resolve18 } from "path";
-import { logger as logger18 } from "@nexusts/core/index.js";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir, readdir, writeFile as writeFile2, unlink } from "fs/promises";
+import { resolve as resolve20 } from "path";
 var SEED_TEMPLATE = `/**
  * Seed: {name}
  *
@@ -2703,7 +3156,7 @@ var dbSeedCommand = {
     }
   ],
   async run(ctx) {
-    const folder = resolve18(ctx.cwd, ctx.flags["folder"] ?? ctx.config.paths?.seeds ?? "db/seeds");
+    const folder = resolve20(ctx.cwd, ctx.flags["folder"] ?? ctx.config.paths?.seeds ?? "db/seeds");
     const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
     const createName = ctx.flags["create"];
     const fileName = ctx.flags["file"];
@@ -2711,10 +3164,10 @@ var dbSeedCommand = {
     if (createName) {
       return await createSeedFile(folder, createName);
     }
-    if (!existsSync3(folder)) {
-      logger18.info(`creating empty seeds folder at ${folder}`);
+    if (!existsSync5(folder)) {
+      logger.info(`creating empty seeds folder at ${folder}`);
       await mkdir(folder, { recursive: true });
-      await writeFile14(resolve18(folder, "_README.ts"), `// Seed files go here. Run with: nx db:seed
+      await writeFile2(resolve20(folder, "_README.ts"), `// Seed files go here. Run with: nx db:seed
 `, "utf-8");
       return 0;
     }
@@ -2722,23 +3175,23 @@ var dbSeedCommand = {
     if (fileName) {
       const matched = files.filter((f) => f.toLowerCase().includes(fileName.toLowerCase()));
       if (matched.length === 0) {
-        logger18.error(`no seed file matching "${fileName}" in ${folder}`);
+        logger.error(`no seed file matching "${fileName}" in ${folder}`);
         return 1;
       }
     } else if (files.length === 0) {
-      logger18.warn(`no seed files found in ${folder}`);
+      logger.warn(`no seed files found in ${folder}`);
       return 0;
     }
     const target = fileName ? files.filter((f) => f.toLowerCase().includes(fileName.toLowerCase())) : files;
     const url = readEnvUrl2(dialect);
     if (!url) {
-      logger18.error(`could not read ${dialect} URL from environment. Set DATABASE_URL or NEXUS_DB_URL.`);
+      logger.error(`could not read ${dialect} URL from environment. Set DATABASE_URL or NEXUS_DB_URL.`);
       return 1;
     }
     if (reset) {
-      logger18.warn("--reset is set: truncating every table in the schema before running seeds.");
+      logger.warn("--reset is set: truncating every table in the schema before running seeds.");
     }
-    const seedImports = target.map((f, i) => `import seed_${i} from ${JSON.stringify(resolve18(folder, f))};`).join(`
+    const seedImports = target.map((f, i) => `import seed_${i} from ${JSON.stringify(resolve20(folder, f))};`).join(`
 `);
     const seedCalls = target.map((_, i) => `  await seed_${i}({ db, logger, dialect, truncate: (t) => db.truncate(t) });`).join(`
 `);
@@ -2771,8 +3224,8 @@ ${seedCalls}
 await db.close();
 logger.info(\`Seeds complete (\${${target.length}} file(s))\`);
 `;
-    const tmpFile = resolve18(ctx.cwd, ".nx-db-seed.mjs");
-    await writeFile14(tmpFile, script, "utf-8");
+    const tmpFile = resolve20(ctx.cwd, ".nx-db-seed.mjs");
+    await writeFile2(tmpFile, script, "utf-8");
     try {
       const code = await new Promise((resP) => {
         const child = spawn2("bun", [tmpFile], {
@@ -2780,7 +3233,7 @@ logger.info(\`Seeds complete (\${${target.length}} file(s))\`);
           stdio: "inherit",
           shell: process.platform === "win32"
         });
-        child.on("exit", (c) => resP(c ?? 0));
+        child.on("exit", (c2) => resP(c2 ?? 0));
         child.on("error", () => resP(1));
       });
       return code;
@@ -2806,21 +3259,21 @@ async function collectSeedFiles(folder) {
 }
 async function createSeedFile(folder, name) {
   if (!/^[a-z0-9_-]+$/i.test(name)) {
-    logger18.error(`invalid seed name "${name}" \u2014 use letters, numbers, dash, underscore.`);
+    logger.error(`invalid seed name "${name}" \u2014 use letters, numbers, dash, underscore.`);
     return 1;
   }
-  if (!existsSync3(folder))
+  if (!existsSync5(folder))
     await mkdir(folder, { recursive: true });
   let candidate = `${name}.ts`;
   let i = 1;
-  while (existsSync3(resolve18(folder, candidate))) {
+  while (existsSync5(resolve20(folder, candidate))) {
     candidate = `${name}_${i}.ts`;
     i++;
   }
-  const path = resolve18(folder, candidate);
+  const path = resolve20(folder, candidate);
   const body = SEED_TEMPLATE.replace(/\{name\}/g, name);
-  await writeFile14(path, body, "utf-8");
-  logger18.info(`created ${path}`);
+  await writeFile2(path, body, "utf-8");
+  logger.info(`created ${path}`);
   return 0;
 }
 function readEnvUrl2(dialect) {
@@ -2828,7 +3281,7 @@ function readEnvUrl2(dialect) {
   return url ?? null;
 }
 function relativeImport(cwd, target) {
-  const abs = resolve18(cwd, target);
+  const abs = resolve20(cwd, target);
   let rel = abs;
   if (rel.startsWith(cwd))
     rel = rel.slice(cwd.length);
@@ -2841,9 +3294,8 @@ function relativeImport(cwd, target) {
 var db_seed_default = dbSeedCommand;
 
 // packages/cli/src/commands/new.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve19 } from "path";
-import { flagBool as flagBool5, logger as logger19, render as render15, select as select2 } from "@nexusts/core/index.js";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve21 } from "path";
 var newCommand = {
   name: "new",
   aliases: ["n"],
@@ -2874,48 +3326,52 @@ var newCommand = {
   async run(ctx) {
     const name = ctx.positional[0];
     if (!name) {
-      logger19.error("Usage: nx new <project-name>");
+      logger.error("Usage: nx new <project-name>");
       return 1;
     }
-    const interactive = !flagBool5(ctx.flags, "no-interaction", false);
-    const target = resolve19(ctx.cwd, name);
-    if (existsSync4(target)) {
-      logger19.error(`Directory already exists: ${target}`);
+    const interactive = !flagBool(ctx.flags, "no-interaction", false);
+    const target = resolve21(ctx.cwd, name);
+    if (existsSync6(target)) {
+      logger.error(`Directory already exists: ${target}`);
       return 1;
     }
-    const routing = ctx.flags["style"] ?? await select2("Routing style", ["nest", "adonis", "functional"], {
+    const routing = ctx.flags["style"] ?? await select("Routing style", ["nest", "adonis", "functional"], {
       interactive,
       default: "nest"
     });
-    const view = ctx.flags["view"] ?? await select2("View engine", ["rendu", "edge", "eta", "inertia", "none"], {
+    const view = ctx.flags["view"] ?? await select("View engine", ["rendu", "edge", "eta", "inertia", "none"], {
       interactive,
       default: "rendu"
     });
-    const orm = ctx.flags["orm"] ?? await select2("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
+    const orm = ctx.flags["orm"] ?? await select("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
       interactive,
       default: "drizzle"
     });
-    const db = ctx.flags["db"] ?? await select2("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], {
+    const db = ctx.flags["db"] ?? await select("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], {
       interactive,
       default: "bun-sqlite"
     });
-    const frontend = ctx.flags["frontend"] ?? await select2("Inertia frontend", ["react", "vue", "svelte", "solid"], {
+    const frontend = ctx.flags["frontend"] ?? await select("Inertia frontend", ["react", "vue", "svelte", "solid"], {
       interactive,
       default: "react"
     });
-    const ssr = !flagBool5(ctx.flags, "no-ssr", false);
-    mkdirSync3(resolve19(target, "app"), { recursive: true });
-    mkdirSync3(resolve19(target, "public"), { recursive: true });
-    mkdirSync3(resolve19(target, "resources/views"), { recursive: true });
-    writeFileSync2(resolve19(target, "public/.gitkeep"), "");
-    writeFileSync2(resolve19(target, "resources/views/welcome.html"), `<h1>Welcome to ${name}</h1>
+    const ssr = !flagBool(ctx.flags, "no-ssr", false);
+    mkdirSync4(resolve21(target, "app"), { recursive: true });
+    if (view !== "none") {
+      mkdirSync4(resolve21(target, "resources/views"), { recursive: true });
+    }
+    mkdirSync4(resolve21(target, "public"), { recursive: true });
+    writeFileSync3(resolve21(target, "public/.gitkeep"), "");
+    if (view !== "none") {
+      writeFileSync3(resolve21(target, "resources/views/welcome.html"), `<h1>Welcome to ${name}</h1>
 <p>This is a sample Rendu template.</p>
 <p>Founded <?= year ?>.</p>
 `);
-    writeFileSync2(resolve19(target, ".env"), generateEnvFile());
-    writeFileSync2(resolve19(target, ".env.local"), generateEnvLocalFile());
-    writeFileSync2(resolve19(target, ".gitignore"), generateGitIgnore());
-    const code = render15(templates.project["nx.config.ts"], {
+    }
+    writeFileSync3(resolve21(target, ".env"), generateEnvFile());
+    writeFileSync3(resolve21(target, ".env.local"), generateEnvLocalFile());
+    writeFileSync3(resolve21(target, ".gitignore"), generateGitIgnore());
+    const code = render(templates.project["nx.config.ts"], {
       routing,
       view,
       viewPaths: view === "none" ? "" : "resources/views",
@@ -2926,8 +3382,21 @@ var newCommand = {
       inertiaSSR: ssr,
       inertiaVersion: "1.0.0"
     });
-    writeFileSync2(resolve19(target, "nx.config.ts"), code);
-    writeFileSync2(resolve19(target, "package.json"), JSON.stringify({
+    writeFileSync3(resolve21(target, "nx.config.ts"), code);
+    const deps = {
+      "@nexusts/core": "*",
+      "reflect-metadata": "^0.2.2",
+      hono: "^4.6.0",
+      zod: "^3.23.8"
+    };
+    if (orm === "drizzle") {
+      deps["@nexusts/drizzle"] = "*";
+      deps["drizzle-orm"] = "^0.45.0";
+    }
+    if (view !== "none") {
+      deps["@nexusts/static"] = "*";
+    }
+    writeFileSync3(resolve21(target, "package.json"), JSON.stringify({
       name,
       version: "0.1.0",
       type: "module",
@@ -2938,14 +3407,9 @@ var newCommand = {
         test: "vitest",
         nx: "nx"
       },
-      dependencies: {
-        "@nexusts/core": "*",
-        "reflect-metadata": "^0.2.2",
-        hono: "^4.6.0",
-        zod: "^3.23.8"
-      }
+      dependencies: deps
     }, null, 2));
-    writeFileSync2(resolve19(target, "tsconfig.json"), `{
+    writeFileSync3(resolve21(target, "tsconfig.json"), `{
   "compilerOptions": {
     "target": "ES2022",
     "module": "ESNext",
@@ -2960,43 +3424,59 @@ var newCommand = {
   "include": ["app/**/*.ts", "nx.config.ts"]
 }
 `);
-    writeFileSync2(resolve19(target, "app/main.ts"), `import 'reflect-metadata';
+    const hasView = view !== "none";
+    const staticImport = hasView ? `import { StaticModule } from '@nexusts/static';
+const staticMiddleware = StaticModule.mount({ root: './public', prefix: '/static' });
+` : "";
+    const staticOption = hasView ? `
+  middleware: [staticMiddleware],` : "";
+    writeFileSync3(resolve21(target, "app/main.ts"), `import 'reflect-metadata';
 import { Application } from '@nexusts/core';
-import { StaticModule } from '@nexusts/static';
-import { AppModule } from './app.module.js';
+${staticImport}import { AppModule } from './app.module.js';
 
-const app = new Application(AppModule);
-// Serve ./public files under /static/*
-app.server.app.use('/static/*', StaticModule.mount({ root: './public', prefix: '/static' }));
+const app = new Application(AppModule, {
+  logging: true,
+  port: Number(process.env['PORT'] ?? 3000),${staticOption}
+});
 
-const port = Number(process.env["PORT"] ?? 3000);
-await app.listen(port);
-console.log("[nexusjs] Listening on http://localhost:" + port);
+await app.listen();
+console.log('[nexus] Listening on http://localhost:' + (process.env['PORT'] ?? 3000));
 `);
-    writeFileSync2(resolve19(target, "app/app.module.ts"), `import { Module } from '@nexusts/core';
+    const ormImport = orm === "drizzle" ? `import { DrizzleModule } from '@nexusts/drizzle';
+` : "";
+    const forRootDialect = db === "bun-sqlite" ? "bun-sqlite" : "sqlite";
+    const ormBlock = orm === "drizzle" ? `    DrizzleModule.forRoot({
+      dialect: '${forRootDialect}',
+      connection: { filename: 'app.db' },
+      logging: true,
+    })` : "";
+    writeFileSync3(resolve21(target, "app/app.module.ts"), `${ormImport}import { Module } from '@nexusts/core';
 import { HomeController } from './controllers/home.controller.js';
 
 @Module({
-  imports: [],
+  imports: [${orm === "drizzle" ? `
+${ormBlock},
+` : ""}  ],
   controllers: [HomeController],
 })
 export class AppModule {}
 `);
-    mkdirSync3(resolve19(target, "app/controllers"), { recursive: true });
-    writeFileSync2(resolve19(target, "app/controllers/home.controller.ts"), `import { Controller, Get } from '@nexusts/core';
+    mkdirSync4(resolve21(target, "app/controllers"), { recursive: true });
+    const homeViewReturn = view !== "none" ? `{
+      view: 'welcome.html',
+      data: { year: new Date().getFullYear() },
+    }` : `{ status: 200, body: { message: 'Hello from NexusTS!' } }`;
+    writeFileSync3(resolve21(target, "app/controllers/home.controller.ts"), `import { Controller, Get } from '@nexusts/core';
 
 @Controller('/')
 export class HomeController {
   @Get('/')
   index() {
-    return {
-      view: 'welcome.html',
-      data: { year: new Date().getFullYear() },
-    };
+    return ${homeViewReturn};
   }
 }
 `);
-    writeFileSync2(resolve19(target, "README.md"), `# ${name}
+    writeFileSync3(resolve21(target, "README.md"), `# ${name}
 
 A new Nexus project.
 
@@ -3013,13 +3493,13 @@ bun run dev
 bunx nx make:crud Post
 \`\`\`
 `);
-    logger19.success(`created ${target}`);
-    logger19.blank();
-    logger19.heading("Next steps");
-    logger19.info(`  cd ${name}`);
-    logger19.info(`  bun install`);
-    logger19.info(`  bun run dev`);
-    logger19.blank();
+    logger.success(`created ${target}`);
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info(`  cd ${name}`);
+    logger.info(`  bun install`);
+    logger.info(`  bun run dev`);
+    logger.blank();
     return 0;
   }
 };
@@ -3077,9 +3557,8 @@ dist/
 var new_default = newCommand;
 
 // packages/cli/src/commands/config.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve20 } from "path";
-import { flagBool as flagBool6, logger as logger20, render as render16, select as select3 } from "@nexusts/core/index.js";
+import { existsSync as existsSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve22 } from "path";
 var DEFAULT_VALUES = {
   routing: "nest",
   view: "rendu",
@@ -3093,9 +3572,9 @@ var DEFAULT_VALUES = {
 };
 function parseExistingConfig(path) {
   const out = { ...DEFAULT_VALUES };
-  if (!existsSync5(path))
+  if (!existsSync7(path))
     return out;
-  const src = readFileSync2(path, "utf8");
+  const src = readFileSync4(path, "utf8");
   const grab = (re) => {
     const m = src.match(re);
     return m?.[1];
@@ -3192,17 +3671,17 @@ var configCommand = {
     { name: "no-interaction", description: "Disable interactive prompts" }
   ],
   async run(ctx) {
-    const interactive = !flagBool6(ctx.flags, "no-interaction", false);
-    const force = flagBool6(ctx.flags, "force", false);
-    const target = resolve20(ctx.cwd, ctx.flags["target"] ?? ".");
-    if (!existsSync5(target)) {
-      logger20.error(`Target directory does not exist: ${target}`);
+    const interactive = !flagBool(ctx.flags, "no-interaction", false);
+    const force = flagBool(ctx.flags, "force", false);
+    const target = resolve22(ctx.cwd, ctx.flags["target"] ?? ".");
+    if (!existsSync7(target)) {
+      logger.error(`Target directory does not exist: ${target}`);
       return 1;
     }
-    const nxConfigPath = resolve20(target, "nx.config.ts");
+    const nxConfigPath = resolve22(target, "nx.config.ts");
     const values = parseExistingConfig(nxConfigPath);
     const flag = (k) => ctx.flags[k];
-    const flagBoolStrict = (k, def) => flagBool6(ctx.flags, k, def);
+    const flagBoolStrict = (k, def) => flagBool(ctx.flags, k, def);
     if (flag("style"))
       values.routing = flag("style");
     if (flag("view"))
@@ -3223,84 +3702,83 @@ var configCommand = {
     if (flagBoolStrict("no-ssr", false))
       values.inertiaSSR = false;
     const anyFlag = Object.values(ctx.flags).some((v) => v !== undefined && v !== false);
-    if (interactive && !anyFlag && !existsSync5(nxConfigPath)) {
-      values.routing = await select3("Routing style", ["nest", "adonis", "functional"], {
+    if (interactive && !anyFlag && !existsSync7(nxConfigPath)) {
+      values.routing = await select("Routing style", ["nest", "adonis", "functional"], {
         interactive,
         default: values.routing
       }) ?? values.routing;
-      values.view = await select3("View engine", ["inertia", "rendu", "edge", "none"], {
+      values.view = await select("View engine", ["inertia", "rendu", "edge", "none"], {
         interactive,
         default: values.view
       }) ?? values.view;
-      values.orm = await select3("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
+      values.orm = await select("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
         interactive,
         default: values.orm
       }) ?? values.orm;
-      values.dbDriver = await select3("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], { interactive, default: values.dbDriver }) ?? values.dbDriver;
-      values.inertiaFrontend = await select3("Inertia frontend", ["react", "vue", "svelte", "solid"], { interactive, default: values.inertiaFrontend }) ?? values.inertiaFrontend;
+      values.dbDriver = await select("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], { interactive, default: values.dbDriver }) ?? values.dbDriver;
+      values.inertiaFrontend = await select("Inertia frontend", ["react", "vue", "svelte", "solid"], { interactive, default: values.inertiaFrontend }) ?? values.inertiaFrontend;
     }
     if (flag("db-url") === undefined && flag("db") !== undefined) {
       values.dbUrl = defaultDbUrl(values.dbDriver);
     }
-    const existed = existsSync5(nxConfigPath);
+    const existed = existsSync7(nxConfigPath);
     if (existed && !force) {
       if (anyFlag) {
         writeNxConfig(target, values);
-        logger20.info(`  ~ nx.config.ts (updated)`);
+        logger.info(`  ~ nx.config.ts (updated)`);
       } else {
-        logger20.info(`  - nx.config.ts (unchanged; pass --force or a flag to update)`);
+        logger.info(`  - nx.config.ts (unchanged; pass --force or a flag to update)`);
       }
     } else {
       writeNxConfig(target, values);
-      logger20.info(`  + nx.config.ts`);
+      logger.info(`  + nx.config.ts`);
     }
-    const drizzleConfigPath = resolve20(target, "drizzle.config.ts");
+    const drizzleConfigPath = resolve22(target, "drizzle.config.ts");
     if (values.orm === "drizzle") {
       const dialect = driverToDialect(values.dbDriver);
       const dbUrl = values.dbUrl;
-      const existedDrizzle = existsSync5(drizzleConfigPath);
+      const existedDrizzle = existsSync7(drizzleConfigPath);
       if (existedDrizzle && !force && !anyFlag) {
-        logger20.info(`  - drizzle.config.ts (unchanged; pass --force or a flag to update)`);
+        logger.info(`  - drizzle.config.ts (unchanged; pass --force or a flag to update)`);
       } else {
         writeDrizzleConfig(target, { dialect, dbUrl });
-        logger20.info(`  ${existedDrizzle ? "~" : "+"} drizzle.config.ts`);
+        logger.info(`  ${existedDrizzle ? "~" : "+"} drizzle.config.ts`);
       }
-    } else if (existsSync5(drizzleConfigPath)) {
-      logger20.info(`  - drizzle.config.ts (left as-is; ORM is '${values.orm}', not 'drizzle')`);
+    } else if (existsSync7(drizzleConfigPath)) {
+      logger.info(`  - drizzle.config.ts (left as-is; ORM is '${values.orm}', not 'drizzle')`);
     }
-    logger20.blank();
-    logger20.success(`config updated in ${target}`);
-    logger20.blank();
-    logger20.heading("Next steps");
-    logger20.info(`  cd ${target === ctx.cwd ? "." : target}`);
+    logger.blank();
+    logger.success(`config updated in ${target}`);
+    logger.blank();
+    logger.heading("Next steps");
+    logger.info(`  cd ${target === ctx.cwd ? "." : target}`);
     if (values.orm === "drizzle") {
-      logger20.info(`  bun run db:generate    # generate migrations`);
+      logger.info(`  bun run db:generate    # generate migrations`);
     }
-    logger20.blank();
+    logger.blank();
     return 0;
   }
 };
 function writeNxConfig(target, values) {
-  const code = render16(templates.project["nx.config.ts"], values);
-  writeFileSync3(resolve20(target, "nx.config.ts"), code);
+  const code = render(templates.project["nx.config.ts"], values);
+  writeFileSync4(resolve22(target, "nx.config.ts"), code);
 }
 function writeDrizzleConfig(target, values) {
-  const code = render16(templates.project["drizzle.config.ts"], values);
-  writeFileSync3(resolve20(target, "drizzle.config.ts"), code);
+  const code = render(templates.project["drizzle.config.ts"], values);
+  writeFileSync4(resolve22(target, "drizzle.config.ts"), code);
 }
 var config_default = configCommand;
 
 // packages/cli/src/commands/repl.ts
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
-  writeFileSync as writeFileSync4
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { dirname as dirname2, resolve as resolve21 } from "path";
+import { dirname as dirname3, resolve as resolve23 } from "path";
 import * as readline from "readline";
 import * as vm from "vm";
-import { logger as logger21 } from "@nexusts/core/index.js";
 var BANNER = `
 \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E
 \u2502  NexusTS REPL                                    \u2502
@@ -3366,32 +3844,32 @@ var replCommand = {
   async run(ctx) {
     const mod = ctx.flags["module"];
     const noBoot = Boolean(ctx.flags["no-boot"]);
-    const histPath = resolve21(ctx.cwd, ctx.flags["history"] ?? ".nx-repl-history");
+    const histPath = resolve23(ctx.cwd, ctx.flags["history"] ?? ".nx-repl-history");
     const env = { console };
     if (!noBoot) {
-      const modPath = resolve21(ctx.cwd, mod ?? "app/app.module.ts");
-      if (!existsSync6(modPath)) {
-        logger21.error(`module not found: ${modPath}`);
-        logger21.info("pass --module <path> or --no-boot to skip booting");
+      const modPath = resolve23(ctx.cwd, mod ?? "app/app.module.ts");
+      if (!existsSync8(modPath)) {
+        logger.error(`module not found: ${modPath}`);
+        logger.info("pass --module <path> or --no-boot to skip booting");
         return 1;
       }
       try {
         const modSpec = await import(modPath);
         const AppModule = modSpec.default ?? modSpec.AppModule;
         if (!AppModule) {
-          logger21.error(`module at ${modPath} does not export AppModule as default or named export`);
+          logger.error(`module at ${modPath} does not export AppModule as default or named export`);
           return 1;
         }
-        const { Application } = await import("@nexusts/core/src/application.js");
+        const { Application } = await import("@nexusts/core");
         const app = new Application(AppModule);
         env.app = app;
         env.container = app.container;
         for (const [name, path, className] of PRELOAD) {
           await preloadService(env, app, name, path, className);
         }
-        logger21.info(`\u2713 Booted ${modPath}`);
+        logger.info(`\u2713 Booted ${modPath}`);
       } catch (err) {
-        logger21.error(`failed to boot: ${err.message}`);
+        logger.error(`failed to boot: ${err.message}`);
         return 1;
       }
     }
@@ -3487,580 +3965,301 @@ var replCommand = {
           }
           return true;
         }
-        case ".history": {
-          const hist = rl.history ?? [];
-          const histArr = hist;
-          histArr.forEach((h, i) => {
-            console.log(`  ${(i + 1).toString().padStart(4)}: ${h}`);
-          });
-          return true;
-        }
-        case ".reset": {
-          for (const k of Object.keys(env)) {
-            if (k !== "console")
-              delete env[k];
-          }
-          console.log("  context reset");
-          return true;
-        }
-        default:
-          console.error(`  unknown command: ${cmd}`);
-          console.log("  type .help for the list");
-          return true;
-      }
-    };
-    rl.on("line", async (line) => {
-      const trimmed = line.trim();
-      if (trimmed.startsWith(".")) {
-        await handleDotCommand(trimmed);
-      } else {
-        buffer += line + `
-`;
-        if (isIncomplete(buffer)) {
-          rl.setPrompt("... ");
-          rl.prompt();
-          return;
-        }
-        await evaluate(buffer);
-        buffer = "";
-        rl.setPrompt("\u276F ");
-      }
-      rl.prompt();
-    });
-    rl.prompt();
-    return new Promise(() => {});
-  }
-};
-async function preloadService(env, app, name, path, className) {
-  try {
-    const mod = await import(path);
-    const ServiceClass = mod[className];
-    if (!ServiceClass)
-      return;
-    const Token = ServiceClass.TOKEN ?? ServiceClass[`${className.toUpperCase()}_TOKEN`];
-    if (!Token)
-      return;
-    try {
-      env[name] = app.container.resolve(Token);
-    } catch {
-      try {
-        env[name] = app.container.resolve(ServiceClass);
-      } catch {}
-    }
-  } catch {}
-}
-function listServices(container) {
-  if (!container)
-    return [];
-  const c = container;
-  if (typeof c.listProviders !== "function")
-    return [];
-  try {
-    return c.listProviders().map((p) => p.token?.toString?.() ?? String(p.token));
-  } catch {
-    return [];
-  }
-}
-function isIncomplete(code) {
-  const stack = [];
-  let inString = null;
-  let inComment = null;
-  for (let i = 0;i < code.length; i++) {
-    const c = code[i];
-    const next = code[i + 1];
-    if (inComment === "line") {
-      if (c === `
-`)
-        inComment = null;
-      continue;
-    }
-    if (inComment === "block") {
-      if (c === "*" && next === "/") {
-        inComment = null;
-        i++;
-      }
-      continue;
-    }
-    if (inString) {
-      if (c === "\\") {
-        i++;
-        continue;
-      }
-      if (c === inString)
-        inString = null;
-      continue;
-    }
-    if (c === "/" && next === "/") {
-      inComment = "line";
-      i++;
-      continue;
-    }
-    if (c === "/" && next === "*") {
-      inComment = "block";
-      i++;
-      continue;
-    }
-    if (c === '"' || c === "'" || c === "`") {
-      inString = c;
-      continue;
-    }
-    if (c === "{" || c === "[" || c === "(")
-      stack.push(c);
-    else if (c === "}" || c === "]" || c === ")")
-      stack.pop();
-  }
-  return stack.length > 0 || inString !== null || inComment === "block";
-}
-function formatResult(r) {
-  if (r === null)
-    return "null";
-  if (r === undefined)
-    return "undefined";
-  if (typeof r === "string")
-    return r;
-  if (typeof r === "number" || typeof r === "boolean" || typeof r === "bigint")
-    return String(r);
-  if (typeof r === "function") {
-    const fn = r;
-    return `[Function: ${fn.name || "anonymous"}]`;
-  }
-  if (typeof r === "symbol")
-    return r.toString();
-  try {
-    return JSON.stringify(r, null, 2);
-  } catch {
-    return Object.prototype.toString.call(r);
-  }
-}
-function formatError(e) {
-  if (e.name === "SyntaxError")
-    return e.message;
-  return e.stack ? e.stack.split(`
-`).slice(0, 5).join(`
-`) : e.message;
-}
-function loadHistory(path) {
-  if (!existsSync6(path))
-    return [];
-  try {
-    return readFileSync3(path, "utf-8").split(`
-`).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-function saveHistoryFile(path, history) {
-  try {
-    const dir = dirname2(path);
-    if (!existsSync6(dir))
-      mkdirSync4(dir, { recursive: true });
-    writeFileSync4(path, history.slice(-1000).join(`
-`));
-  } catch {}
-}
-var repl_default = replCommand;
-
-// packages/cli/src/commands/route-list.ts
-import { readdirSync, statSync } from "fs";
-import { resolve as resolve22 } from "path";
-import { colors as colors2, logger as logger22 } from "@nexusts/core/index.js";
-var routeListCommand = {
-  name: "route:list",
-  aliases: ["routes", "route-list"],
-  summary: "List registered HTTP routes",
-  description: "Reads route metadata from controllers and prints a table. Falls back to a scan message when controllers don't use the decorator style.",
-  flags: [
-    { name: "format", description: "Output format: table (default) | json" }
-  ],
-  async run(ctx) {
-    const controllersDir = resolve22(ctx.cwd, ctx.config.paths.controllers);
-    try {
-      statSync(controllersDir);
-    } catch {
-      logger22.warn(`No controllers directory at ${controllersDir}.`);
-      return 0;
-    }
-    const files = readdirSync(controllersDir).filter((f) => f.endsWith(".ts"));
-    if (files.length === 0) {
-      logger22.info("No controllers found.");
-      return 0;
-    }
-    const routes = [];
-    for (const file of files) {
-      const fullPath = resolve22(controllersDir, file);
-      try {
-        const mod = await import(`${fullPath}?t=${Date.now()}`);
-        for (const exportName of Object.keys(mod)) {
-          const cls = mod[exportName];
-          if (typeof cls !== "function")
-            continue;
-          const prefix = Reflect.getMetadata("nexus:controller:prefix", cls) ?? "";
-          const routeList = Reflect.getMetadata("nexus:routes", cls) ?? [];
-          for (const r of routeList) {
-            routes.push({
-              method: String(r.method).toUpperCase(),
-              path: joinPath(prefix, r.path),
-              handler: String(r.propertyKey),
-              controller: cls.name || exportName
-            });
+        case ".history": {
+          const hist = rl.history ?? [];
+          const histArr = hist;
+          histArr.forEach((h, i) => {
+            console.log(`  ${(i + 1).toString().padStart(4)}: ${h}`);
+          });
+          return true;
+        }
+        case ".reset": {
+          for (const k of Object.keys(env)) {
+            if (k !== "console")
+              delete env[k];
           }
+          console.log("  context reset");
+          return true;
         }
-      } catch (err) {
-        logger22.warn(`could not parse ${file}: ${err.message ?? err}`);
+        default:
+          console.error(`  unknown command: ${cmd}`);
+          console.log("  type .help for the list");
+          return true;
       }
-    }
-    if (routes.length === 0) {
-      logger22.info("No routes discovered via metadata. " + "This usually means the controllers use the Adonis or functional style \u2014 see nx.config.ts:routing.");
-      return 0;
-    }
-    const format = ctx.flags["format"] ?? "table";
-    if (format === "json") {
-      console.log(JSON.stringify(routes, null, 2));
-      return 0;
-    }
-    routes.sort((a, b) => a.path.localeCompare(b.path));
-    logger22.heading(`Routes (${routes.length})`);
-    const methodColors = {
-      GET: colors2.cyan,
-      POST: colors2.green,
-      PUT: colors2.yellow,
-      PATCH: colors2.yellow,
-      DELETE: colors2.red,
-      OPTIONS: colors2.gray,
-      HEAD: colors2.gray
     };
-    const pathWidth = Math.max(...routes.map((r) => r.path.length));
-    const methodWidth = Math.max(...routes.map((r) => r.method.length));
-    for (const r of routes) {
-      const colorize = methodColors[r.method] ?? colors2.reset;
-      const m = colorize(r.method.padEnd(methodWidth));
-      const p = colors2.bold(r.path.padEnd(pathWidth));
-      const c = colors2.dim(`${r.controller}.${r.handler}`);
-      console.log(`  ${m}  ${p}  ${c}`);
-    }
-    logger22.blank();
-    return 0;
-  }
-};
-function joinPath(prefix, sub) {
-  const a = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-  const b = sub.startsWith("/") ? sub : `/${sub}`;
-  return `${a}${b}` || "/";
-}
-var route_list_default = routeListCommand;
-
-// packages/cli/src/commands/index.ts
-var commands = [
-  new_default,
-  init_default,
-  config_default,
-  make_crud_default,
-  make_controller_default,
-  make_service_default,
-  make_module_default,
-  make_model_default,
-  make_migration_default,
-  make_middleware_default,
-  make_validator_default,
-  make_auth_default,
-  make_queue_default,
-  make_schedule_default,
-  make_listener_default,
-  make_session_default,
-  db_migrate_default,
-  db_generate_default,
-  db_seed_default,
-  route_list_default,
-  info_default,
-  repl_default
-];
-function findCommand(name) {
-  return commands.find((c) => c.name === name || (c.aliases ?? []).includes(name));
-}
-
-// packages/cli/src/core/config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve23 } from "path";
-var DEFAULT_CONFIG = {
-  routing: "nest",
-  view: "inertia",
-  orm: "drizzle",
-  database: {
-    driver: "bun-sqlite",
-    url: "app.db"
-  },
-  inertia: {
-    frontend: "react",
-    ssr: true,
-    version: "1.0.0"
-  },
-  paths: {
-    app: "app",
-    controllers: "app/controllers",
-    services: "app/services",
-    modules: "app/modules",
-    models: "app/models",
-    migrations: "app/database/migrations",
-    seeds: "db/seeds",
-    middleware: "app/middleware",
-    dto: "app/dto"
-  },
-  moduleStyle: "nest",
-  auth: undefined,
-  queue: undefined
-};
-var CONFIG_CANDIDATES = [
-  "nx.config.ts",
-  "nx.config.js",
-  "nx.config.mjs",
-  ".nxrc.json"
-];
-async function loadConfig(cwd = process.cwd()) {
-  let config = {};
-  let configSource = "<defaults>";
-  for (const candidate of CONFIG_CANDIDATES) {
-    const path = resolve23(cwd, candidate);
-    if (!existsSync7(path))
-      continue;
-    try {
-      if (candidate.endsWith(".json")) {
-        const raw = readFileSync4(path, "utf8");
-        config = JSON.parse(raw);
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith(".")) {
+        await handleDotCommand(trimmed);
       } else {
-        try {
-          const mod = await import(path);
-          config = mod.default ?? mod;
-        } catch (importErr) {
-          console.warn(`[nx] Could not dynamically import ${candidate}: ${importErr.message ?? importErr}. Falling back to defaults.`);
-          config = {};
+        buffer += line + `
+`;
+        if (isIncomplete(buffer)) {
+          rl.setPrompt("... ");
+          rl.prompt();
+          return;
         }
+        await evaluate(buffer);
+        buffer = "";
+        rl.setPrompt("\u276F ");
       }
-      configSource = candidate;
-      break;
-    } catch (err) {
-      throw new Error(`Failed to load ${candidate}: ${err.message ?? String(err)}`);
-    }
-  }
-  const merged = mergeWithEnv(DEFAULT_CONFIG, config);
-  assertEnum("routing", merged.routing, [
-    "nest",
-    "adonis",
-    "functional",
-    "mixed"
-  ]);
-  assertEnum("view", merged.view, ["rendu", "edge", "inertia", "none"]);
-  assertEnum("orm", merged.orm, ["drizzle", "prisma", "kysely", "none"]);
-  assertEnum("database.driver", merged.database.driver, [
-    "bun-sqlite",
-    "node-sqlite",
-    "libsql",
-    "postgres",
-    "mysql",
-    "none"
-  ]);
-  assertEnum("inertia.frontend", merged.inertia.frontend, [
-    "react",
-    "vue",
-    "svelte",
-    "solid"
-  ]);
-  if (process.env["NX_DEBUG"] === "1") {
-    console.log(`[nx] config source: ${configSource}`);
+      rl.prompt();
+    });
+    rl.prompt();
+    return new Promise(() => {});
   }
-  return merged;
-}
-function mergeWithEnv(base, override) {
-  const env = process.env;
-  const merged = {
-    ...base,
-    ...override,
-    database: { ...base.database, ...override.database ?? {} },
-    inertia: { ...base.inertia, ...override.inertia ?? {} },
-    paths: { ...base.paths, ...override.paths ?? {} }
-  };
-  if (env["NX_ROUTING"])
-    merged.routing = env["NX_ROUTING"];
-  if (env["NX_VIEW"])
-    merged.view = env["NX_VIEW"];
-  if (env["NX_ORM"])
-    merged.orm = env["NX_ORM"];
-  if (env["NX_DATABASE_DRIVER"])
-    merged.database.driver = env["NX_DATABASE_DRIVER"];
-  if (env["NX_DATABASE_URL"])
-    merged.database.url = env["NX_DATABASE_URL"];
-  if (env["NX_INERTIA_FRONTEND"])
-    merged.inertia.frontend = env["NX_INERTIA_FRONTEND"];
-  if (env["NX_INERTIA_SSR"])
-    merged.inertia.ssr = env["NX_INERTIA_SSR"] !== "false" && env["NX_INERTIA_SSR"] !== "0";
-  if (env["NX_INERTIA_VERSION"])
-    merged.inertia.version = env["NX_INERTIA_VERSION"];
-  return merged;
+};
+async function preloadService(env, app, name, path, className) {
+  try {
+    const mod = await import(path);
+    const ServiceClass = mod[className];
+    if (!ServiceClass)
+      return;
+    const Token = ServiceClass.TOKEN ?? ServiceClass[`${className.toUpperCase()}_TOKEN`];
+    if (!Token)
+      return;
+    try {
+      env[name] = app.container.resolve(Token);
+    } catch {
+      try {
+        env[name] = app.container.resolve(ServiceClass);
+      } catch {}
+    }
+  } catch {}
 }
-function assertEnum(key, value, allowed) {
-  if (!allowed.includes(value)) {
-    throw new Error(`Invalid value for ${key}: "${value}". Allowed: ${allowed.join(", ")}.`);
+function listServices(container) {
+  if (!container)
+    return [];
+  const c2 = container;
+  if (typeof c2.listProviders !== "function")
+    return [];
+  try {
+    return c2.listProviders().map((p) => p.token?.toString?.() ?? String(p.token));
+  } catch {
+    return [];
   }
 }
-
-// packages/cli/src/core/args.ts
-var LONG_RE = /^--([^=]+)(?:=(.*))?$/;
-var SHORT_RE = /^-([A-Za-z])$/;
-function parseArgs(argv) {
-  const positional = [];
-  const flags = {};
-  let endOfOptions = false;
-  let i = 0;
-  while (i < argv.length) {
-    const arg = argv[i];
-    if (arg === "--") {
-      endOfOptions = true;
-      i++;
+function isIncomplete(code) {
+  const stack = [];
+  let inString = null;
+  let inComment = null;
+  for (let i = 0;i < code.length; i++) {
+    const c2 = code[i];
+    const next = code[i + 1];
+    if (inComment === "line") {
+      if (c2 === `
+`)
+        inComment = null;
       continue;
     }
-    if (endOfOptions || !arg.startsWith("-")) {
-      positional.push(arg);
-      i++;
+    if (inComment === "block") {
+      if (c2 === "*" && next === "/") {
+        inComment = null;
+        i++;
+      }
       continue;
     }
-    const longMatch = LONG_RE.exec(arg);
-    if (longMatch) {
-      const [, name, inline] = longMatch;
-      const flagName = name;
-      if (inline !== undefined) {
-        setFlag(flags, flagName, inline);
+    if (inString) {
+      if (c2 === "\\") {
         i++;
         continue;
       }
-      const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith("-")) {
-        setFlag(flags, flagName, next);
-        i += 2;
-      } else {
-        setFlag(flags, flagName, true);
-        i++;
-      }
+      if (c2 === inString)
+        inString = null;
       continue;
     }
-    const shortMatch = SHORT_RE.exec(arg);
-    if (shortMatch) {
-      const flagName = shortMatch[1];
-      const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith("-")) {
-        setFlag(flags, flagName, next);
-        i += 2;
-      } else {
-        setFlag(flags, flagName, true);
-        i++;
-      }
+    if (c2 === "/" && next === "/") {
+      inComment = "line";
+      i++;
       continue;
     }
-    positional.push(arg);
-    i++;
+    if (c2 === "/" && next === "*") {
+      inComment = "block";
+      i++;
+      continue;
+    }
+    if (c2 === '"' || c2 === "'" || c2 === "`") {
+      inString = c2;
+      continue;
+    }
+    if (c2 === "{" || c2 === "[" || c2 === "(")
+      stack.push(c2);
+    else if (c2 === "}" || c2 === "]" || c2 === ")")
+      stack.pop();
   }
-  const command = positional.shift();
-  return { command, positional, flags };
+  return stack.length > 0 || inString !== null || inComment === "block";
 }
-function setFlag(flags, name, value) {
-  if (name.startsWith("no-") && value === true) {
-    const key = name.slice(3);
-    flags[key] = false;
-    return;
+function formatResult(r) {
+  if (r === null)
+    return "null";
+  if (r === undefined)
+    return "undefined";
+  if (typeof r === "string")
+    return r;
+  if (typeof r === "number" || typeof r === "boolean" || typeof r === "bigint")
+    return String(r);
+  if (typeof r === "function") {
+    const fn = r;
+    return `[Function: ${fn.name || "anonymous"}]`;
   }
-  const existing = flags[name];
-  if (existing === undefined) {
-    flags[name] = value;
-  } else if (Array.isArray(existing)) {
-    existing.push(typeof value === "string" ? value : String(value));
-  } else {
-    flags[name] = [
-      String(existing),
-      typeof value === "string" ? value : String(value)
-    ];
+  if (typeof r === "symbol")
+    return r.toString();
+  try {
+    return JSON.stringify(r, null, 2);
+  } catch {
+    return Object.prototype.toString.call(r);
   }
 }
-function flagBool7(flags, name, fallback = false) {
-  const v = flags[name];
-  if (v === undefined)
-    return fallback;
-  if (typeof v === "boolean")
-    return v;
-  return v !== "false" && v !== "0" && v !== "no";
+function formatError(e) {
+  if (e.name === "SyntaxError")
+    return e.message;
+  return e.stack ? e.stack.split(`
+`).slice(0, 5).join(`
+`) : e.message;
 }
-// packages/cli/src/core/logger.ts
-var USE_COLOR = process.env["NO_COLOR"] === undefined && process.env["FORCE_COLOR"] !== "0" && process.stdout.isTTY === true;
-var wrap = (open, close) => (s) => USE_COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
-var c = {
-  reset: wrap(0, 0),
-  bold: wrap(1, 22),
-  dim: wrap(2, 22),
-  red: wrap(31, 39),
-  green: wrap(32, 39),
-  yellow: wrap(33, 39),
-  blue: wrap(34, 39),
-  magenta: wrap(35, 39),
-  cyan: wrap(36, 39),
-  gray: wrap(90, 39)
-};
-var PREFIXES = {
-  info: `${c.cyan("\u2139")}`,
-  success: `${c.green("\u2714")}`,
-  warn: `${c.yellow("\u26A0")}`,
-  error: `${c.red("\u2716")}`,
-  debug: `${c.gray("\xB7")}`,
-  finger: `${c.magenta("\u279C")}`
-};
-
-class Logger {
-  verbose = false;
-  setVerbose(v) {
-    this.verbose = v;
-  }
-  info(message) {
-    console.log(`${PREFIXES.info}  ${message}`);
-  }
-  success(message) {
-    console.log(`${PREFIXES.success}  ${message}`);
-  }
-  warn(message) {
-    console.warn(`${PREFIXES.warn}  ${c.yellow(message)}`);
-  }
-  error(message) {
-    console.error(`${PREFIXES.error}  ${c.red(message)}`);
-  }
-  debug(message) {
-    if (!this.verbose)
-      return;
-    console.log(`${PREFIXES.debug}  ${c.gray(message)}`);
-  }
-  finger(message) {
-    console.log(`${PREFIXES.finger}  ${c.magenta(message)}`);
+function loadHistory(path) {
+  if (!existsSync8(path))
+    return [];
+  try {
+    return readFileSync5(path, "utf-8").split(`
+`).filter(Boolean);
+  } catch {
+    return [];
   }
-  table(rows) {
-    const labelWidth = Math.max(...rows.map(([l]) => l.length));
-    for (const [label, value] of rows) {
-      const padded = label.padEnd(labelWidth);
-      console.log(`  ${c.dim(padded)}  ${value}`);
+}
+function saveHistoryFile(path, history) {
+  try {
+    const dir = dirname3(path);
+    if (!existsSync8(dir))
+      mkdirSync5(dir, { recursive: true });
+    writeFileSync5(path, history.slice(-1000).join(`
+`));
+  } catch {}
+}
+var repl_default = replCommand;
+
+// packages/cli/src/commands/route-list.ts
+import { readdirSync, statSync as statSync2 } from "fs";
+import { resolve as resolve24 } from "path";
+var routeListCommand = {
+  name: "route:list",
+  aliases: ["routes", "route-list"],
+  summary: "List registered HTTP routes",
+  description: "Reads route metadata from controllers and prints a table. Falls back to a scan message when controllers don't use the decorator style.",
+  flags: [
+    { name: "format", description: "Output format: table (default) | json" }
+  ],
+  async run(ctx) {
+    const controllersDir = resolve24(ctx.cwd, ctx.config.paths.controllers);
+    try {
+      statSync2(controllersDir);
+    } catch {
+      logger.warn(`No controllers directory at ${controllersDir}.`);
+      return 0;
     }
+    const files = readdirSync(controllersDir).filter((f) => f.endsWith(".ts"));
+    if (files.length === 0) {
+      logger.info("No controllers found.");
+      return 0;
+    }
+    const routes = [];
+    for (const file of files) {
+      const fullPath = resolve24(controllersDir, file);
+      try {
+        const mod = await import(`${fullPath}?t=${Date.now()}`);
+        for (const exportName of Object.keys(mod)) {
+          const cls = mod[exportName];
+          if (typeof cls !== "function")
+            continue;
+          const prefix = Reflect.getMetadata("nexus:controller:prefix", cls) ?? "";
+          const routeList = Reflect.getMetadata("nexus:routes", cls) ?? [];
+          for (const r of routeList) {
+            routes.push({
+              method: String(r.method).toUpperCase(),
+              path: joinPath(prefix, r.path),
+              handler: String(r.propertyKey),
+              controller: cls.name || exportName
+            });
+          }
+        }
+      } catch (err) {
+        logger.warn(`could not parse ${file}: ${err.message ?? err}`);
+      }
+    }
+    if (routes.length === 0) {
+      logger.info("No routes discovered via metadata. " + "This usually means the controllers use the Adonis or functional style \u2014 see nx.config.ts:routing.");
+      return 0;
+    }
+    const format = ctx.flags["format"] ?? "table";
+    if (format === "json") {
+      console.log(JSON.stringify(routes, null, 2));
+      return 0;
+    }
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    logger.heading(`Routes (${routes.length})`);
+    const methodColors = {
+      GET: colors.cyan,
+      POST: colors.green,
+      PUT: colors.yellow,
+      PATCH: colors.yellow,
+      DELETE: colors.red,
+      OPTIONS: colors.gray,
+      HEAD: colors.gray
+    };
+    const pathWidth = Math.max(...routes.map((r) => r.path.length));
+    const methodWidth = Math.max(...routes.map((r) => r.method.length));
+    for (const r of routes) {
+      const colorize = methodColors[r.method] ?? colors.reset;
+      const m = colorize(r.method.padEnd(methodWidth));
+      const p = colors.bold(r.path.padEnd(pathWidth));
+      const c2 = colors.dim(`${r.controller}.${r.handler}`);
+      console.log(`  ${m}  ${p}  ${c2}`);
+    }
+    logger.blank();
+    return 0;
   }
-  heading(text) {
-    const bar = "\u2500".repeat(text.length + 4);
-    console.log(`
-${c.bold(c.cyan(bar))}`);
-    console.log(`${c.bold(c.cyan(`  ${text}  `))}`);
-    console.log(`${c.bold(c.cyan(bar))}
-`);
-  }
-  blank() {
-    console.log("");
-  }
+};
+function joinPath(prefix, sub) {
+  const a = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const b = sub.startsWith("/") ? sub : `/${sub}`;
+  return `${a}${b}` || "/";
+}
+var route_list_default = routeListCommand;
+
+// packages/cli/src/commands/index.ts
+var commands = [
+  new_default,
+  init_default,
+  config_default,
+  make_crud_default,
+  make_controller_default,
+  make_service_default,
+  make_module_default,
+  make_model_default,
+  make_migration_default,
+  make_middleware_default,
+  make_validator_default,
+  make_auth_default,
+  make_queue_default,
+  make_schedule_default,
+  make_listener_default,
+  make_session_default,
+  db_migrate_default,
+  db_generate_default,
+  db_seed_default,
+  route_list_default,
+  info_default,
+  repl_default
+];
+function findCommand(name) {
+  return commands.find((c2) => c2.name === name || (c2.aliases ?? []).includes(name));
 }
-var logger23 = new Logger;
-var colors3 = c;
+
 // packages/cli/src/index.ts
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
-  const verbose = flagBool7(parsed.flags, "verbose", false);
-  logger23.setVerbose(verbose);
+  const verbose = flagBool(parsed.flags, "verbose", false);
+  logger.setVerbose(verbose);
   if (parsed.flags["version"] === true) {
     console.log(PKG_VERSION);
     return 0;
@@ -4071,8 +4270,8 @@ async function main() {
   const command = parsed.command ? findCommand(parsed.command) : undefined;
   if (!command) {
     if (parsed.command) {
-      logger23.error(`Unknown command: ${parsed.command}`);
-      logger23.info(`Run \`nx help\` for a list of commands.`);
+      logger.error(`Unknown command: ${parsed.command}`);
+      logger.info(`Run \`nx help\` for a list of commands.`);
       return 1;
     }
     return renderHelp();
@@ -4090,80 +4289,80 @@ function renderHelp(commandName) {
   if (commandName) {
     const cmd = findCommand(commandName);
     if (!cmd) {
-      logger23.error(`Unknown command: ${commandName}`);
+      logger.error(`Unknown command: ${commandName}`);
       return 1;
     }
     renderCommandHelp(cmd);
     return 0;
   }
-  logger23.heading("nx \u2014 Nexus CLI");
+  logger.heading("nx \u2014 Nexus CLI");
   console.log(`
-  ${colors3.dim("Adonis ACE-style command runner for the NexusTS framework.")}
+  ${colors.dim("Adonis ACE-style command runner for the NexusTS framework.")}
 
-${colors3.bold("Usage")}
+${colors.bold("Usage")}
   nx <command> [args...]
 
-${colors3.bold("Commands")}
+${colors.bold("Commands")}
 `);
   const nameWidth = Math.max(...commands.map((c2) => c2.name.length));
   for (const c2 of commands) {
     const padded = c2.name.padEnd(nameWidth);
-    const aliasStr = c2.aliases?.length ? ` ${colors3.dim(`(${c2.aliases.join(", ")})`)}` : "";
-    console.log(`  ${colors3.cyan(padded)}${aliasStr}  ${c2.summary}`);
+    const aliasStr = c2.aliases?.length ? ` ${colors.dim(`(${c2.aliases.join(", ")})`)}` : "";
+    console.log(`  ${colors.cyan(padded)}${aliasStr}  ${c2.summary}`);
   }
   console.log(`
-${colors3.bold("Global flags")}
+${colors.bold("Global flags")}
   --help, -h           Show help (or \`nx help <command>\`)
   --version, -v        Print the CLI version
   --verbose            Verbose output
   --no-color           Disable ANSI color output
 
-${colors3.bold("Examples")}
-  ${colors3.dim("nx new my-app")}
-  ${colors3.dim("nx init --style nest --view inertia --orm drizzle")}
-  ${colors3.dim("nx make:crud Post")}
-  ${colors3.dim("nx make:controller User")}
-  ${colors3.dim("nx make:migration create_users_table")}
-  ${colors3.dim("nx info")}
-  ${colors3.dim("nx route:list")}
+${colors.bold("Examples")}
+  ${colors.dim("nx new my-app")}
+  ${colors.dim("nx init --style nest --view inertia --orm drizzle")}
+  ${colors.dim("nx make:crud Post")}
+  ${colors.dim("nx make:controller User")}
+  ${colors.dim("nx make:migration create_users_table")}
+  ${colors.dim("nx info")}
+  ${colors.dim("nx route:list")}
 `);
   return 0;
 }
 function renderCommandHelp(cmd) {
-  logger23.heading(cmd.name);
+  logger.heading(cmd.name);
   if (cmd.aliases?.length) {
-    console.log(`  ${colors3.dim("aliases:")} ${cmd.aliases.join(", ")}`);
+    console.log(`  ${colors.dim("aliases:")} ${cmd.aliases.join(", ")}`);
   }
   if (cmd.description)
     console.log(`
   ${cmd.description}
 `);
   if (cmd.flags?.length) {
-    console.log(colors3.bold(`
+    console.log(colors.bold(`
 Flags`));
     for (const f of cmd.flags) {
       const short = f.short ? `, -${f.short}` : "";
-      const def = f.default !== undefined ? ` ${colors3.dim(`(default: ${String(f.default)})`)}` : "";
+      const def = f.default !== undefined ? ` ${colors.dim(`(default: ${String(f.default)})`)}` : "";
       console.log(`  --${f.name}${short.padEnd(6)}  ${f.description}${def}`);
     }
   }
   if (cmd.examples?.length) {
-    console.log(colors3.bold(`
+    console.log(colors.bold(`
 Examples`));
     for (const ex of cmd.examples) {
-      console.log(`  ${colors3.cyan(ex)}`);
+      console.log(`  ${colors.cyan(ex)}`);
     }
   }
   console.log();
 }
 var PKG_VERSION = "0.1.0";
 main().then((code) => process.exit(code)).catch((err) => {
-  logger23.error(err?.message ?? String(err));
+  logger.error(err?.message ?? String(err));
   if (process.env["NX_DEBUG"] === "1" && err?.stack) {
     console.error(err.stack);
   }
   process.exit(1);
 });
 
-//# debugId=D18D0C47D950221364756E2164756E21
+//# debugId=CB0A9796F624CF2164756E2164756E21
 //# sourceMappingURL=index.js.map