@forinda/kickjs-cli 5.2.0 → 5.2.3

package/dist/builtins-C_VfEGdg.mjs

@@ -1,4182 +0,0 @@
-/**
- * @forinda/kickjs-cli v5.2.0
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import { A as httpMethodColor, C as intro, D as select, E as outro, F as writeFileSafe, M as severityColor, N as fileExists, O as spinner, P as setDryRun, S as confirm, T as multiSelect, _ as pluralize, a as initProject, b as toKebabCase, c as generateKickJsSkills, d as generateService, f as generateGuard, g as resolveRepoType, h as generateModule, j as pc, k as text, l as generateDto, m as generateAdapter, n as tryDispatchPluginGenerator, o as generateAgents, p as generateMiddleware, s as generateClaude, t as listPluginGenerators, u as generateController, v as pluralizePascal, w as log, x as toPascalCase, y as toCamelCase } from "./generator-extension-DRNQpoZP.mjs";
-import { a as resolveModuleConfig, i as loadKickConfig, o as resolveTokenScope, t as PACKAGE_MANAGERS } from "./config-DDrgs-I3.mjs";
-import { n as defineCliPlugin } from "./types-CGB8BiQh.mjs";
-import { n as mergeCliPlugins } from "./plugin-6_YlK-JG.mjs";
-import { a as discoverAssets, i as TokenCollisionError, o as renderAssetTypes, r as watchTypegen, s as scanProject, t as runTypegen$1 } from "./typegen-DugZmi-0.mjs";
-import path, { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { execSync, fork, spawn, spawnSync } from "node:child_process";
-import { pathToFileURL } from "node:url";
-import { glob } from "glob";
-import { groupAssetKeys } from "@forinda/kickjs";
-import { arch, platform, release } from "node:os";
-import { generate, migrateDown, migrateLatest, migrateRollback, migrateStatus, migrateUp, renderSchemaSource, resolveDbConfig } from "@forinda/kickjs-db";
-//#region src/commands/add.ts
-/** Registry of KickJS packages and their required peer dependencies */
-const PACKAGE_REGISTRY = {
-	kickjs: {
-		pkg: "@forinda/kickjs",
-		peers: ["express"],
-		description: "Unified framework: DI, decorators, routing, middleware",
-		core: true
-	},
-	vite: {
-		pkg: "@forinda/kickjs-vite",
-		peers: ["vite"],
-		description: "Vite plugin: dev server, HMR, module discovery",
-		dev: true,
-		core: true
-	},
-	cli: {
-		pkg: "@forinda/kickjs-cli",
-		peers: [],
-		description: "CLI tool and code generators",
-		dev: true,
-		core: true
-	},
-	swagger: {
-		pkg: "@forinda/kickjs-swagger",
-		peers: [],
-		description: "OpenAPI spec + Swagger UI + ReDoc"
-	},
-	db: {
-		pkg: "@forinda/kickjs-db",
-		peers: [],
-		description: "kick/db core — schema DSL, migrations, KickDbClient, customType"
-	},
-	"db-pg": {
-		pkg: "@forinda/kickjs-db-pg",
-		peers: ["pg"],
-		description: "kick/db PostgreSQL dialect + adapter (pgDialect, pgAdapter)"
-	},
-	drizzle: {
-		pkg: "@forinda/kickjs-drizzle",
-		peers: ["drizzle-orm"],
-		description: "Drizzle ORM adapter + query builder"
-	},
-	prisma: {
-		pkg: "@forinda/kickjs-prisma",
-		peers: ["@prisma/client"],
-		description: "Prisma adapter + query builder"
-	},
-	ws: {
-		pkg: "@forinda/kickjs-ws",
-		peers: ["socket.io"],
-		description: "WebSocket with @WsController decorators"
-	},
-	devtools: {
-		pkg: "@forinda/kickjs-devtools",
-		peers: [],
-		description: "Development dashboard — routes, DI, metrics, health",
-		dev: true
-	},
-	auth: {
-		pkg: "@forinda/kickjs-auth",
-		peers: ["jsonwebtoken"],
-		description: "Authentication — JWT, API key, and custom strategies"
-	},
-	queue: {
-		pkg: "@forinda/kickjs-queue",
-		peers: [],
-		description: "Queue adapter (BullMQ/RabbitMQ/Kafka)"
-	},
-	"queue:bullmq": {
-		pkg: "@forinda/kickjs-queue",
-		peers: ["bullmq", "ioredis"],
-		description: "Queue with BullMQ + Redis"
-	},
-	"queue:rabbitmq": {
-		pkg: "@forinda/kickjs-queue",
-		peers: ["amqplib"],
-		description: "Queue with RabbitMQ"
-	},
-	"queue:kafka": {
-		pkg: "@forinda/kickjs-queue",
-		peers: ["kafkajs"],
-		description: "Queue with Kafka"
-	},
-	mcp: {
-		pkg: "@forinda/kickjs-mcp",
-		peers: ["@modelcontextprotocol/sdk"],
-		description: "Model Context Protocol server — expose @Controller endpoints as AI tools"
-	},
-	testing: {
-		pkg: "@forinda/kickjs-testing",
-		peers: [],
-		description: "Test utilities and TestModule builder",
-		dev: true
-	}
-};
-/**
-* Walk up from `fromDir` to filesystem root, returning the first
-* directory that contains `name`. Lets monorepo sub-packages pick up
-* lockfiles and `packageManager` fields living at the workspace root.
-*/
-function findUp(name, fromDir = process.cwd()) {
-	let current = fromDir;
-	while (true) {
-		if (existsSync(resolve(current, name))) return current;
-		const parent = dirname(current);
-		if (parent === current) return null;
-		current = parent;
-	}
-}
-function detectFromLockfile() {
-	if (findUp("pnpm-lock.yaml")) return "pnpm";
-	if (findUp("yarn.lock")) return "yarn";
-	if (findUp("bun.lockb") || findUp("bun.lock")) return "bun";
-	if (findUp("package-lock.json")) return "npm";
-	return null;
-}
-/**
-* Read `packageManager` from the nearest ancestor `package.json` that
-* declares the field (corepack convention: `"pnpm@10.0.0"`). Climbs so
-* monorepo sub-packages inherit the workspace pm even when their own
-* package.json omits the field.
-*/
-function packageManagerFromPackageJson() {
-	let dir = process.cwd();
-	while (dir) {
-		const pkgPath = resolve(dir, "package.json");
-		if (existsSync(pkgPath)) try {
-			const field = JSON.parse(readFileSync(pkgPath, "utf-8")).packageManager;
-			if (typeof field === "string") {
-				const name = field.split("@")[0];
-				if (PACKAGE_MANAGERS.includes(name)) return name;
-			}
-		} catch {}
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-	return null;
-}
-/**
-* Resolve which package manager to use, in priority order:
-* 1. `--pm` CLI flag
-* 2. `packageManager` in kick.config
-* 3. `packageManager` in nearest ancestor package.json (corepack)
-* 4. Nearest ancestor lockfile (pnpm-lock.yaml → yarn.lock → bun.lock → package-lock.json)
-* 5. `'npm'` fallback
-*
-* Returns the chosen pm plus the source for callers that want to log
-* the resolution path.
-*/
-async function resolvePackageManagerWithSource(flagPm) {
-	if (flagPm && PACKAGE_MANAGERS.includes(flagPm)) return {
-		pm: flagPm,
-		source: "flag"
-	};
-	const config = await loadKickConfig(process.cwd());
-	if (config?.packageManager && PACKAGE_MANAGERS.includes(config.packageManager)) return {
-		pm: config.packageManager,
-		source: "config"
-	};
-	const fromPkg = packageManagerFromPackageJson();
-	if (fromPkg) return {
-		pm: fromPkg,
-		source: "package.json"
-	};
-	const fromLock = detectFromLockfile();
-	if (fromLock) return {
-		pm: fromLock,
-		source: "lockfile"
-	};
-	return {
-		pm: "npm",
-		source: "default"
-	};
-}
-/** Convenience wrapper for callers that don't care about the source. */
-async function resolvePackageManager(flagPm) {
-	const { pm } = await resolvePackageManagerWithSource(flagPm);
-	return pm;
-}
-/**
-* Print the package catalog. By default shows just the three core
-* packages every project always has — the optional list churns
-* (packages added, deprecated, removed) and a long enumeration in CLI
-* output / docs goes stale within a release. Pass `all = true` to dump
-* everything; that's what `kick add --list --all` triggers when an
-* adopter genuinely wants the live catalog.
-*/
-function printPackageList(all = false) {
-	const entries = Object.entries(PACKAGE_REGISTRY);
-	const maxName = Math.max(...entries.map(([k]) => k.length));
-	const core = entries.filter(([, info]) => info.core);
-	const optional = entries.filter(([, info]) => !info.core);
-	const formatRow = ([name, info]) => {
-		const padded = name.padEnd(maxName + 2);
-		const peers = info.peers.length ? ` (+ ${info.peers.join(", ")})` : "";
-		return `    ${padded} ${info.description}${peers}`;
-	};
-	console.log("\n  Core packages (always installed by `kick new`):\n");
-	for (const row of core) console.log(formatRow(row));
-	if (all) {
-		console.log("\n  Optional packages (add as needed):\n");
-		for (const row of optional) console.log(formatRow(row));
-	} else {
-		console.log(`\n  Plus ${optional.length} optional packages (auth, swagger, db, queue, …).`);
-		console.log("  Run `kick add --list --all` for the full catalog.");
-	}
-	console.log("\n  Usage: kick add auth drizzle swagger");
-	console.log("         kick add queue:bullmq");
-	console.log();
-}
-function registerListCommand(program) {
-	program.command("list").alias("ls").description("List KickJS packages (core only; pair with --all for the full catalog)").option("--all", "Include the full optional catalog").action((opts) => {
-		printPackageList(Boolean(opts.all));
-	});
-}
-function registerAddCommand(program) {
-	program.command("add [packages...]").description("Add KickJS packages with their required dependencies").option("--pm <manager>", "Package manager override").option("-D, --dev", "Install as dev dependency").option("--list", "List packages (core only by default; pair with --all)").option("--all", "When listing, include the full optional catalog").action(async (packages, opts) => {
-		if (opts.list || packages.length === 0) {
-			printPackageList(Boolean(opts.all));
-			return;
-		}
-		const { pm, source } = await resolvePackageManagerWithSource(opts.pm);
-		console.log(`\n  Using ${pm} (resolved from ${source})`);
-		const forceDevFlag = opts.dev;
-		const prodDeps = /* @__PURE__ */ new Set();
-		const devDeps = /* @__PURE__ */ new Set();
-		const unknown = [];
-		for (const name of packages) {
-			const entry = PACKAGE_REGISTRY[name];
-			if (!entry) {
-				unknown.push(name);
-				continue;
-			}
-			const target = forceDevFlag || entry.dev ? devDeps : prodDeps;
-			target.add(entry.pkg);
-			for (const peer of entry.peers) target.add(peer);
-		}
-		if (unknown.length > 0) {
-			console.log(`\n  Unknown packages: ${unknown.join(", ")}`);
-			console.log("  Run \"kick add --list\" to see available packages.\n");
-			if (prodDeps.size === 0 && devDeps.size === 0) return;
-		}
-		if (prodDeps.size > 0) {
-			const deps = Array.from(prodDeps);
-			const cmd = `${pm} add ${deps.join(" ")}`;
-			console.log(`\n  Installing ${deps.length} dependency(ies):`);
-			for (const dep of deps) console.log(`    + ${dep}`);
-			console.log();
-			try {
-				execSync(cmd, { stdio: "inherit" });
-			} catch {
-				console.log(`\n  Installation failed. Run manually:\n    ${cmd}\n`);
-			}
-		}
-		if (devDeps.size > 0) {
-			const deps = Array.from(devDeps);
-			const cmd = `${pm} add -D ${deps.join(" ")}`;
-			console.log(`\n  Installing ${deps.length} dev dependency(ies):`);
-			for (const dep of deps) console.log(`    + ${dep} (dev)`);
-			console.log();
-			try {
-				execSync(cmd, { stdio: "inherit" });
-			} catch {
-				console.log(`\n  Installation failed. Run manually:\n    ${cmd}\n`);
-			}
-		}
-		console.log("  Done!\n");
-	});
-}
-//#endregion
-//#region src/commands/init.ts
-/** All optional packages available for selection */
-const OPTIONAL_PACKAGES = [
-	{
-		value: "auth",
-		label: "Auth",
-		hint: "JWT, OAuth, API keys"
-	},
-	{
-		value: "swagger",
-		label: "Swagger",
-		hint: "OpenAPI docs"
-	},
-	{
-		value: "ws",
-		label: "WebSocket",
-		hint: "rooms, heartbeat"
-	},
-	{
-		value: "queue",
-		label: "Queue",
-		hint: "BullMQ/RabbitMQ/Kafka"
-	},
-	{
-		value: "devtools",
-		label: "DevTools",
-		hint: "debug dashboard"
-	}
-];
-function registerInitCommand(program) {
-	program.command("new [name]").alias("init").description("Create a new KickJS project (use \".\" for current directory)").option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn | bun").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").option("-t, --template <type>", "Project template: rest | ddd | cqrs | minimal").option("-r, --repo <type>", "Default repository: prisma | drizzle | inmemory | custom").option("--packages <packages>", "Comma-separated packages to include (e.g. auth,swagger,ws,queue)").option("-y, --yes", "Pick safe defaults for every prompt (template=minimal, repo=inmemory, no extras, git+install on)").option("--non-interactive", "alias for --yes").action(async (name, opts) => {
-		intro("KickJS — Create a new project");
-		const yes = Boolean(opts.yes || opts.nonInteractive);
-		if (!name) if (yes) name = "my-api";
-		else name = await text({
-			message: "Project name",
-			placeholder: "my-api",
-			defaultValue: "my-api"
-		});
-		let directory;
-		if (name === ".") {
-			directory = resolve(".");
-			name = basename(directory);
-		} else directory = resolve(opts.directory || name);
-		if (existsSync(directory)) {
-			const entries = readdirSync(directory);
-			if (entries.length > 0) {
-				if (opts.force) log.warn(`Clearing existing files in ${directory}`);
-				else if (yes) {
-					log.warn(`Directory "${name}" is not empty. Pass --force to clear it.`);
-					outro("Aborted.");
-					return;
-				} else {
-					log.warn(`Directory "${name}" is not empty:`);
-					const shown = entries.slice(0, 5);
-					for (const entry of shown) log.message(`  - ${entry}`);
-					if (entries.length > 5) log.message(`  ... and ${entries.length - 5} more`);
-					if (!await confirm({
-						message: pc.red("Remove all existing files and proceed?"),
-						initialValue: false
-					})) {
-						outro("Aborted.");
-						return;
-					}
-				}
-				for (const entry of entries) rmSync(resolve(directory, entry), {
-					recursive: true,
-					force: true
-				});
-			}
-		}
-		let template = opts.template;
-		if (!template) if (yes) template = "minimal";
-		else template = await select({
-			message: "Project template",
-			options: [
-				{
-					value: "rest",
-					label: "REST API",
-					hint: "Express + Swagger"
-				},
-				{
-					value: "ddd",
-					label: "DDD",
-					hint: "Domain-Driven Design modules"
-				},
-				{
-					value: "cqrs",
-					label: "CQRS",
-					hint: "Commands, Queries, Events + WS/Queue"
-				},
-				{
-					value: "minimal",
-					label: "Minimal",
-					hint: "bare Express"
-				}
-			]
-		});
-		let packageManager = opts.pm;
-		if (!packageManager) if (yes) packageManager = await resolvePackageManager(void 0);
-		else packageManager = await select({
-			message: "Package manager",
-			options: [
-				{
-					value: "pnpm",
-					label: "pnpm"
-				},
-				{
-					value: "npm",
-					label: "npm"
-				},
-				{
-					value: "yarn",
-					label: "yarn"
-				},
-				{
-					value: "bun",
-					label: "bun"
-				}
-			]
-		});
-		let defaultRepo = opts.repo;
-		if (!defaultRepo) if (yes) defaultRepo = "inmemory";
-		else {
-			defaultRepo = await select({
-				message: "Default repository/ORM",
-				options: [
-					{
-						value: "prisma",
-						label: "Prisma"
-					},
-					{
-						value: "drizzle",
-						label: "Drizzle"
-					},
-					{
-						value: "inmemory",
-						label: "In-Memory"
-					},
-					{
-						value: "custom",
-						label: "Custom",
-						hint: "specify later"
-					}
-				]
-			});
-			if (defaultRepo === "custom") defaultRepo = await text({
-				message: "Custom repository name",
-				defaultValue: "custom"
-			});
-		}
-		let selectedPackages;
-		if (opts.packages !== void 0) {
-			const raw = opts.packages.trim().toLowerCase();
-			if (raw === "" || raw === "none" || raw === "false") selectedPackages = [];
-			else selectedPackages = opts.packages.split(",").map((p) => p.trim()).filter(Boolean);
-		} else if (yes) selectedPackages = [];
-		else selectedPackages = await multiSelect({
-			message: "Select packages to include",
-			options: [...OPTIONAL_PACKAGES],
-			required: false
-		});
-		let initGit;
-		if (opts.git === void 0) initGit = yes ? true : await confirm({
-			message: "Initialize git repository?",
-			initialValue: true
-		});
-		else initGit = opts.git;
-		let installDeps;
-		if (opts.install === void 0) installDeps = yes ? true : await confirm({
-			message: "Install dependencies?",
-			initialValue: true
-		});
-		else installDeps = opts.install;
-		await initProject({
-			name,
-			directory,
-			packageManager,
-			initGit,
-			installDeps,
-			template,
-			defaultRepo,
-			packages: selectedPackages
-		});
-		outro(`Done! Next steps: ${pc.cyan(`cd ${name} && ${packageManager} dev`)}`);
-	});
-}
-//#endregion
-//#region src/generators/plugin.ts
-/**
-* Scaffold a `definePlugin()` factory under `src/plugins/<name>.plugin.ts`.
-*
-* v4 standardised on the `definePlugin()` factory pattern (architecture
-* §21.2.2) — same surface as `defineAdapter()`, so adopters learn one
-* mental model. The generated template uses the factory shape with a
-* typed config object, defaults block, and a build function returning
-* the underlying KickPlugin hooks.
-*/
-async function generatePlugin(options) {
-	const { name, outDir } = options;
-	const kebab = toKebabCase(name);
-	const pascal = toPascalCase(name);
-	const files = [];
-	const filePath = join(outDir, `${kebab}.plugin.ts`);
-	await writeFileSafe(filePath, `import {
-  definePlugin,
-  type AppAdapter,
-  type AppModuleClass,
-  type Container,
-  type ContributorRegistrations,
-} from '@forinda/kickjs'
-
-/**
- * Configuration for the ${pascal} plugin.
- *
- * Plugins typically take a small config object so callers can tune
- * behaviour at bootstrap time. Keep the shape narrow — anything
- * derived from the environment should be read inside the build
- * function via getEnv(), not forced onto the caller.
- */
-export interface ${pascal}PluginConfig {
-  // Add your plugin config here, e.g.:
-  // enabled?: boolean
-  // apiKey?: string
-}
-
-/**
- * ${pascal} plugin — built via \`definePlugin()\` so callers get the
- * factory's call / \`.scoped()\` / \`.async()\` surfaces for free.
- *
- * A plugin bundles DI bindings, modules, adapters, and middleware
- * into one object that can be added to \`bootstrap({ plugins })\`.
- *
- * Lifecycle order (each hook is optional — delete the ones you don't
- * need and keep only the surface your plugin actually uses):
- *
- *   1. \`register(container)\` — runs before user modules load. Use
- *      it to bind services that modules depend on.
- *   2. \`modules()\`            — plugin modules load before user modules.
- *   3. \`adapters()\`           — plugin adapters mount before user adapters.
- *   4. \`middleware()\`         — plugin middleware runs before user middleware.
- *   5. \`contributors()\`       — Context Contributors merged into every route.
- *   6. \`onReady(container)\`   — runs after the app has fully bootstrapped.
- *   7. \`shutdown()\`           — runs on graceful shutdown.
- *
- * @example
- * \`\`\`ts
- * import { bootstrap } from '@forinda/kickjs'
- * import { ${pascal}Plugin } from './plugins/${kebab}.plugin'
- *
- * export const app = await bootstrap({
- *   modules,
- *   plugins: [${pascal}Plugin({ /* config overrides *\\/ })],
- * })
- * \`\`\`
- */
-export const ${pascal}Plugin = definePlugin<${pascal}PluginConfig>({
-  name: '${pascal}Plugin',
-  defaults: {
-    // Default config values go here
-  },
-  build: (_config, { name: _name }) => ({
-    /**
-     * Register DI bindings before modules load.
-     * Use \`container.registerInstance(TOKEN, value)\` for singletons
-     * and \`container.registerFactory(TOKEN, () => ...)\` for lazy
-     * constructions.
-     */
-    register(_container: Container): void {
-      // Example: _container.registerInstance(MY_TOKEN, new MyService(_config))
-    },
-
-    /**
-     * Return module classes this plugin contributes to the app.
-     * These load before user modules, so plugin controllers and
-     * services are available for user code to \`@Autowired\`.
-     */
-    modules(): AppModuleClass[] {
-      return [
-        // ExampleModule,
-      ]
-    },
-
-    /**
-     * Return adapter instances to be added to the application.
-     * Plugin adapters mount before user adapters.
-     */
-    adapters(): AppAdapter[] {
-      return [
-        // MyAdapter({ ... }),
-      ]
-    },
-
-    /**
-     * Return Express middleware entries to be added to the global
-     * pipeline. Plugin middleware runs before user-defined middleware.
-     */
-    middleware(): unknown[] {
-      return [
-        // helmet(),
-        // myCustomMiddleware(_config),
-      ]
-    },
-
-    /**
-     * Return Context Contributors to merge into every route's pipeline.
-     * Plugins contribute at the same \`'adapter'\` precedence level as
-     * adapters — overrideable per-route at the method / class / module
-     * level. See https://forinda.github.io/kick-js/guide/context-decorators
-     *
-     * Delete this hook if your plugin doesn't ship typed per-request values.
-     */
-    contributors(): ContributorRegistrations {
-      return [
-        // Example:
-        // import { defineHttpContextDecorator } from '@forinda/kickjs'
-        // declare module '@forinda/kickjs' { interface ContextMeta { ${kebab}: { foo: string } } }
-        // const Load${pascal} = defineHttpContextDecorator({
-        //   key: '${kebab}',
-        //   resolve: (ctx) => ({ foo: ctx.req.headers['x-${kebab}'] as string }),
-        // })
-        // return [Load${pascal}.registration]
-      ]
-    },
-
-    /**
-     * Called after the application has fully bootstrapped. Use this
-     * for post-startup work like logging, health checks, or warming
-     * a cache. Runs once per process.
-     */
-    async onReady(_container: Container): Promise<void> {
-      // const log = _container.resolve(Logger)
-      // log.info('${pascal} plugin ready')
-    },
-
-    /**
-     * Called during graceful shutdown. Clean up any long-lived
-     * resources this plugin owns (connections, timers, subscriptions).
-     */
-    async shutdown(): Promise<void> {
-      // Example: await this.connection?.close()
-    },
-  }),
-})
-`);
-	files.push(filePath);
-	return files;
-}
-//#endregion
-//#region src/generators/config.ts
-async function generateConfig(options) {
-	const filePath = join(options.outDir, "kick.config.ts");
-	const modulesDir = options.modulesDir ?? "src/modules";
-	const defaultRepo = options.defaultRepo ?? "inmemory";
-	if (existsSync(filePath) && !options.force) {
-		if (!await confirm({
-			message: "kick.config.ts already exists. Overwrite?",
-			initialValue: false
-		})) {
-			console.log("\n  Skipped — existing kick.config.ts preserved.");
-			return [];
-		}
-	}
-	await writeFileSafe(filePath, `import { defineConfig } from '@forinda/kickjs-cli'
-
-export default defineConfig({
-  modules: {
-    dir: '${modulesDir}',
-    repo: '${defaultRepo}',
-    pluralize: true,
-  },
-
-  typegen: {
-    schemaValidator: 'zod',
-  },
-
-  commands: [
-    {
-      name: 'test',
-      description: 'Run tests with Vitest',
-      steps: 'npx vitest run',
-    },
-    {
-      name: 'format',
-      description: 'Format code with Prettier',
-      steps: 'npx prettier --write src/',
-    },
-    {
-      name: 'format:check',
-      description: 'Check formatting without writing',
-      steps: 'npx prettier --check src/',
-    },
-    {
-      name: 'ci:check',
-      description: 'Run typecheck + format check',
-      steps: ['npx tsc --noEmit', 'npx prettier --check src/'],
-      aliases: ['verify'],
-    },
-  ],
-})
-`);
-	return [filePath];
-}
-//#endregion
-//#region src/generators/agent-docs.ts
-const VALID_TEMPLATES = new Set([
-	"rest",
-	"ddd",
-	"cqrs",
-	"minimal"
-]);
-function detectName(outDir, override) {
-	if (override) return override;
-	try {
-		const pkg = JSON.parse(readFileSync(join(outDir, "package.json"), "utf-8"));
-		if (pkg.name) return pkg.name.replace(/^@[^/]+\//, "");
-	} catch {}
-	return outDir.split("/").findLast(Boolean) ?? "app";
-}
-function detectPm(outDir, override) {
-	if (override) return override;
-	try {
-		const pkg = JSON.parse(readFileSync(join(outDir, "package.json"), "utf-8"));
-		if (pkg.packageManager) return pkg.packageManager.split("@")[0];
-	} catch {}
-	return "pnpm";
-}
-async function detectTemplate(outDir, override) {
-	if (override) return override;
-	try {
-		const pattern = (await loadKickConfig(outDir))?.pattern;
-		if (pattern && VALID_TEMPLATES.has(pattern)) return pattern;
-	} catch {}
-	return "ddd";
-}
-async function generateAgentDocs(options) {
-	const only = options.only ?? "all";
-	const name = detectName(options.outDir, options.name);
-	const pm = detectPm(options.outDir, options.pm);
-	const template = await detectTemplate(options.outDir, options.template);
-	const wantsAgents = only === "agents" || only === "both" || only === "all";
-	const wantsClaude = only === "claude" || only === "both" || only === "all";
-	const wantsSkills = only === "skills" || only === "all";
-	const targets = [];
-	if (wantsAgents) targets.push({
-		file: join(options.outDir, "AGENTS.md"),
-		render: () => generateAgents(name, template, pm)
-	});
-	if (wantsClaude) targets.push({
-		file: join(options.outDir, "CLAUDE.md"),
-		render: () => generateClaude(name, template, pm)
-	});
-	if (wantsSkills) targets.push({
-		file: join(options.outDir, "kickjs-skills.md"),
-		render: () => generateKickJsSkills(name, template, pm)
-	});
-	const written = [];
-	for (const { file, render } of targets) {
-		if (existsSync(file) && !options.force) {
-			if (!await confirm({
-				message: `${file.replace(options.outDir + "/", "")} already exists. Overwrite?`,
-				initialValue: false
-			})) {
-				console.log(`  Skipped — existing ${file.replace(options.outDir + "/", "")} preserved.`);
-				continue;
-			}
-		}
-		await writeFileSafe(file, render());
-		written.push(file);
-	}
-	return written;
-}
-//#endregion
-//#region src/generators/auth-scaffold.ts
-/**
-* Generate a complete auth module with registration, login, logout,
-* and password hashing. Uses PasswordService and the configured strategy.
-*/
-async function generateAuthScaffold(options = {}) {
-	const strategy = options.strategy ?? "jwt";
-	const outDir = options.outDir ?? "src/modules/auth";
-	const dtoDir = join(outDir, "dto");
-	const files = [];
-	const modulePath = join(outDir, "auth.module.ts");
-	await writeFileSafe(modulePath, `import { Module } from '@forinda/kickjs'
-import { AuthController } from './auth.controller'
-import { AuthService } from './auth.service'
-
-@Module({
-  controllers: [AuthController],
-  services: [AuthService],
-})
-export class AuthModule {}
-`);
-	files.push(modulePath);
-	const controllerPath = join(outDir, "auth.controller.ts");
-	await writeFileSafe(controllerPath, strategy === "jwt" ? jwtControllerTemplate() : sessionControllerTemplate());
-	files.push(controllerPath);
-	const servicePath = join(outDir, "auth.service.ts");
-	await writeFileSafe(servicePath, strategy === "jwt" ? jwtServiceTemplate() : sessionServiceTemplate());
-	files.push(servicePath);
-	const registerDtoPath = join(dtoDir, "register.dto.ts");
-	await writeFileSafe(registerDtoPath, `import { z } from 'zod'
-
-export const RegisterDto = z.object({
-  email: z.string().email(),
-  password: z.string().min(8),
-  name: z.string().min(1).optional(),
-})
-
-export type RegisterInput = z.infer<typeof RegisterDto>
-`);
-	files.push(registerDtoPath);
-	const loginDtoPath = join(dtoDir, "login.dto.ts");
-	await writeFileSafe(loginDtoPath, `import { z } from 'zod'
-
-export const LoginDto = z.object({
-  email: z.string().email(),
-  password: z.string().min(1),
-})
-
-export type LoginInput = z.infer<typeof LoginDto>
-`);
-	files.push(loginDtoPath);
-	const testPath = join(outDir, "auth.test.ts");
-	await writeFileSafe(testPath, `import { describe, it, expect } from 'vitest'
-
-describe('Auth Module', () => {
-  it.todo('POST /register — creates a new user')
-  it.todo('POST /login — returns token for valid credentials')
-  it.todo('POST /login — rejects invalid credentials')
-  it.todo('POST /logout — invalidates session/token')
-  it.todo('GET /me — returns authenticated user')
-})
-`);
-	files.push(testPath);
-	if (options.roleGuards !== false) {
-		const guardPath = join(outDir, "auth.guard.ts");
-		await writeFileSafe(guardPath, `import { Roles } from '@forinda/kickjs-auth'
-
-/**
- * Role-based access guard.
- * Usage: @Roles('admin') on a controller method.
- *
- * The AuthAdapter extracts the user's roles from the JWT/session
- * and the framework checks them automatically.
- */
-export const AdminOnly = Roles('admin')
-export const ManagerOnly = Roles('manager')
-`);
-		files.push(guardPath);
-	}
-	return files;
-}
-function jwtControllerTemplate() {
-	return `import { Controller, Post, Get } from '@forinda/kickjs'
-import { Authenticated, Public } from '@forinda/kickjs-auth'
-import type { RequestContext } from '@forinda/kickjs'
-import { Autowired } from '@forinda/kickjs'
-import { AuthService } from './auth.service'
-
-@Controller()
-@Authenticated()
-export class AuthController {
-  @Autowired() private authService!: AuthService
-
-  @Post('/register')
-  @Public()
-  async register(ctx: RequestContext) {
-    const result = await this.authService.register(ctx.body)
-    return ctx.created(result)
-  }
-
-  @Post('/login')
-  @Public()
-  async login(ctx: RequestContext) {
-    const result = await this.authService.login(ctx.body)
-    if (!result) return ctx.badRequest('Invalid credentials')
-    return ctx.json(result)
-  }
-
-  @Post('/logout')
-  async logout(ctx: RequestContext) {
-    return ctx.json({ message: 'Logged out' })
-  }
-
-  @Get('/me')
-  async me(ctx: RequestContext) {
-    return ctx.json({ user: ctx.user })
-  }
-}
-`;
-}
-function jwtServiceTemplate() {
-	return `import { Service, Autowired } from '@forinda/kickjs'
-import { PasswordService } from '@forinda/kickjs-auth'
-import type { RegisterInput } from './dto/register.dto'
-import type { LoginInput } from './dto/login.dto'
-
-// TODO: Replace with your User repository
-const users = new Map<string, { id: string; email: string; name?: string; passwordHash: string }>()
-
-@Service()
-export class AuthService {
-  @Autowired() private password!: PasswordService
-
-  async register(input: RegisterInput) {
-    const { email, password, name } = input
-
-    if (users.has(email)) {
-      throw new Error('User already exists')
-    }
-
-    const passwordHash = await this.password.hash(password)
-    const id = crypto.randomUUID()
-    users.set(email, { id, email, name, passwordHash })
-
-    return { id, email, name }
-  }
-
-  async login(input: LoginInput) {
-    const { email, password } = input
-    const user = users.get(email)
-    if (!user) return null
-
-    const valid = await this.password.verify(user.passwordHash, password)
-    if (!valid) return null
-
-    // TODO: Generate JWT token here
-    // const token = jwt.sign({ sub: user.id, email: user.email }, process.env.JWT_SECRET!)
-    return { user: { id: user.id, email: user.email, name: user.name } }
-  }
-}
-`;
-}
-function sessionControllerTemplate() {
-	return `import { Controller, Post, Get } from '@forinda/kickjs'
-import { Authenticated, Public } from '@forinda/kickjs-auth'
-import { sessionLogin, sessionLogout } from '@forinda/kickjs-auth'
-import type { RequestContext } from '@forinda/kickjs'
-import { Autowired } from '@forinda/kickjs'
-import { AuthService } from './auth.service'
-
-@Controller()
-@Authenticated()
-export class AuthController {
-  @Autowired() private authService!: AuthService
-
-  @Post('/register')
-  @Public()
-  async register(ctx: RequestContext) {
-    const result = await this.authService.register(ctx.body)
-    return ctx.created(result)
-  }
-
-  @Post('/login')
-  @Public()
-  async login(ctx: RequestContext) {
-    const user = await this.authService.login(ctx.body)
-    if (!user) return ctx.badRequest('Invalid credentials')
-    await sessionLogin(ctx.session, user)
-    return ctx.json({ message: 'Logged in', user })
-  }
-
-  @Post('/logout')
-  async logout(ctx: RequestContext) {
-    await sessionLogout(ctx.session)
-    return ctx.json({ message: 'Logged out' })
-  }
-
-  @Get('/me')
-  async me(ctx: RequestContext) {
-    return ctx.json({ user: ctx.user })
-  }
-}
-`;
-}
-function sessionServiceTemplate() {
-	return `import { Service, Autowired } from '@forinda/kickjs'
-import { PasswordService } from '@forinda/kickjs-auth'
-import type { RegisterInput } from './dto/register.dto'
-import type { LoginInput } from './dto/login.dto'
-
-// TODO: Replace with your User repository
-const users = new Map<string, { id: string; email: string; name?: string; passwordHash: string }>()
-
-@Service()
-export class AuthService {
-  @Autowired() private password!: PasswordService
-
-  async register(input: RegisterInput) {
-    const { email, password, name } = input
-
-    if (users.has(email)) {
-      throw new Error('User already exists')
-    }
-
-    const passwordHash = await this.password.hash(password)
-    const id = crypto.randomUUID()
-    users.set(email, { id, email, name, passwordHash })
-
-    return { id, email, name }
-  }
-
-  async login(input: LoginInput) {
-    const { email, password } = input
-    const user = users.get(email)
-    if (!user) return null
-
-    const valid = await this.password.verify(user.passwordHash, password)
-    if (!valid) return null
-
-    return { id: user.id, email: user.email, name: user.name }
-  }
-}
-`;
-}
-//#endregion
-//#region src/generators/job.ts
-async function generateJob(options) {
-	const { name, outDir } = options;
-	const pascal = toPascalCase(name);
-	const kebab = toKebabCase(name);
-	const camel = toCamelCase(name);
-	const queueName = options.queue ?? `${kebab}-queue`;
-	const files = [];
-	const write = async (relativePath, content) => {
-		const fullPath = join(outDir, relativePath);
-		await writeFileSafe(fullPath, content);
-		files.push(fullPath);
-	};
-	await write(`${kebab}.job.ts`, `import { Inject } from '@forinda/kickjs'
-import { Job, Process, QUEUE_MANAGER, type QueueService } from '@forinda/kickjs-queue'
-
-/**
- * ${pascal} Job Processor
- *
- * Decorators:
- *   @Job(queueName) — marks this class as a job processor for a queue
- *   @Process(jobName?) — marks a method as the handler for a specific job type
- *     - Without a name: handles all jobs in the queue
- *     - With a name: handles only jobs matching that name
- *
- * To add jobs to this queue from a service or controller:
- *   @Inject(QUEUE_MANAGER) private queue: QueueService
- *   await this.queue.add('${queueName}', '${camel}', { ... })
- */
-@Job('${queueName}')
-export class ${pascal}Job {
-  @Process()
-  async handle(job: { name: string; data: any; id?: string }) {
-    console.log(\`Processing \${job.name} (id: \${job.id})\`, job.data)
-
-    // TODO: Implement job logic here
-    // Example:
-    // await this.emailService.send(job.data.to, job.data.subject, job.data.body)
-  }
-
-  @Process('${camel}.priority')
-  async handlePriority(job: { name: string; data: any; id?: string }) {
-    console.log(\`Priority job: \${job.name}\`, job.data)
-    // Handle high-priority variant of this job
-  }
-}
-`);
-	return files;
-}
-//#endregion
-//#region src/generators/scaffold.ts
-/**
-* Supported field types and their mappings:
-*   string    → z.string()
-*   text      → z.string()        (alias, hints at longer content)
-*   number    → z.number()
-*   int       → z.number().int()
-*   float     → z.number()
-*   boolean   → z.boolean()
-*   date      → z.string().datetime()
-*   email     → z.string().email()
-*   url       → z.string().url()
-*   uuid      → z.string().uuid()
-*   json      → z.any()
-*   enum:a,b  → z.enum(['a','b'])
-*
-* Mark optional fields — three equivalent syntaxes:
-*   body:text:optional  ← recommended (shell-safe, no quoting needed)
-*   body?:text          ← needs quoting in bash/zsh ("body?:text")
-*   body:text?          ← needs quoting in bash/zsh ("body:text?")
-*/
-const TYPE_MAP = {
-	string: {
-		ts: "string",
-		zod: "z.string()"
-	},
-	text: {
-		ts: "string",
-		zod: "z.string()"
-	},
-	number: {
-		ts: "number",
-		zod: "z.number()"
-	},
-	int: {
-		ts: "number",
-		zod: "z.number().int()"
-	},
-	float: {
-		ts: "number",
-		zod: "z.number()"
-	},
-	boolean: {
-		ts: "boolean",
-		zod: "z.boolean()"
-	},
-	date: {
-		ts: "string",
-		zod: "z.string().datetime()"
-	},
-	email: {
-		ts: "string",
-		zod: "z.string().email()"
-	},
-	url: {
-		ts: "string",
-		zod: "z.string().url()"
-	},
-	uuid: {
-		ts: "string",
-		zod: "z.string().uuid()"
-	},
-	json: {
-		ts: "any",
-		zod: "z.any()"
-	}
-};
-function parseFields(raw) {
-	return raw.map((f) => {
-		const colonIdx = f.indexOf(":");
-		if (colonIdx === -1) throw new Error(`Invalid field: "${f}". Use format: name:type (e.g. title:string)`);
-		let namePart = f.slice(0, colonIdx);
-		let typePart = f.slice(colonIdx + 1);
-		if (!namePart || !typePart) throw new Error(`Invalid field: "${f}". Use format: name:type (e.g. title:string)`);
-		let optional = false;
-		if (typePart.endsWith(":optional")) {
-			typePart = typePart.slice(0, -9);
-			optional = true;
-		}
-		if (namePart.endsWith("?")) {
-			namePart = namePart.slice(0, -1);
-			optional = true;
-		}
-		if (typePart.endsWith("?")) {
-			typePart = typePart.slice(0, -1);
-			optional = true;
-		}
-		const cleanType = typePart;
-		if (cleanType.startsWith("enum:")) {
-			const values = cleanType.slice(5).split(",");
-			return {
-				name: namePart,
-				type: "enum",
-				tsType: values.map((v) => `'${v}'`).join(" | "),
-				zodType: `z.enum([${values.map((v) => `'${v}'`).join(", ")}])`,
-				optional
-			};
-		}
-		const mapped = TYPE_MAP[cleanType];
-		if (!mapped) {
-			const validTypes = [...Object.keys(TYPE_MAP), "enum:a,b,c"].join(", ");
-			throw new Error(`Unknown field type: "${cleanType}". Valid types: ${validTypes}`);
-		}
-		return {
-			name: namePart,
-			type: cleanType,
-			tsType: mapped.ts,
-			zodType: mapped.zod,
-			optional
-		};
-	});
-}
-async function generateScaffold(options) {
-	const { name, fields, modulesDir, noEntity, noTests: _noTests, repo = "inmemory", tokenScope = "app" } = options;
-	const shouldPluralize = options.pluralize !== false;
-	const kebab = toKebabCase(name);
-	const pascal = toPascalCase(name);
-	toCamelCase(name);
-	const plural = shouldPluralize ? pluralize(kebab) : kebab;
-	const pluralPascal = shouldPluralize ? pluralizePascal(pascal) : pascal;
-	const moduleDir = join(modulesDir, plural);
-	const files = [];
-	const write = async (relativePath, content) => {
-		const fullPath = join(moduleDir, relativePath);
-		await writeFileSafe(fullPath, content);
-		files.push(fullPath);
-	};
-	await write(`${kebab}.module.ts`, genModuleIndex(pascal, kebab, plural));
-	await write("constants.ts", genConstants(pascal, fields));
-	await write(`presentation/${kebab}.controller.ts`, genController(pascal, kebab, plural, pluralPascal));
-	await write(`application/dtos/create-${kebab}.dto.ts`, genCreateDTO(pascal, fields));
-	await write(`application/dtos/update-${kebab}.dto.ts`, genUpdateDTO(pascal, fields));
-	await write(`application/dtos/${kebab}-response.dto.ts`, genResponseDTO(pascal, fields));
-	const useCases = genUseCases(pascal, kebab, plural, pluralPascal);
-	for (const uc of useCases) await write(`application/use-cases/${uc.file}`, uc.content);
-	await write(`domain/repositories/${kebab}.repository.ts`, genRepositoryInterface(pascal, kebab, tokenScope));
-	await write(`domain/services/${kebab}-domain.service.ts`, genDomainService(pascal, kebab));
-	if (repo === "inmemory") await write(`infrastructure/repositories/in-memory-${kebab}.repository.ts`, genInMemoryRepository(pascal, kebab, fields));
-	if (!noEntity) {
-		await write(`domain/entities/${kebab}.entity.ts`, genEntity(pascal, kebab, fields));
-		await write(`domain/value-objects/${kebab}-id.vo.ts`, genValueObject(pascal));
-	}
-	await autoRegisterModule(modulesDir, pascal, plural, kebab);
-	return files;
-}
-function genCreateDTO(pascal, fields) {
-	return `import { z } from 'zod'
-
-export const create${pascal}Schema = z.object({
-${fields.map((f) => {
-		const base = f.zodType;
-		return `  ${f.name}: ${base}${f.optional ? ".optional()" : ""},`;
-	}).join("\n")}
-})
-
-export type Create${pascal}DTO = z.infer<typeof create${pascal}Schema>
-`;
-}
-function genUpdateDTO(pascal, fields) {
-	return `import { z } from 'zod'
-
-export const update${pascal}Schema = z.object({
-${fields.map((f) => `  ${f.name}: ${f.zodType}.optional(),`).join("\n")}
-})
-
-export type Update${pascal}DTO = z.infer<typeof update${pascal}Schema>
-`;
-}
-function genResponseDTO(pascal, fields) {
-	return `export interface ${pascal}ResponseDTO {
-  id: string
-${fields.map((f) => `  ${f.name}${f.optional ? "?" : ""}: ${f.tsType}`).join("\n")}
-  createdAt: string
-  updatedAt: string
-}
-`;
-}
-function genConstants(pascal, fields) {
-	const stringFields = fields.filter((f) => f.tsType === "string").map((f) => `'${f.name}'`);
-	fields.filter((f) => f.tsType === "number").map((f) => `'${f.name}'`);
-	const allFieldNames = fields.map((f) => `'${f.name}'`);
-	const filterable = [...allFieldNames].join(", ");
-	const sortable = [
-		...allFieldNames,
-		"'createdAt'",
-		"'updatedAt'"
-	].join(", ");
-	const searchable = stringFields.length > 0 ? stringFields.join(", ") : "'name'";
-	return `import type { ApiQueryParamsConfig } from '@forinda/kickjs'
-
-export const ${pascal.toUpperCase()}_QUERY_CONFIG: ApiQueryParamsConfig = {
-  filterable: [${filterable}],
-  sortable: [${sortable}],
-  searchable: [${searchable}],
-}
-`;
-}
-function genInMemoryRepository(pascal, kebab, fields) {
-	return `import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
-import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
-import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
-
-@Repository()
-export class InMemory${pascal}Repository implements I${pascal}Repository {
-  private store = new Map<string, ${pascal}ResponseDTO>()
-
-  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${pascal}ResponseDTO[]> {
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }> {
-    const all = Array.from(this.store.values())
-    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
-    return { data, total: all.length }
-  }
-
-  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
-    const now = new Date().toISOString()
-    const entity: ${pascal}ResponseDTO = {
-      id: randomUUID(),
-${fields.map((f) => `      ${f.name}: dto.${f.name},`).join("\n")}
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${pascal} not found')
-    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
-    this.store.set(id, updated)
-    return updated
-  }
-
-  async delete(id: string): Promise<void> {
-    if (!this.store.has(id)) throw HttpException.notFound('${pascal} not found')
-    this.store.delete(id)
-  }
-}
-`;
-}
-function genEntity(pascal, kebab, fields) {
-	return `import { ${pascal}Id } from '../value-objects/${kebab}-id.vo'
-
-interface ${pascal}Props {
-  id: ${pascal}Id
-${fields.map((f) => `  ${f.name}${f.optional ? "?" : ""}: ${f.tsType}`).join("\n")}
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class ${pascal} {
-  private constructor(private props: ${pascal}Props) {}
-
-  static create(params: { ${fields.filter((f) => !f.optional).map((f) => `${f.name}: ${f.tsType}`).join("; ")} }): ${pascal} {
-    const now = new Date()
-    return new ${pascal}({
-      id: ${pascal}Id.create(),
-${fields.filter((f) => !f.optional).map((f) => `      ${f.name}: params.${f.name},`).join("\n")}
-      createdAt: now,
-      updatedAt: now,
-    })
-  }
-
-  static reconstitute(props: ${pascal}Props): ${pascal} {
-    return new ${pascal}(props)
-  }
-
-  get id(): ${pascal}Id { return this.props.id }
-${fields.map((f) => `  get ${f.name}(): ${f.tsType}${f.optional ? " | undefined" : ""} {
-    return this.props.${f.name}
-  }`).join("\n")}
-  get createdAt(): Date { return this.props.createdAt }
-  get updatedAt(): Date { return this.props.updatedAt }
-
-  toJSON() {
-    return {
-      id: this.props.id.toString(),
-${fields.map((f) => `      ${f.name}: this.props.${f.name},`).join("\n")}
-      createdAt: this.props.createdAt.toISOString(),
-      updatedAt: this.props.updatedAt.toISOString(),
-    }
-  }
-}
-`;
-}
-function genValueObject(pascal) {
-	return `import { randomUUID } from 'node:crypto'
-
-export class ${pascal}Id {
-  private constructor(private readonly value: string) {}
-
-  static create(): ${pascal}Id { return new ${pascal}Id(randomUUID()) }
-
-  static from(id: string): ${pascal}Id {
-    if (!id || id.trim().length === 0) throw new Error('${pascal}Id cannot be empty')
-    return new ${pascal}Id(id)
-  }
-
-  toString(): string { return this.value }
-  equals(other: ${pascal}Id): boolean { return this.value === other.value }
-}
-`;
-}
-function genModuleIndex(pascal, kebab, plural) {
-	return `import { type AppModule, type ModuleRoutes, Container, buildRoutes } from '@forinda/kickjs'
-import { ${pascal}Controller } from './presentation/${kebab}.controller'
-import { ${pascal.toUpperCase()}_REPOSITORY } from './domain/repositories/${kebab}.repository'
-import { InMemory${pascal}Repository } from './infrastructure/repositories/in-memory-${kebab}.repository'
-
-// Eagerly load decorated classes so @Service()/@Repository() decorators
-// register in the DI container before the application bootstraps.
-import.meta.glob(
-  ['./domain/services/**/*.ts', './application/use-cases/**/*.ts', '!./**/*.test.ts'],
-  { eager: true },
-)
-
-export class ${pascal}Module implements AppModule {
-  /**
-   * Bind the repository token to its concrete implementation.
-   * Decorator-managed classes (@Service, @Controller, @Repository) are
-   * registered automatically — only token-to-impl bindings need to live here.
-   */
-  register(container: Container): void {
-    container.registerFactory(
-      ${pascal.toUpperCase()}_REPOSITORY,
-      () => container.resolve(InMemory${pascal}Repository),
-    )
-  }
-
-  routes(): ModuleRoutes {
-    return {
-      path: '/${plural}',
-      router: buildRoutes(${pascal}Controller),
-      controller: ${pascal}Controller,
-    }
-  }
-}
-`;
-}
-function genController(pascal, kebab, plural, pluralPascal) {
-	return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${pascal}UseCase } from '../application/use-cases/create-${kebab}.use-case'
-import { Get${pascal}UseCase } from '../application/use-cases/get-${kebab}.use-case'
-import { List${pluralPascal}UseCase } from '../application/use-cases/list-${plural}.use-case'
-import { Update${pascal}UseCase } from '../application/use-cases/update-${kebab}.use-case'
-import { Delete${pascal}UseCase } from '../application/use-cases/delete-${kebab}.use-case'
-import { create${pascal}Schema } from '../application/dtos/create-${kebab}.dto'
-import { update${pascal}Schema } from '../application/dtos/update-${kebab}.dto'
-import { ${pascal.toUpperCase()}_QUERY_CONFIG } from '../constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${pascal}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${pascal}Controller {
-  @Autowired() private readonly create${pascal}UseCase!: Create${pascal}UseCase
-  @Autowired() private readonly get${pascal}UseCase!: Get${pascal}UseCase
-  @Autowired() private readonly list${pluralPascal}UseCase!: List${pluralPascal}UseCase
-  @Autowired() private readonly update${pascal}UseCase!: Update${pascal}UseCase
-  @Autowired() private readonly delete${pascal}UseCase!: Delete${pascal}UseCase
-
-  @Get('/')
-  @ApiTags('${pascal}')
-  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${pascal}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.list${pluralPascal}UseCase.execute(parsed),
-      ${pascal.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${pascal}')
-  async getById(ctx: Ctx<KickRoutes.${pascal}Controller['getById']>) {
-    const result = await this.get${pascal}UseCase.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${pascal} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
-  @ApiTags('${pascal}')
-  async create(ctx: Ctx<KickRoutes.${pascal}Controller['create']>) {
-    const result = await this.create${pascal}UseCase.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
-  @ApiTags('${pascal}')
-  async update(ctx: Ctx<KickRoutes.${pascal}Controller['update']>) {
-    const result = await this.update${pascal}UseCase.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${pascal}')
-  async remove(ctx: Ctx<KickRoutes.${pascal}Controller['remove']>) {
-    await this.delete${pascal}UseCase.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`;
-}
-function genRepositoryInterface(pascal, kebab, tokenScope) {
-	return `import { createToken } from '@forinda/kickjs'
-import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
-import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
-import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-export interface I${pascal}Repository {
-  findById(id: string): Promise<${pascal}ResponseDTO | null>
-  findAll(): Promise<${pascal}ResponseDTO[]>
-  findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }>
-  create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO>
-  update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO>
-  delete(id: string): Promise<void>
-}
-
-/**
- * Collision-safe DI token bound to \`I${pascal}Repository\`.
- * \`container.resolve(${pascal.toUpperCase()}_REPOSITORY)\` and
- * \`@Inject(${pascal.toUpperCase()}_REPOSITORY)\` both return the typed
- * interface — no manual generic, no \`any\` cast.
- *
- * The \`'${tokenScope}/'\` prefix matches the project scope so
- * \`kick-lint\`'s \`token-reserved-prefix\` rule never fires —
- * adopters must NOT use the reserved \`'kick/'\` namespace.
- */
-export const ${pascal.toUpperCase()}_REPOSITORY = createToken<I${pascal}Repository>('${tokenScope}/${kebab}/repository')
-`;
-}
-function genDomainService(pascal, kebab) {
-	return `import { Service, Inject, HttpException } from '@forinda/kickjs'
-import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../repositories/${kebab}.repository'
-
-@Service()
-export class ${pascal}DomainService {
-  constructor(
-    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
-  ) {}
-
-  async ensureExists(id: string): Promise<void> {
-    const entity = await this.repo.findById(id)
-    if (!entity) throw HttpException.notFound('${pascal} not found')
-  }
-}
-`;
-}
-function genUseCases(pascal, kebab, plural, pluralPascal) {
-	return [
-		{
-			file: `create-${kebab}.use-case.ts`,
-			content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-import type { Create${pascal}DTO } from '../dtos/create-${kebab}.dto'
-
-@Service()
-export class Create${pascal}UseCase {
-  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
-  async execute(dto: Create${pascal}DTO) { return this.repo.create(dto) }
-}
-`
-		},
-		{
-			file: `get-${kebab}.use-case.ts`,
-			content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-
-@Service()
-export class Get${pascal}UseCase {
-  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
-  async execute(id: string) { return this.repo.findById(id) }
-}
-`
-		},
-		{
-			file: `list-${plural}.use-case.ts`,
-			content: `import { Service, Inject } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-
-@Service()
-export class List${pluralPascal}UseCase {
-  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
-  async execute(parsed: ParsedQuery) { return this.repo.findPaginated(parsed) }
-}
-`
-		},
-		{
-			file: `update-${kebab}.use-case.ts`,
-			content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-import type { Update${pascal}DTO } from '../dtos/update-${kebab}.dto'
-
-@Service()
-export class Update${pascal}UseCase {
-  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
-  async execute(id: string, dto: Update${pascal}DTO) { return this.repo.update(id, dto) }
-}
-`
-		},
-		{
-			file: `delete-${kebab}.use-case.ts`,
-			content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-
-@Service()
-export class Delete${pascal}UseCase {
-  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
-  async execute(id: string) { return this.repo.delete(id) }
-}
-`
-		}
-	];
-}
-async function autoRegisterModule(modulesDir, pascal, plural, kebab) {
-	const indexPath = join(modulesDir, "index.ts");
-	const exists = await fileExists(indexPath);
-	const importPath = `./${plural}/${kebab}.module`;
-	if (!exists) {
-		await writeFileSafe(indexPath, `import type { AppModuleClass } from '@forinda/kickjs'\nimport { ${pascal}Module } from '${importPath}'\n\nexport const modules: AppModuleClass[] = [${pascal}Module]\n`);
-		return;
-	}
-	let content = await readFile(indexPath, "utf-8");
-	const importLine = `import { ${pascal}Module } from '${importPath}'`;
-	if (!content.includes(`${pascal}Module`)) {
-		const lastImportIdx = content.lastIndexOf("import ");
-		if (lastImportIdx !== -1) {
-			const lineEnd = content.indexOf("\n", lastImportIdx);
-			content = content.slice(0, lineEnd + 1) + importLine + "\n" + content.slice(lineEnd + 1);
-		} else content = importLine + "\n" + content;
-		content = content.replace(/(=\s*\[)([\s\S]*?)(])/, (_match, open, existing, close) => {
-			const trimmed = existing.trim();
-			if (!trimmed) return `${open}${pascal}Module${close}`;
-			const needsComma = trimmed.endsWith(",") ? "" : ",";
-			return `${open}${existing.trimEnd()}${needsComma} ${pascal}Module${close}`;
-		});
-	}
-	await writeFile(indexPath, content, "utf-8");
-}
-//#endregion
-//#region src/generators/test.ts
-async function generateTest(options) {
-	const { name, moduleName, modulesDir } = options;
-	const shouldPluralize = options.pluralize ?? true;
-	const kebab = toKebabCase(name);
-	const pascal = toPascalCase(name);
-	const files = [];
-	let outDir;
-	if (options.outDir) outDir = resolve(options.outDir);
-	else if (moduleName) {
-		const modKebab = toKebabCase(moduleName);
-		const modFolder = shouldPluralize ? pluralize(modKebab) : modKebab;
-		outDir = resolve(join(modulesDir ?? "src/modules", modFolder, "__tests__"));
-	} else outDir = resolve("src/__tests__");
-	const filePath = join(outDir, `${kebab}.test.ts`);
-	await writeFileSafe(filePath, `import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-
-describe('${pascal}', () => {
-  beforeEach(() => {
-    Container.reset()
-  })
-
-  it('should be defined', () => {
-    // TODO: Import and test your class/function here
-    expect(true).toBe(true)
-  })
-
-  it('should handle the happy path', async () => {
-    // TODO: Set up test data and assertions
-    expect(true).toBe(true)
-  })
-
-  it('should handle edge cases', async () => {
-    // TODO: Test error handling, empty inputs, etc.
-    expect(true).toBe(true)
-  })
-})
-`);
-	files.push(filePath);
-	return files;
-}
-//#endregion
-//#region src/commands/generate.ts
-const AGENT_DOCS_ONLY_VALUES = [
-	"agents",
-	"claude",
-	"skills",
-	"both",
-	"all"
-];
-/** Check if --dry-run was passed on the parent generate command */
-function isDryRun(cmd) {
-	return (cmd.parent?.opts())?.dryRun ?? false;
-}
-function printGenerated(files, dryRun = false) {
-	const cwd = process.cwd();
-	console.log(`\n  ${dryRun ? "Would generate" : "Generated"} ${files.length} file${files.length === 1 ? "" : "s"}:`);
-	for (const f of files) console.log(`    ${f.replace(cwd + "/", "")}`);
-	if (dryRun) console.log("\n  (dry run — no files were written)");
-	console.log();
-}
-/**
-* Refresh `.kickjs/types/*` after a generator that emitted controllers,
-* so the new `Ctx<KickRoutes.X['method']>` references resolve in the
-* user's editor without waiting for `kick dev`.
-*
-* Loads `kick.config.ts` for `typegen.schemaValidator`. Failures are
-* non-fatal — typegen problems should never block code generation.
-*/
-async function runPostTypegen(dryRun) {
-	if (dryRun) return;
-	try {
-		const cfg = await loadKickConfig(process.cwd());
-		await runTypegen$1({
-			cwd: process.cwd(),
-			allowDuplicates: true,
-			silent: true,
-			schemaValidator: cfg?.typegen?.schemaValidator ?? "zod",
-			envFile: cfg?.typegen?.envFile,
-			srcDir: cfg?.typegen?.srcDir,
-			outDir: cfg?.typegen?.outDir
-		});
-	} catch {}
-}
-const GENERATORS = [
-	{
-		name: "module <name>",
-		description: "Full DDD module (controller, DTOs, use-cases, repo)"
-	},
-	{
-		name: "scaffold <name> <fields...>",
-		description: "CRUD module from field definitions"
-	},
-	{
-		name: "controller <name>",
-		description: "@Controller() class            [-m module]"
-	},
-	{
-		name: "service <name>",
-		description: "@Service() singleton             [-m module]"
-	},
-	{
-		name: "middleware <name>",
-		description: "Express middleware function     [-m module]"
-	},
-	{
-		name: "guard <name>",
-		description: "Route guard (auth, roles, etc.)  [-m module]"
-	},
-	{
-		name: "dto <name>",
-		description: "Zod DTO schema                  [-m module]"
-	},
-	{
-		name: "adapter <name>",
-		description: "AppAdapter with lifecycle hooks (app-level only)"
-	},
-	{
-		name: "test <name>",
-		description: "Vitest test scaffold            [-m module]"
-	},
-	{
-		name: "job <name>",
-		description: "Queue @Job processor"
-	},
-	{
-		name: "config",
-		description: "Generate kick.config.ts"
-	},
-	{
-		name: "agents",
-		description: "Regenerate AGENTS.md + CLAUDE.md + kickjs-skills.md from upstream templates"
-	}
-];
-async function printGeneratorList() {
-	console.log("\n  Built-in generators:\n");
-	const maxName = Math.max(...GENERATORS.map((g) => g.name.length));
-	for (const g of GENERATORS) console.log(`    kick g ${g.name.padEnd(maxName + 2)} ${g.description}`);
-	const config = await loadKickConfig(process.cwd());
-	const merged = mergeCliPlugins(config?.plugins ?? [], config?.commands ?? []);
-	const discovery = await listPluginGenerators(process.cwd(), merged.generators);
-	if (discovery.generators.length > 0) {
-		console.log("\n  Plugin generators:\n");
-		const pluginMax = Math.max(...discovery.generators.map((g) => `${g.spec.name} <name>`.length));
-		for (const { source, spec } of discovery.generators) {
-			const usage = `${spec.name} <name>`;
-			console.log(`    kick g ${usage.padEnd(pluginMax + 2)} ${spec.description}  [${source}]`);
-		}
-	}
-	if (discovery.failed.length > 0) {
-		console.log("\n  Failed to load:\n");
-		for (const { source, reason } of discovery.failed) console.log(`    ${source} — ${reason}`);
-	}
-	console.log();
-}
-/**
-* Generate one or more modules. Shared by `kick g module <names...>` and
-* the bare `kick g <names...>` shortcut.
-*/
-async function runModuleGeneration(names, opts, dryRun) {
-	const config = await loadKickConfig(process.cwd());
-	const mc = resolveModuleConfig(config);
-	const modulesDir = opts.modulesDir ?? mc.dir ?? "src/modules";
-	const repo = opts.repo ?? resolveRepoType(mc.repo);
-	const pattern = opts.pattern ?? config?.pattern ?? "ddd";
-	const shouldPluralize = opts.pluralize === false ? false : mc.pluralize ?? true;
-	const tokenScope = resolveTokenScope(config, process.cwd());
-	const allFiles = [];
-	for (const name of names) {
-		const files = await generateModule({
-			name,
-			modulesDir: resolve(modulesDir),
-			noEntity: opts.entity === false,
-			noTests: opts.tests === false,
-			repo,
-			minimal: opts.minimal,
-			force: opts.force,
-			pattern,
-			dryRun,
-			pluralize: shouldPluralize,
-			prismaClientPath: mc.prismaClientPath,
-			tokenScope
-		});
-		allFiles.push(...files);
-	}
-	printGenerated(allFiles, dryRun);
-	await runPostTypegen(dryRun);
-}
-function registerGenerateCommand(program) {
-	const gen = program.command("generate [names...]").alias("g").description("Generate code scaffolds — bare form `kick g <name>` is shorthand for `kick g module <name>`").option("--list", "List all available generators").option("--dry-run", "Preview files that would be generated without writing them").option("--no-entity", "Skip entity and value object generation (module shortcut)").option("--no-tests", "Skip test file generation (module shortcut)").option("--repo <type>", "Repository implementation: inmemory | drizzle | prisma").option("--pattern <pattern>", "Override project pattern: rest | ddd | cqrs | minimal").option("--minimal", "Shorthand for --pattern minimal").option("--modules-dir <dir>", "Modules directory").option("--no-pluralize", "Use singular names (skip auto-pluralization)").option("-f, --force", "Overwrite existing files without prompting").action(async (names, opts, cmd) => {
-		if (opts.list) {
-			await printGeneratorList();
-			return;
-		}
-		if (!names || names.length === 0) {
-			gen.help();
-			return;
-		}
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		if (names.length >= 2) {
-			const [generatorName, itemName, ...rest] = names;
-			const cfg = await loadKickConfig(process.cwd());
-			const merged = mergeCliPlugins(cfg?.plugins ?? [], cfg?.commands ?? []);
-			const result = await tryDispatchPluginGenerator({
-				generatorName,
-				itemName,
-				args: rest,
-				flags: opts,
-				cwd: process.cwd()
-			}, merged.generators);
-			if (result) {
-				printGenerated(result.files, dryRun);
-				return;
-			}
-		}
-		await runModuleGeneration(names, opts, dryRun);
-	});
-	gen.command("module <names...>").description("Generate one or more modules (e.g. kick g module user task project)").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--repo <type>", "Repository implementation: inmemory | drizzle | prisma").option("--pattern <pattern>", "Override project pattern: rest | ddd | cqrs | minimal").option("--minimal", "Shorthand for --pattern minimal").option("--modules-dir <dir>", "Modules directory").option("--no-pluralize", "Use singular names (skip auto-pluralization)").option("-f, --force", "Overwrite existing files without prompting").action(async (names, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		await runModuleGeneration(names, opts, dryRun);
-	});
-	gen.command("adapter <name>").description("Generate an AppAdapter with lifecycle hooks and middleware support").option("-o, --out <dir>", "Output directory", "src/adapters").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		printGenerated(await generateAdapter({
-			name,
-			outDir: resolve(opts.out)
-		}), dryRun);
-	});
-	gen.command("plugin <name>").description("Generate a KickPlugin with DI, modules, adapters, middleware, and lifecycle hooks").option("-o, --out <dir>", "Output directory", "src/plugins").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		printGenerated(await generatePlugin({
-			name,
-			outDir: resolve(opts.out)
-		}), dryRun);
-	});
-	gen.command("middleware <name>").description("Generate an Express middleware function\n  Use -m to scope it to a module: kick g middleware auth -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const config = await loadKickConfig(process.cwd());
-		const mc = resolveModuleConfig(config);
-		const modulesDir = mc.dir ?? "src/modules";
-		printGenerated(await generateMiddleware({
-			name,
-			outDir: opts.out,
-			moduleName: opts.module,
-			modulesDir,
-			pattern: config?.pattern,
-			pluralize: mc.pluralize ?? true
-		}), dryRun);
-	});
-	gen.command("guard <name>").description("Generate a route guard (auth, roles, etc.)\n  Use -m to scope it to a module: kick g guard admin -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const config = await loadKickConfig(process.cwd());
-		const mc = resolveModuleConfig(config);
-		const modulesDir = mc.dir ?? "src/modules";
-		printGenerated(await generateGuard({
-			name,
-			outDir: opts.out,
-			moduleName: opts.module,
-			modulesDir,
-			pattern: config?.pattern,
-			pluralize: mc.pluralize ?? true
-		}), dryRun);
-	});
-	gen.command("service <name>").description("Generate a @Service() class\n  Use -m to scope it to a module: kick g service payment -m orders").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const config = await loadKickConfig(process.cwd());
-		const mc = resolveModuleConfig(config);
-		const modulesDir = mc.dir ?? "src/modules";
-		printGenerated(await generateService({
-			name,
-			outDir: opts.out,
-			moduleName: opts.module,
-			modulesDir,
-			pattern: config?.pattern,
-			pluralize: mc.pluralize ?? true
-		}), dryRun);
-	});
-	gen.command("controller <name>").description("Generate a @Controller() class with basic routes\n  Use -m to scope it to a module: kick g controller auth -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const config = await loadKickConfig(process.cwd());
-		const mc = resolveModuleConfig(config);
-		const modulesDir = mc.dir ?? "src/modules";
-		printGenerated(await generateController({
-			name,
-			outDir: opts.out,
-			moduleName: opts.module,
-			modulesDir,
-			pattern: config?.pattern,
-			pluralize: mc.pluralize ?? true
-		}), dryRun);
-		await runPostTypegen(dryRun);
-	});
-	gen.command("dto <name>").description("Generate a Zod DTO schema\n  Use -m to scope it to a module: kick g dto create-user -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const config = await loadKickConfig(process.cwd());
-		const mc = resolveModuleConfig(config);
-		const modulesDir = mc.dir ?? "src/modules";
-		printGenerated(await generateDto({
-			name,
-			outDir: opts.out,
-			moduleName: opts.module,
-			modulesDir,
-			pattern: config?.pattern,
-			pluralize: mc.pluralize ?? true
-		}), dryRun);
-	});
-	gen.command("test <name>").description("Generate a Vitest test scaffold\n  Use -m to scope it to a module: kick g test user-service -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module's __tests__/ folder").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const mc = resolveModuleConfig(await loadKickConfig(process.cwd()));
-		const modulesDir = mc.dir ?? "src/modules";
-		printGenerated(await generateTest({
-			name,
-			outDir: opts.out,
-			moduleName: opts.module,
-			modulesDir,
-			pluralize: mc.pluralize ?? true
-		}), dryRun);
-	});
-	gen.command("job <name>").description("Generate a @Job queue processor with @Process handlers").option("-o, --out <dir>", "Output directory", "src/jobs").option("-q, --queue <name>", "Queue name (default: <name>-queue)").action(async (name, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		printGenerated(await generateJob({
-			name,
-			outDir: resolve(opts.out),
-			queue: opts.queue
-		}), dryRun);
-	});
-	gen.command("scaffold <name> [fields...]").description("Generate a full CRUD module from field definitions\n  Example: kick g scaffold Post title:string body:text:optional published:boolean:optional\n  Types: string, text, number, int, float, boolean, date, email, url, uuid, json, enum:a,b,c\n  Optional: append :optional (shell-safe):  description:text:optional\n            or use ? with quoting:           \"description:text?\" or \"description?:text\"").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--no-pluralize", "Use singular names (skip auto-pluralization)").option("--modules-dir <dir>", "Modules directory").action(async (name, rawFields, opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		if (rawFields.length === 0) {
-			console.error("\n  Error: At least one field is required.\n  Usage: kick g scaffold <name> <field:type> [field:type...]\n  Example: kick g scaffold Post title:string body:text:optional published:boolean:optional\n  Optional: append :optional (shell-safe, no quoting needed)\n");
-			process.exit(1);
-		}
-		const config = await loadKickConfig(process.cwd());
-		const mc = resolveModuleConfig(config);
-		const modulesDir = opts.modulesDir ?? mc.dir ?? "src/modules";
-		const fields = parseFields(rawFields);
-		const tokenScope = resolveTokenScope(config, process.cwd());
-		const files = await generateScaffold({
-			name,
-			fields,
-			modulesDir: resolve(modulesDir),
-			noEntity: opts.entity === false,
-			noTests: opts.tests === false,
-			pluralize: opts.pluralize === false ? false : mc.pluralize ?? true,
-			tokenScope
-		});
-		console.log(`\n  Scaffolded ${name} with ${fields.length} field(s):`);
-		for (const f of fields) console.log(`    ${f.name}: ${f.type}${f.optional ? " (optional)" : ""}`);
-		printGenerated(files, dryRun);
-		await runPostTypegen(dryRun);
-	});
-	gen.command("auth-scaffold").description("Generate a complete auth module (register, login, logout, password hashing)\n  Includes controller, service, DTOs, and test stubs.").option("-s, --strategy <type>", "Auth strategy: jwt | session").option("--role-guards", "Generate role-based guards (default: true)").option("--no-role-guards", "Skip role-based guard generation").option("-o, --out <dir>", "Output directory", "src/modules/auth").action(async (opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		let strategy = opts.strategy;
-		if (!strategy) strategy = await select({
-			message: "Auth strategy",
-			options: [{
-				value: "jwt",
-				label: "JWT",
-				hint: "stateless token-based auth"
-			}, {
-				value: "session",
-				label: "Session",
-				hint: "server-side session with cookies"
-			}]
-		});
-		let roleGuards = opts.roleGuards;
-		if (roleGuards === void 0) roleGuards = await confirm({
-			message: "Generate role-based guards?",
-			initialValue: true
-		});
-		printGenerated(await generateAuthScaffold({
-			strategy,
-			outDir: opts.out,
-			roleGuards
-		}), dryRun);
-	});
-	gen.command("config").description("Generate a kick.config.ts at the project root").option("--modules-dir <dir>", "Modules directory path", "src/modules").option("--repo <type>", "Default repository type: inmemory | drizzle | prisma", "inmemory").option("-f, --force", "Overwrite existing kick.config.ts without prompting").action(async (opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		printGenerated(await generateConfig({
-			outDir: resolve("."),
-			modulesDir: opts.modulesDir,
-			defaultRepo: opts.repo,
-			force: opts.force
-		}), dryRun);
-	});
-	gen.command("agents").alias("agent-docs").alias("ai-docs").description("Regenerate AGENTS.md + CLAUDE.md + kickjs-skills.md (sync after framework upgrades)").option("--only <which>", "Limit scope: agents | claude | skills | both (agents+claude) | all (default: all)", "all").option("--name <name>", "Project name (defaults to package.json name)").option("--pm <pm>", "Package manager (defaults to package.json packageManager)").option("--template <template>", "Template: rest | ddd | cqrs | minimal").option("-f, --force", "Overwrite existing files without prompting").action(async (opts, cmd) => {
-		const dryRun = isDryRun(cmd);
-		setDryRun(dryRun);
-		const only = opts.only ?? "all";
-		if (!AGENT_DOCS_ONLY_VALUES.includes(only)) {
-			console.error(`  Invalid --only value: ${only}. Expected: ${AGENT_DOCS_ONLY_VALUES.join(" | ")}`);
-			process.exitCode = 1;
-			return;
-		}
-		printGenerated(await generateAgentDocs({
-			outDir: resolve("."),
-			only,
-			name: opts.name,
-			pm: opts.pm,
-			template: opts.template,
-			force: opts.force
-		}), dryRun);
-	});
-}
-//#endregion
-//#region src/utils/shell.ts
-/**
-* Cross-platform way to launch a Node.js process with a set of
-* environment variables. Uses `spawnSync` with an argument array so no
-* shell is involved — the `VAR=value node ...` POSIX prefix syntax that
-* `runShellCommand` relied on breaks on cmd.exe and PowerShell.
-*/
-function runNodeWithEnv(entry, env, cwd) {
-	const result = spawnSync(process.execPath, [entry], {
-		cwd,
-		stdio: "inherit",
-		env: {
-			...process.env,
-			...env
-		}
-	});
-	if (result.status !== 0) process.exit(result.status ?? 1);
-}
-//#endregion
-//#region src/typegen/runner.ts
-const TYPES_DIR = ".kickjs/types";
-const BANNER_PREFIX = "/* AUTO-GENERATED by kick typegen — do not edit. Plugin: ";
-async function runTypegen(opts) {
-	const typesDirAbs = path.resolve(opts.cwd, TYPES_DIR);
-	await mkdir(typesDirAbs, { recursive: true });
-	const scanCache = /* @__PURE__ */ new Map();
-	const scanFn = opts.scan ?? scanProject;
-	const getScanResult = (scanOpts) => {
-		const key = stableScanKey(scanOpts);
-		let pending = scanCache.get(key);
-		if (!pending) {
-			pending = scanFn(scanOpts);
-			scanCache.set(key, pending);
-		}
-		return pending;
-	};
-	const ctx = {
-		cwd: opts.cwd,
-		config: opts.config,
-		async importTs(abs) {
-			return await import(pathToFileURL(abs).href);
-		},
-		async writeFile(relPath, contents) {
-			const abs = path.resolve(opts.cwd, relPath);
-			await mkdir(path.dirname(abs), { recursive: true });
-			await writeFile(abs, contents, "utf8");
-		},
-		getScanResult,
-		log: console
-	};
-	const results = [];
-	for (const plugin of opts.plugins) {
-		const out = await plugin.generate(ctx);
-		if (out === null) {
-			results.push({
-				id: plugin.id,
-				status: "skipped"
-			});
-			continue;
-		}
-		const ext = plugin.outExtension ?? ".d.ts";
-		const file = path.join(typesDirAbs, `${plugin.id.replace(/\//g, "__")}${ext}`);
-		const next = `${BANNER_PREFIX}${plugin.id} */\n\n` + out + "\n";
-		let prev = "";
-		if (existsSync(file)) prev = await readFile(file, "utf8");
-		if (prev === next) {
-			results.push({
-				id: plugin.id,
-				status: "unchanged",
-				outFile: file
-			});
-			continue;
-		}
-		if (opts.check) throw new Error(`kick typegen --check: drift detected for ${plugin.id} (${file})`);
-		await writeFile(file, next, "utf8");
-		results.push({
-			id: plugin.id,
-			status: "written",
-			outFile: file
-		});
-	}
-	return results;
-}
-/**
-* Order-independent cache key for `ScanOptions`. Builds the key from
-* the known fields in a fixed order so semantically equal options
-* always produce the same key regardless of how the caller built the
-* object literal. Arrays (extensions / exclude) are sorted before
-* joining so `['.ts', '.tsx']` and `['.tsx', '.ts']` collide.
-*/
-function stableScanKey(opts) {
-	const extensions = (opts.extensions ?? []).slice().toSorted().join(",");
-	const exclude = (opts.exclude ?? []).slice().toSorted().join(",");
-	return [
-		`root=${opts.root}`,
-		`cwd=${opts.cwd}`,
-		`extensions=${extensions}`,
-		`exclude=${exclude}`,
-		`envFile=${opts.envFile ?? ""}`
-	].join("|");
-}
-//#endregion
-//#region src/typegen/disable-filter.ts
-/**
-* Returns three buckets:
-*   - `enabled`: plugins that should run
-*   - `skipped`: plugins explicitly disabled by id
-*   - `unknown`: disable ids that didn't match any registered plugin
-*     — surfaced as a warning to catch typos without breaking the run
-*/
-function applyDisableFilter(typegens, disable) {
-	const disabledSet = new Set(disable);
-	const enabled = [];
-	const skipped = [];
-	const matchedDisable = /* @__PURE__ */ new Set();
-	for (const tg of typegens) if (disabledSet.has(tg.id)) {
-		skipped.push(tg);
-		matchedDisable.add(tg.id);
-	} else enabled.push(tg);
-	return {
-		enabled,
-		skipped,
-		unknown: [...disabledSet].filter((id) => !matchedDisable.has(id))
-	};
-}
-//#endregion
-//#region src/typegen/run-plugins.ts
-async function runAllPluginTypegens(opts) {
-	const { enabled, skipped, unknown } = applyDisableFilter(mergeCliPlugins([...builtinCliPlugins, ...opts.config?.plugins ?? []], opts.config?.commands ?? []).typegens, opts.config?.typegen?.disable ?? []);
-	if (!opts.silent && skipped.length > 0) for (const tg of skipped) console.log(`  ${tg.id}: disabled (typegen.disable)`);
-	if (!opts.silent && unknown.length > 0) console.warn(`  kick typegen: disable list references unknown id(s): ${unknown.map((id) => `'${id}'`).join(", ")}. Run \`kick typegen --list\` to see registered ids.`);
-	if (enabled.length === 0) return [];
-	try {
-		const results = await runTypegen({
-			cwd: opts.cwd,
-			config: opts.config ?? {},
-			plugins: enabled,
-			check: opts.check
-		});
-		if (!opts.silent) for (const r of results) console.log(`  ${r.id}: ${r.status}`);
-		return results;
-	} catch (err) {
-		if (!opts.silent) {
-			const msg = err instanceof Error ? err.message : String(err);
-			console.warn(`  kick typegen plugins: skipped (${msg})`);
-		}
-		return [];
-	}
-}
-/**
-* Run the full asset build for a loaded config:
-*
-* 1. For each `assetMap` entry, glob → copy → manifest stub.
-* 2. Write `dist/.kickjs-assets.json`.
-*
-* Returns a summary including the manifest contents. No-op (and no
-* manifest written) when `assetMap` is empty / missing — the build
-* pipeline shouldn't litter `dist/` with empty manifests for
-* adopters who don't use the feature.
-*/
-async function buildAssets(config, opts) {
-	const { cwd, silent = false } = opts;
-	const distDir = opts.distDir ?? config?.build?.outDir ?? "dist";
-	const map = config?.assetMap;
-	if (!map || Object.keys(map).length === 0) return null;
-	const log = silent ? () => {} : console.log;
-	const distAbs = resolve(cwd, distDir);
-	mkdirSync(distAbs, { recursive: true });
-	const summary = [];
-	const manifestEntries = {};
-	for (const [namespace, entry] of Object.entries(map)) {
-		const result = await processEntry(namespace, entry, cwd, distAbs);
-		summary.push(result.entrySummary);
-		Object.assign(manifestEntries, result.manifestSlice);
-		log(`    ✓ ${namespace}: ${result.entrySummary.filesCopied} file(s) → ${result.entrySummary.dest}`);
-	}
-	const manifest = {
-		version: 1,
-		entries: manifestEntries
-	};
-	const manifestPath = join(distAbs, ".kickjs-assets.json");
-	writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
-	log(`    ✓ wrote manifest → ${relative(cwd, manifestPath)} (${Object.keys(manifestEntries).length} entries)`);
-	return {
-		manifestPath,
-		entries: summary,
-		manifest
-	};
-}
-/** Per-entry inner pipeline — extracted for unit-test reuse. */
-async function processEntry(namespace, entry, cwd, distAbs) {
-	const srcAbs = resolve(cwd, entry.src);
-	const destAbs = entry.dest ? resolve(cwd, entry.dest) : join(distAbs, namespace);
-	if (escapesRoot(destAbs, cwd)) {
-		console.warn(`  ⚠ assetMap.${namespace}.dest ('${entry.dest}') resolves outside the project root — skipping copy`);
-		return {
-			entrySummary: {
-				namespace,
-				src: entry.src,
-				dest: relative(cwd, destAbs),
-				filesCopied: 0
-			},
-			manifestSlice: {}
-		};
-	}
-	if (!existsSync(srcAbs) || !isDirectorySync(srcAbs)) return {
-		entrySummary: {
-			namespace,
-			src: entry.src,
-			dest: relative(cwd, destAbs),
-			filesCopied: 0
-		},
-		manifestSlice: {}
-	};
-	const matches = await glob(entry.glob ?? "**/*", {
-		cwd: srcAbs,
-		nodir: true,
-		dot: false,
-		posix: true
-	});
-	mkdirSync(destAbs, { recursive: true });
-	const manifestSlice = {};
-	const { pairs, collisionGroupsResolved } = groupAssetKeys(namespace, [...matches].toSorted(), { strategy: entry.keys ?? "auto" });
-	for (const { rel: relPath, key } of pairs) {
-		const srcFile = join(srcAbs, relPath);
-		const destFile = join(destAbs, relPath);
-		mkdirSync(dirname(destFile), { recursive: true });
-		cpSync(srcFile, destFile);
-		manifestSlice[key] = toManifestRelative(distAbs, destFile);
-	}
-	if (collisionGroupsResolved > 0) console.log(`  ℹ assetMap.${namespace}: auto-resolved ${collisionGroupsResolved} basename collision(s) by keeping extensions (set 'keys: "strip"' to opt back into legacy last-write-wins behaviour, or 'keys: "with-extension"' to keep all keys verbose).`);
-	return {
-		entrySummary: {
-			namespace,
-			src: entry.src,
-			dest: relative(cwd, destAbs),
-			filesCopied: matches.length
-		},
-		manifestSlice
-	};
-}
-/**
-* Make `destFile` relative to the manifest's directory + force POSIX
-* separators so the manifest is byte-stable across platforms.
-*/
-function toManifestRelative(manifestDir, destFile) {
-	return relative(manifestDir, destFile).split(/[\\/]/).filter(Boolean).join("/");
-}
-/**
-* Project-root escape check that's safe across symlinks + drive letters.
-* `path.relative` returns `..` segments when the target sits above root,
-* and an absolute path when the two live on different roots (Windows).
-* `startsWith(root)` would miss both cases.
-*/
-function escapesRoot(path, root) {
-	const rel = relative(root, path);
-	if (rel === "") return false;
-	return rel.startsWith("..") || isAbsolute(rel);
-}
-/** Pure helper — `false` for missing, non-dir, or unreadable paths. */
-function isDirectorySync(path) {
-	try {
-		return statSync(path).isDirectory();
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/commands/run.ts
-/**
-* Start the Vite dev server with @forinda/kickjs-vite plugin.
-*
-* The plugin (configured in the user's vite.config.ts) handles:
-* - SSR environment setup (kickjs:core)
-* - Module auto-discovery (kickjs:module-discovery)
-* - Selective HMR invalidation (kickjs:hmr)
-* - Virtual module generation (kickjs:virtual-modules)
-* - Express mounting + httpServer piping (kickjs:dev-server)
-*
-* This function just creates the Vite server, listens, and handles shutdown.
-* Vite owns the HTTP port — Express runs as post-middleware on Vite's server.
-*/
-/**
-* Resolve whether the dev server's chokidar should poll instead of
-* relying on `fs.watch` events. CLI flag wins over env var; default
-* is event-based (faster, lower CPU). Polling is the right choice in
-* Docker bind mounts, WSL crossing the WSL/Windows boundary, NFS,
-* and some old Linux kernels where new-file events get dropped.
-*/
-function resolvePolling(flag) {
-	if (typeof flag === "boolean") return flag;
-	const env = process.env.KICKJS_WATCH_POLLING;
-	return env === "1" || env === "true";
-}
-async function startDevServer(_entry, port, opts = {}) {
-	if (port) process.env.PORT = port;
-	const polling = resolvePolling(opts.polling);
-	const cwd = process.cwd();
-	const devConfig = await loadKickConfig(cwd);
-	const schemaValidator = devConfig?.typegen?.schemaValidator ?? "zod";
-	const envFile = devConfig?.typegen?.envFile;
-	try {
-		await runTypegen$1({
-			cwd,
-			allowDuplicates: true,
-			schemaValidator,
-			envFile,
-			srcDir: devConfig?.typegen?.srcDir,
-			outDir: devConfig?.typegen?.outDir,
-			assetMap: devConfig?.assetMap,
-			runPlugins: false
-		});
-	} catch (err) {
-		console.warn(`  kick typegen: skipped (${err?.message ?? err})`);
-	}
-	await runAllPluginTypegens({
-		cwd,
-		config: devConfig
-	});
-	const { createRequire } = await import("node:module");
-	const { createServer } = await import(pathToFileURL(createRequire(resolve("package.json")).resolve("vite")).href);
-	const server = await createServer({
-		configFile: resolve("vite.config.ts"),
-		server: {
-			port: port ? parseInt(port, 10) : void 0,
-			...polling ? { watch: {
-				usePolling: true,
-				interval: 100
-			} } : {}
-		}
-	});
-	const assetSrcRoots = devConfig?.assetMap ? Object.values(devConfig.assetMap).map((entry) => entry?.src).filter((src) => typeof src === "string" && src.length > 0).map((src) => resolve(cwd, src)) : [];
-	const isAssetFile = (file) => assetSrcRoots.some((root) => file === root || file.startsWith(`${root}/`));
-	let typegenTimer = null;
-	const scheduleTypegen = (file) => {
-		if (file.includes(".kickjs")) return;
-		if (file.endsWith(".d.ts")) return;
-		const isTs = /\.(ts|tsx|mts|cts)$/.test(file);
-		const isAsset = isAssetFile(file);
-		if (!isTs && !isAsset) return;
-		if (typegenTimer) clearTimeout(typegenTimer);
-		typegenTimer = setTimeout(() => {
-			runTypegen$1({
-				cwd,
-				silent: true,
-				allowDuplicates: true,
-				schemaValidator,
-				envFile,
-				srcDir: devConfig?.typegen?.srcDir,
-				outDir: devConfig?.typegen?.outDir,
-				assetMap: devConfig?.assetMap,
-				runPlugins: false
-			}).catch(() => {});
-			runAllPluginTypegens({
-				cwd,
-				config: devConfig,
-				silent: true
-			}).catch(() => {});
-		}, 100);
-	};
-	server.watcher.on("add", scheduleTypegen);
-	server.watcher.on("unlink", scheduleTypegen);
-	server.watcher.on("change", scheduleTypegen);
-	if (assetSrcRoots.length > 0) server.watcher.add(assetSrcRoots);
-	await server.listen();
-	server.printUrls();
-	console.log(`\n  KickJS dev server running (Vite + @forinda/kickjs-vite)\n`);
-	const shutdown = async () => {
-		if (typegenTimer) clearTimeout(typegenTimer);
-		await server.close();
-		process.exit(0);
-	};
-	process.on("SIGINT", shutdown);
-	process.on("SIGTERM", shutdown);
-}
-function registerRunCommands(program) {
-	program.command("dev").description("Start development server with Vite HMR (zero-downtime reload)").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").option("--polling", "Force chokidar to poll for file changes (Docker / WSL / NFS / older kernels)").action(async (opts) => {
-		try {
-			await startDevServer(opts.entry, opts.port, { polling: opts.polling });
-		} catch (err) {
-			if (err.code === "ERR_MODULE_NOT_FOUND" && err.message?.includes("vite")) console.error("\n  Error: vite is not installed.\n  Run: pnpm add -D vite unplugin-swc\n");
-			else console.error("\n  Dev server failed:", err.message ?? err);
-			process.exit(1);
-		}
-	});
-	program.command("build").description("Build for production via Vite").action(async () => {
-		console.log("\n  Building for production...\n");
-		const { createRequire } = await import("node:module");
-		const { build } = await import(pathToFileURL(createRequire(resolve("package.json")).resolve("vite")).href);
-		await build({ configFile: resolve("vite.config.ts") });
-		const config = await loadKickConfig(process.cwd());
-		const copyDirs = config?.copyDirs ?? [];
-		if (copyDirs.length > 0) {
-			console.log("\n  Copying directories to dist...");
-			for (const entry of copyDirs) {
-				const src = typeof entry === "string" ? entry : entry.src;
-				const dest = typeof entry === "string" ? join("dist", entry) : entry.dest ?? join("dist", src);
-				const srcPath = resolve(src);
-				const destPath = resolve(dest);
-				if (!existsSync(srcPath)) {
-					console.log(`    ⚠ Skipped ${src} (not found)`);
-					continue;
-				}
-				mkdirSync(destPath, { recursive: true });
-				cpSync(srcPath, destPath, { recursive: true });
-				console.log(`    ✓ ${src} → ${dest}`);
-			}
-		}
-		if (config?.assetMap && Object.keys(config.assetMap).length > 0) {
-			console.log("\n  Building asset map...");
-			try {
-				await buildAssets(config, { cwd: process.cwd() });
-			} catch (err) {
-				console.error(`    ✗ asset build failed: ${err instanceof Error ? err.message : String(err)}`);
-				process.exit(1);
-			}
-		}
-		console.log("\n  Build complete.\n");
-	});
-	program.command("build:assets").description("Rebuild the .kickjs-assets.json manifest under the configured outDir (no JS rebuild)").action(async () => {
-		const config = await loadKickConfig(process.cwd());
-		if (!config?.assetMap || Object.keys(config.assetMap).length === 0) {
-			console.log("  No assetMap entries — nothing to build.");
-			return;
-		}
-		console.log("\n  Building asset map...");
-		try {
-			await buildAssets(config, { cwd: process.cwd() });
-			console.log("\n  Asset build complete.\n");
-		} catch (err) {
-			console.error(`  ✗ ${err instanceof Error ? err.message : String(err)}`);
-			process.exit(1);
-		}
-	});
-	program.command("start").description("Start production server").option("-e, --entry <file>", "Entry file", "dist/index.js").option("-p, --port <port>", "Port number").action((opts) => {
-		const env = { NODE_ENV: "production" };
-		if (opts.port) env.PORT = String(opts.port);
-		runNodeWithEnv(opts.entry, env);
-	});
-	program.command("dev:debug").description("Start dev server with Node.js inspector attached").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").option("--inspect-port <port>", "Inspector port", "9229").action(async (opts) => {
-		const inspectPort = opts.inspectPort ?? "9229";
-		process.env.NODE_OPTIONS = `--inspect=0.0.0.0:${inspectPort}`;
-		console.log(`  Debugger: ws://0.0.0.0:${inspectPort}`);
-		try {
-			await startDevServer(opts.entry, opts.port);
-		} catch (err) {
-			console.error("\n  Dev server (debug) failed:", err.message ?? err);
-			process.exit(1);
-		}
-	});
-}
-//#endregion
-//#region src/commands/info.ts
-function registerInfoCommand(program) {
-	program.command("info").description("Print system and framework info").action(() => {
-		console.log(`
-  KickJS CLI
-
-  System:
-    OS:       ${platform()} ${release()} (${arch()})
-    Node:     ${process.version}
-
-  Packages:
-    @forinda/kickjs          workspace
-    @forinda/kickjs-vite     workspace
-    @forinda/kickjs-cli      workspace
-`);
-	});
-}
-//#endregion
-//#region src/commands/inspect.ts
-const { bold, dim, green, red, yellow, blue } = pc;
-function formatUptime(seconds) {
-	const d = Math.floor(seconds / 86400);
-	const h = Math.floor(seconds % 86400 / 3600);
-	const m = Math.floor(seconds % 3600 / 60);
-	const s = seconds % 60;
-	const parts = [];
-	if (d) parts.push(`${d}d`);
-	if (h) parts.push(`${h}h`);
-	if (m) parts.push(`${m}m`);
-	parts.push(`${s}s`);
-	return parts.join(" ");
-}
-async function fetchJson(url) {
-	const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
-	if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
-	return res.json();
-}
-async function fetchEndpoint(base, path) {
-	try {
-		return await fetchJson(`${base}${path}`);
-	} catch {
-		return null;
-	}
-}
-async function fetchAll(base) {
-	const [health, metrics, routes, container, ws] = await Promise.all([
-		fetchEndpoint(base, "/health"),
-		fetchEndpoint(base, "/metrics"),
-		fetchEndpoint(base, "/routes"),
-		fetchEndpoint(base, "/container"),
-		fetchEndpoint(base, "/ws")
-	]);
-	return {
-		health,
-		metrics,
-		routes,
-		container,
-		ws
-	};
-}
-function printSummary(base, data) {
-	const { health, metrics, routes, container, ws } = data;
-	const line = dim("─".repeat(60));
-	console.log();
-	console.log(bold(`  KickJS Inspector`) + dim(`  →  ${base}`));
-	console.log(line);
-	if (health) {
-		const statusText = health.status === "healthy" ? green("● healthy") : red("● " + health.status);
-		console.log(`  ${bold("Health:")}    ${statusText}`);
-	} else console.log(`  ${bold("Health:")}    ${red("● unreachable")}`);
-	if (metrics) {
-		const rate = ((metrics.errorRate ?? 0) * 100).toFixed(1);
-		const rateColor = metrics.errorRate > .1 ? red : metrics.errorRate > 0 ? yellow : green;
-		console.log(`  ${bold("Uptime:")}    ${formatUptime(metrics.uptimeSeconds)}`);
-		console.log(`  ${bold("Requests:")}  ${metrics.requests}`);
-		console.log(`  ${bold("Errors:")}    ${metrics.serverErrors} server, ${metrics.clientErrors ?? 0} client  ${dim("(")}${rateColor(rate + "%")}${dim(")")}`);
-	}
-	if (container) console.log(`  ${bold("DI:")}        ${container.count} bindings`);
-	if (ws && ws.enabled) console.log(`  ${bold("WS:")}        ${ws.connections ?? 0} connections, ${ws.namespaces ?? 0} namespaces`);
-	if (routes?.routes?.length) {
-		console.log();
-		console.log(bold("  Routes"));
-		console.log(line);
-		console.log(`  ${dim("METHOD")}  ${dim("PATH".padEnd(36))} ${dim("CONTROLLER")}`);
-		for (const r of routes.routes) {
-			const path = r.path.length > 36 ? r.path.slice(0, 33) + "..." : r.path.padEnd(36);
-			console.log(`  ${httpMethodColor(r.method)} ${path} ${blue(r.controller)}.${dim(r.handler)}`);
-		}
-	}
-	console.log(line);
-	console.log();
-}
-function registerInspectCommand(program) {
-	program.command("inspect [url]").description("Connect to a running KickJS app and display debug info").option("-p, --port <port>", "Override port").option("-w, --watch", "Poll every 5 seconds").option("-j, --json", "Output raw JSON").action(async (url, opts) => {
-		let base = url ?? "http://localhost:3000";
-		if (opts.port) try {
-			const parsed = new URL(base);
-			parsed.port = opts.port;
-			base = parsed.origin;
-		} catch {
-			base = `http://localhost:${opts.port}`;
-		}
-		const debugBase = `${base.replace(/\/$/, "")}/_debug`;
-		const run = async () => {
-			try {
-				const data = await fetchAll(debugBase);
-				if (opts.json) console.log(JSON.stringify(data, null, 2));
-				else printSummary(base, data);
-			} catch (err) {
-				if (opts.json) console.log(JSON.stringify({ error: String(err) }));
-				else {
-					console.error(red(`  ✖ Could not connect to ${base}`));
-					console.error(dim(`    ${err instanceof Error ? err.message : String(err)}`));
-				}
-				if (!opts.watch) process.exitCode = 1;
-			}
-		};
-		if (opts.watch) {
-			const poll = async () => {
-				process.stdout.write("\x1B[2J\x1B[H");
-				await run();
-			};
-			await poll();
-			setInterval(poll, 5e3);
-		} else await run();
-	});
-}
-//#endregion
-//#region src/explain/known-issues.ts
-function includesAll(haystack, needles) {
-	const lower = haystack.toLowerCase();
-	return needles.every((n) => lower.includes(n.toLowerCase()));
-}
-function includesAny(haystack, needles) {
-	const lower = haystack.toLowerCase();
-	return needles.some((n) => lower.includes(n.toLowerCase()));
-}
-const KNOWN_ISSUES = [
-	{ match(input, _ctx) {
-		const hasConfigGetUndefined = includesAll(input, ["config", "get"]) && includesAny(input, ["undefined", "null"]);
-		const hasValueUndefined = input.includes("@Value") && includesAny(input, ["undefined", "is not defined"]);
-		if (!hasConfigGetUndefined && !hasValueUndefined) return null;
-		return {
-			confidence: hasConfigGetUndefined && hasValueUndefined ? 90 : 75,
-			diagnosis: {
-				id: "env-schema-not-registered",
-				title: "ConfigService.get() returns undefined for user-defined keys",
-				explanation: "Your src/index.ts is missing `import \"./config\"`. That side-effect import\nregisters the env schema with kickjs at module-load time. Without it,\nConfigService falls back to the base schema (PORT/NODE_ENV/LOG_LEVEL only)\nand every user-defined key reads as undefined. @Value() may *appear* to\nwork via a raw process.env fallback, but Zod coercion and schema defaults\nare silently skipped.",
-				fix: "Add this line to src/index.ts near the top, before bootstrap() runs:",
-				codeBefore: "import 'reflect-metadata'\nimport { bootstrap } from '@forinda/kickjs'\nimport { modules } from './modules'\n",
-				codeAfter: "import 'reflect-metadata'\nimport './config'  // ← add this — registers env schema\nimport { bootstrap } from '@forinda/kickjs'\nimport { modules } from './modules'\n",
-				docs: "https://forinda.github.io/kick-js/guide/configuration.html#wiring-the-schema-at-startup"
-			}
-		};
-	} },
-	{ match(input, _ctx) {
-		const hasTestContext = includesAny(input, [
-			"vitest",
-			"test",
-			"spec",
-			"__tests__",
-			".test."
-		]);
-		if (!includesAny(input, [
-			"already registered",
-			"already exists",
-			"duplicate",
-			"has been registered"
-		])) return null;
-		return {
-			confidence: hasTestContext ? 85 : 60,
-			diagnosis: {
-				id: "container-not-reset-in-tests",
-				title: "DI container leaks between test cases",
-				explanation: "KickJS decorators register classes on the global Container at import time.\nWhen vitest re-imports your modules across tests, the same class can be\nregistered twice and the container throws. The fix is to wipe the\ncontainer between tests so each case starts fresh.",
-				fix: "Add Container.reset() to a beforeEach hook in the failing test file:",
-				codeAfter: "import { describe, it, beforeEach } from 'vitest'\nimport { Container } from '@forinda/kickjs'\n\ndescribe('UserController', () => {\n  beforeEach(() => Container.reset())\n\n  it('does the thing', async () => { /* ... */ })\n})",
-				docs: "https://forinda.github.io/kick-js/guide/testing.html"
-			}
-		};
-	} },
-	{ match(input, _ctx) {
-		if (!(input.includes("@Module") || includesAll(input, ["Module", "is not a function"]) || includesAll(input, ["Module", "no exported member"]))) return null;
-		return {
-			confidence: 80,
-			diagnosis: {
-				id: "module-decorator-not-found",
-				title: "KickJS does not have a @Module decorator (different pattern from NestJS)",
-				explanation: "NestJS uses @Module({ controllers, providers }). KickJS uses an interface\npattern instead: a class implements AppModule and exposes routes() that\nreturns the controller wiring. This was a deliberate choice — modules\nbecome explicit values rather than metadata, which makes them easier to\ncompose, test, and serialize.",
-				fix: "Replace the @Module decorator with an AppModule class:",
-				codeBefore: "import { Module } from '@forinda/kickjs'  // ← does not exist\nimport { UserController } from './user.controller'\n\n@Module({\n  controllers: [UserController],\n})\nexport class UserModule {}",
-				codeAfter: "import { type AppModule, type ModuleRoutes, buildRoutes } from '@forinda/kickjs'\nimport { UserController } from './user.controller'\n\nexport class UserModule implements AppModule {\n  routes(): ModuleRoutes {\n    return {\n      path: '/users',\n      router: buildRoutes(UserController),\n      controller: UserController,\n    }\n  }\n}",
-				docs: "https://forinda.github.io/kick-js/guide/project-structure.html"
-			}
-		};
-	} },
-	{ match(input, _ctx) {
-		if (!/KickRoutes\s*\[\s*['"](GET|POST|PUT|PATCH|DELETE)/i.test(input)) return null;
-		return {
-			confidence: 95,
-			diagnosis: {
-				id: "legacy-kick-routes-bracket-syntax",
-				title: "KickRoutes['POST /users'] is the legacy v1 syntax",
-				explanation: "KickJS v2 changed the typegen output from a flat string-keyed map to a\nnamespaced shape: KickRoutes.UserController[\"create\"] instead of\nKickRoutes[\"POST /users\"]. The new form is per-controller, per-method,\nand matches the actual class names so refactors propagate via\nrename-symbol instead of grep.",
-				fix: "Update the Ctx<...> type parameter to use the namespace form:",
-				codeBefore: "@Post('/', { body: createUserSchema })\ncreate(ctx: Ctx<KickRoutes['POST /users']>) { /* ... */ }",
-				codeAfter: "@Post('/', { body: createUserSchema, name: 'CreateUser' })\ncreate(ctx: Ctx<KickRoutes.UserController['create']>) { /* ... */ }",
-				docs: "https://forinda.github.io/kick-js/guide/typegen.html"
-			}
-		};
-	} },
-	{ match(input, _ctx) {
-		const hasCluster = includesAny(input, [
-			"cluster",
-			"workers",
-			"two ports",
-			"duplicate server"
-		]);
-		const hasDevSignal = includesAny(input, [
-			"kick dev",
-			"vite",
-			"eaddrinuse",
-			"5173",
-			"5174",
-			"two servers"
-		]);
-		if (!hasCluster || !hasDevSignal) return null;
-		return {
-			confidence: 85,
-			diagnosis: {
-				id: "cluster-in-vite-dev",
-				title: "Cluster mode is incompatible with `kick dev` (Vite owns the server)",
-				explanation: "In dev mode, Vite owns the HTTP server. If your bootstrap passes\ncluster: { workers: N }, the framework forks N workers, each of which\nspins up its own Vite instance on a separate port. The fix landed in\nv2.2.5: McpAdapter (and bootstrap()) now detects Vite dev mode and\nsilently skips cluster, with a warning. If you see this on an older\nversion, upgrade or guard the cluster option behind NODE_ENV.",
-				fix: "Either upgrade to v2.2.5+ or gate cluster mode on production:",
-				codeAfter: "export const app = await bootstrap({\n  modules,\n  cluster: process.env.NODE_ENV === 'production' ? { workers: 4 } : false,\n})",
-				docs: "https://forinda.github.io/kick-js/guide/cluster.html"
-			}
-		};
-	} },
-	{ match(input, _ctx) {
-		if (!includesAny(input, [
-			"reflect-metadata",
-			"Reflect.getMetadata is not a function",
-			"Reflect.defineMetadata",
-			"design:type",
-			"design:paramtypes"
-		])) return null;
-		return {
-			confidence: 90,
-			diagnosis: {
-				id: "reflect-metadata-missing",
-				title: "reflect-metadata is not loaded — DI cannot read decorator types",
-				explanation: "The DI container reads constructor parameter types via the\nreflect-metadata polyfill. The polyfill must be imported once,\nbefore any decorator runs. Most projects do this at the top of\nsrc/index.ts; missing the import causes obscure \"design:paramtypes\"\nor \"Reflect.getMetadata is not a function\" errors at runtime.",
-				fix: "Add the import at the very top of src/index.ts:",
-				codeAfter: "import 'reflect-metadata'  // ← must be the FIRST import\nimport './config'\nimport { bootstrap } from '@forinda/kickjs'\nimport { modules } from './modules'\n\nexport const app = await bootstrap({ modules })",
-				docs: "https://forinda.github.io/kick-js/guide/dependency-injection.html"
-			}
-		};
-	} },
-	{ match(input, _ctx) {
-		if (!includesAny(input, [
-			"404",
-			"cannot get",
-			"cannot post",
-			"no route"
-		])) return null;
-		return {
-			confidence: 50,
-			diagnosis: {
-				id: "module-not-registered",
-				title: "A 404 may indicate a module is not in the modules array",
-				explanation: "KickJS only mounts modules listed in `src/modules/index.ts`. If you\ngenerated a module via `kick g module foo` but the routes don't appear,\nthe most likely cause is that the module is missing from the exported\narray. The CLI usually wires this automatically, but a hand-edit can\ndrop the entry.",
-				fix: "Open src/modules/index.ts and verify the module is in the array:",
-				codeAfter: "import type { AppModuleClass } from '@forinda/kickjs'\nimport { UserModule } from './users/user.module'\nimport { TaskModule } from './tasks/task.module'  // ← was this missing?\n\nexport const modules: AppModuleClass[] = [UserModule, TaskModule]",
-				docs: "https://forinda.github.io/kick-js/guide/project-structure.html"
-			}
-		};
-	} }
-];
-/**
-* Run every matcher against the input and return the highest-confidence
-* hit, or `null` if no matcher cleared the 40-confidence threshold.
-*/
-function findBestMatch(input, ctx) {
-	let best = null;
-	for (const issue of KNOWN_ISSUES) {
-		let match = null;
-		try {
-			match = issue.match(input, ctx);
-		} catch {
-			continue;
-		}
-		if (!match || match.confidence < 40) continue;
-		if (!best || match.confidence > best.confidence) best = match;
-	}
-	return best;
-}
-//#endregion
-//#region src/explain/ai-fallback.ts
-/**
-* Ask the configured LLM for a diagnosis of `options.input`.
-*
-* Returns a discriminated result; callers should never assume the
-* LLM was reachable or produced valid output. The function catches
-* every expected failure mode and maps it to a friendly `unavailable`
-* or `error` result — the CLI can then decide how to present it.
-*/
-async function askAi(options) {
-	const provider = options.provider ?? "openai";
-	const apiKey = process.env.OPENAI_API_KEY;
-	if (provider === "openai" && !apiKey) return {
-		kind: "unavailable",
-		reason: "OPENAI_API_KEY environment variable is not set",
-		suggestion: "Set OPENAI_API_KEY in your shell, e.g.\n  export OPENAI_API_KEY=\"sk-...\"\n\nThen re-run `kick explain --ai \"<your error>\"`."
-	};
-	let aiModule;
-	try {
-		aiModule = await import("@forinda/kickjs-ai");
-	} catch {
-		return {
-			kind: "unavailable",
-			reason: "@forinda/kickjs-ai is not installed",
-			suggestion: "Install the AI package to enable the LLM fallback:\n  kick add ai\n\nOr manually:\n  pnpm add @forinda/kickjs-ai"
-		};
-	}
-	const { OpenAIProvider } = aiModule;
-	const instance = new OpenAIProvider({
-		apiKey,
-		defaultChatModel: options.model ?? "gpt-4o-mini"
-	});
-	const systemPrompt = buildSystemPrompt(options.cwd);
-	const userPrompt = `Error or stack trace:\n\n${options.input.trim()}`;
-	try {
-		const diagnosis = parseDiagnosisFromResponse((await instance.chat({ messages: [{
-			role: "system",
-			content: systemPrompt
-		}, {
-			role: "user",
-			content: userPrompt
-		}] })).content);
-		if (!diagnosis) return {
-			kind: "error",
-			message: "The LLM responded but the payload was not valid JSON in the expected shape. Try again, or file an issue with the error text."
-		};
-		return {
-			kind: "ok",
-			diagnosis
-		};
-	} catch (err) {
-		return {
-			kind: "error",
-			message: `LLM request failed: ${err instanceof Error ? err.message : String(err)}`
-		};
-	}
-}
-/**
-* Build the system prompt that tells the LLM what KickJS is and how
-* to structure its response. The prompt is deliberately prescriptive:
-* the caller needs a JSON payload it can render via the same formatter
-* the known-issues path uses, so freeform text doesn't work.
-*
-* Keep this prompt short — every token counts at inference time and
-* the CLI is often called interactively.
-*/
-function buildSystemPrompt(cwd) {
-	return [
-		"You are a diagnostic assistant for KickJS, a decorator-driven Node.js",
-		"framework built on Express 5 and TypeScript. KickJS projects use:",
-		"  - @Controller, @Get, @Post, @Autowired, @Service, @Value decorators",
-		"  - An AppModule interface with a routes() method (NOT a @Module decorator)",
-		"  - Zod schemas as both runtime validators and OpenAPI sources",
-		"  - Ctx<KickRoutes.ControllerName['method']> for typed request context",
-		"  - src/config/index.ts with defineEnv/loadEnv for env schema",
-		"  - A side-effect `import \"./config\"` in src/index.ts to register the schema",
-		"  - Container.reset() in beforeEach for DI test isolation",
-		"",
-		"When the user gives you an error message or stack trace, produce a",
-		"structured diagnosis that helps them fix the bug. You MUST respond",
-		"with a single JSON object (no surrounding prose, no markdown fences)",
-		"matching this shape:",
-		"",
-		"{",
-		"  \"id\": \"<kebab-case-identifier>\",",
-		"  \"title\": \"<one-line problem summary>\",",
-		"  \"explanation\": \"<multi-line explanation of what is wrong>\",",
-		"  \"fix\": \"<multi-line instructions for fixing the problem>\",",
-		"  \"codeBefore\": \"<optional: broken code snippet>\",",
-		"  \"codeAfter\": \"<optional: corrected code snippet>\",",
-		"  \"docs\": \"<optional: KickJS doc URL that discusses this topic>\"",
-		"}",
-		"",
-		"The KickJS docs live at https://forinda.github.io/kick-js/ — prefer",
-		"that domain for any doc links you suggest.",
-		cwd ? `The project is located at ${cwd}.` : ""
-	].filter((line) => line.length > 0).join("\n");
-}
-/**
-* Extract a `Diagnosis` object from the LLM response content.
-*
-* Tries three strategies in order:
-*   1. Parse the whole content as JSON directly
-*   2. Strip a surrounding markdown fence (```json ... ```)
-*   3. Find the first balanced `{ ... }` block and parse that
-*
-* Returns null if none of the strategies produce a valid object with
-* at least the required fields (id, title, explanation, fix).
-*/
-function parseDiagnosisFromResponse(content) {
-	const attempts = [
-		content,
-		stripMarkdownFence(content),
-		extractFirstJsonObject(content)
-	].filter((s) => s !== null);
-	for (const attempt of attempts) try {
-		const parsed = JSON.parse(attempt);
-		if (isValidDiagnosis(parsed)) return parsed;
-	} catch {
-		continue;
-	}
-	return null;
-}
-function stripMarkdownFence(text) {
-	const match = text.match(/```(?:json)?\s*\n([\s\S]*?)```/);
-	return match ? match[1]?.trim() ?? null : null;
-}
-function extractFirstJsonObject(text) {
-	const start = text.indexOf("{");
-	if (start === -1) return null;
-	let depth = 0;
-	let inString = false;
-	let escape = false;
-	for (let i = start; i < text.length; i++) {
-		const ch = text[i];
-		if (escape) {
-			escape = false;
-			continue;
-		}
-		if (ch === "\\" && inString) {
-			escape = true;
-			continue;
-		}
-		if (ch === "\"") {
-			inString = !inString;
-			continue;
-		}
-		if (inString) continue;
-		if (ch === "{") depth++;
-		if (ch === "}") {
-			depth--;
-			if (depth === 0) return text.slice(start, i + 1);
-		}
-	}
-	return null;
-}
-function isValidDiagnosis(value) {
-	if (value === null || typeof value !== "object") return false;
-	const v = value;
-	return typeof v.id === "string" && typeof v.title === "string" && typeof v.explanation === "string" && typeof v.fix === "string";
-}
-//#endregion
-//#region src/commands/explain.ts
-/**
-* `kick explain` — explain a KickJS error and suggest a fix.
-*
-* The command takes an error message (positional arg, --message flag,
-* or stdin), runs it through a registry of known KickJS pitfalls, and
-* prints the highest-confidence diagnosis with a code fix and a doc
-* link. If no matcher hits, it prints a "no match" message — the
-* --ai flag (planned) will fall back to an LLM call against the
-* registered AiProvider.
-*
-* The known-issues registry lives in src/explain/known-issues.ts and
-* is the single source of truth for KickJS-specific advice. Adding a
-* new entry takes ~30 lines and gives every user a permanent fix path.
-*
-* @example
-* ```bash
-* # As a positional arg
-* kick explain "config.get('DATABASE_URL') returned undefined"
-*
-* # Via stdin (pipe a stack trace)
-* pnpm test 2>&1 | kick explain
-*
-* # Via --message flag
-* kick explain --message "Reflect.getMetadata is not a function"
-* ```
-*/
-function registerExplainCommand(program) {
-	program.command("explain [message]").description("Explain a KickJS error and suggest a fix").option("-m, --message <text>", "Error message to explain (alternative to positional arg)").option("--ai", "Fall back to LLM if no known-issue matches (requires @forinda/kickjs-ai)").option("--model <name>", "Model name for the --ai fallback", "gpt-4o-mini").option("--json", "Output the diagnosis as JSON for tooling integration").action(async (positional, opts) => {
-		const input = await resolveInput(positional, opts.message);
-		if (!input || input.trim().length === 0) {
-			process.stderr.write("Error: no input provided.\n\nPass a message as a positional arg, --message flag, or pipe via stdin:\n  kick explain \"config.get returned undefined\"\n  pnpm test 2>&1 | kick explain\n");
-			process.exit(1);
-		}
-		const ctx = buildExplainContext();
-		const match = findBestMatch(input, ctx);
-		if (opts.json && match) {
-			process.stdout.write(JSON.stringify({
-				matched: true,
-				...match
-			}, null, 2) + "\n");
-			return;
-		}
-		if (match) {
-			printDiagnosis(input, match.diagnosis, match.confidence);
-			return;
-		}
-		if (!opts.ai) {
-			if (opts.json) {
-				process.stdout.write(JSON.stringify({ matched: false }, null, 2) + "\n");
-				process.exit(2);
-			}
-			printNoMatch(input, false);
-			process.exit(2);
-		}
-		const result = await askAi({
-			input,
-			model: opts.model,
-			cwd: ctx.cwd
-		});
-		if (opts.json) {
-			process.stdout.write(JSON.stringify(aiResultToJson(result), null, 2) + "\n");
-			process.exit(result.kind === "ok" ? 0 : 2);
-		}
-		printAiResult(input, result);
-		process.exit(result.kind === "ok" ? 0 : 2);
-	});
-}
-/** Serialize an AskAiResult for `--json` output. */
-function aiResultToJson(result) {
-	if (result.kind === "ok") return {
-		matched: true,
-		source: "ai",
-		diagnosis: result.diagnosis
-	};
-	if (result.kind === "unavailable") return {
-		matched: false,
-		aiUnavailable: true,
-		reason: result.reason
-	};
-	return {
-		matched: false,
-		aiError: true,
-		error: result.message
-	};
-}
-/** Render an AskAiResult to stdout using the same formatting as local matches. */
-function printAiResult(input, result) {
-	if (result.kind === "ok") {
-		printDiagnosis(input, result.diagnosis, -1, true);
-		return;
-	}
-	if (result.kind === "unavailable") {
-		process.stdout.write(`\n  Explaining: ${truncate(input.trim(), 200)}\n\n`);
-		process.stdout.write(`  AI fallback unavailable: ${result.reason}\n\n`);
-		process.stdout.write(`${indent(result.suggestion, "  ")}\n\n`);
-		return;
-	}
-	process.stdout.write(`\n  Explaining: ${truncate(input.trim(), 200)}\n\n`);
-	process.stdout.write(`  AI fallback error: ${result.message}\n\n`);
-}
-/**
-* Resolve the error text from positional arg, --message flag, or stdin.
-*
-* Precedence: positional > flag > stdin. We only read stdin if neither
-* of the first two were provided AND stdin is not a TTY (i.e. something
-* is being piped in). Reading from a real TTY would hang waiting for
-* the user to type, which is never what they want.
-*/
-async function resolveInput(positional, flag) {
-	if (positional && positional.trim().length > 0) return positional;
-	if (flag && flag.trim().length > 0) return flag;
-	if (process.stdin.isTTY) return "";
-	return readStdinAll();
-}
-function readStdinAll() {
-	return new Promise((resolve, reject) => {
-		let buffer = "";
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", (chunk) => {
-			buffer += chunk;
-		});
-		process.stdin.on("end", () => resolve(buffer));
-		process.stdin.on("error", reject);
-	});
-}
-/**
-* Build a small context object the matchers can use to check project
-* state — e.g. "does this project have a src/config/index.ts?".
-*
-* Kept intentionally minimal to avoid pulling the full kick.config
-* loader into a fast-path command. Matchers should treat this as
-* best-effort and degrade gracefully when ctx is undefined.
-*/
-function buildExplainContext() {
-	const cwd = process.cwd();
-	return {
-		cwd,
-		hasFile: (path) => existsSync(resolve(cwd, path))
-	};
-}
-function printDiagnosis(input, d, confidence, aiLabel = false) {
-	const inputSnippet = truncate(input.trim(), 200);
-	const label = aiLabel ? "AI-generated — verify before applying" : labelConfidence(confidence);
-	process.stdout.write(`\n  Explaining: ${inputSnippet}\n`);
-	process.stdout.write(`\n  Match: ${d.id}  (${label})\n`);
-	process.stdout.write(`  Title: ${d.title}\n`);
-	process.stdout.write(`\n  Diagnosis:\n${indent(d.explanation, "    ")}\n`);
-	process.stdout.write(`\n  Fix:\n${indent(d.fix, "    ")}\n`);
-	if (d.codeBefore) process.stdout.write(`\n  Before:\n${indent(d.codeBefore, "      ")}\n`);
-	if (d.codeAfter) process.stdout.write(`\n  After:\n${indent(d.codeAfter, "      ")}\n`);
-	if (d.docs) process.stdout.write(`\n  Docs: ${d.docs}\n`);
-	process.stdout.write("\n");
-}
-function printNoMatch(input, aiRequested) {
-	const snippet = truncate(input.trim(), 200);
-	process.stdout.write(`\n  Explaining: ${snippet}\n\n`);
-	if (aiRequested) process.stdout.write("  No known-issue matched, and --ai fallback is not yet wired.\n  When @forinda/kickjs-ai ships its provider implementations,\n  this command will call the configured LLM with the error +\n  project context and return a structured fix.\n\n");
-	else process.stdout.write("  No known-issue matched. Things you can try:\n\n    1. Check the framework docs for the error keywords:\n       https://forinda.github.io/kick-js/\n\n    2. Re-run with --ai to fall back to an LLM (requires\n       @forinda/kickjs-ai with a configured provider):\n       kick explain --ai \"<your error>\"\n\n    3. File an issue with the error text:\n       https://github.com/forinda/kick-js/issues/new\n\n");
-}
-function indent(text, prefix) {
-	return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
-}
-function truncate(text, max) {
-	if (text.length <= max) return text;
-	return text.slice(0, max - 1) + "…";
-}
-function labelConfidence(score) {
-	if (score >= 90) return "high confidence";
-	if (score >= 70) return "good match";
-	if (score >= 50) return "medium confidence";
-	return "low confidence — verify manually";
-}
-//#endregion
-//#region src/commands/mcp.ts
-/**
-* `kick mcp` — Model Context Protocol commands.
-*
-* Two subcommands:
-* - `kick mcp` (default → `start`): runs the built application as an
-*   MCP server over stdio. The user's app must already wire `McpAdapter`
-*   from `@forinda/kickjs-mcp` into its bootstrap. The CLI just spawns
-*   the built entry as a subprocess with `KICK_MCP_STDIO=1`, which the
-*   adapter detects and uses to switch its transport from
-*   StreamableHTTP to stdio. The subprocess inherits stdin/stdout/stderr
-*   so the MCP wire protocol flows directly between the parent process
-*   (the MCP client — Claude Code, Cursor, etc.) and the child app.
-* - `kick mcp init`: generates a `.mcp.json` config file pointing at
-*   this project, ready to drop into a Claude Code / Cursor workspace.
-*
-* Logs MUST go to stderr in stdio mode — anything written to stdout
-* corrupts the JSON-RPC protocol stream. Pino's default stream is
-* stderr already, so this works out of the box for KickJS apps using
-* the framework's bundled logger.
-*/
-function registerMcpCommand(program) {
-	const mcp = program.command("mcp").description("Model Context Protocol commands (start | init)");
-	mcp.command("start", { isDefault: true }).description("Run the built application as an MCP server over stdio").option("-e, --entry <file>", "Entry file", "dist/index.js").option("--node-arg <arg...>", "Extra arguments to pass to node").action(runMcpServer);
-	mcp.command("init").description("Generate .mcp.json for Claude Code / Cursor / Zed").option("-n, --name <name>", "Server name (defaults to package.json name)").option("-o, --out <file>", "Output file", ".mcp.json").option("-f, --force", "Overwrite an existing entry without prompting").option("--global", "Write to ~/.mcp.json instead of the project root").action(initMcpConfig);
-}
-function runMcpServer(opts) {
-	const entry = resolve(opts.entry);
-	if (!existsSync(entry)) {
-		process.stderr.write(`Error: entry file not found: ${entry}\n\nBuild the app first with \`kick build\`, or pass a custom entry:\n  kick mcp -e dist/server.js\n`);
-		process.exit(1);
-	}
-	const nodeArgs = [...opts.nodeArg ?? [], entry];
-	const child = spawn(process.execPath, nodeArgs, {
-		stdio: "inherit",
-		env: {
-			...process.env,
-			KICK_MCP_STDIO: "1",
-			NODE_ENV: process.env.NODE_ENV ?? "production"
-		}
-	});
-	child.on("error", (err) => {
-		process.stderr.write(`Failed to start MCP server: ${err.message}\n`);
-		process.exit(1);
-	});
-	child.on("exit", (code, signal) => {
-		if (signal) {
-			process.kill(process.pid, signal);
-			return;
-		}
-		process.exit(code ?? 0);
-	});
-	const forward = (signal) => {
-		if (!child.killed) child.kill(signal);
-	};
-	process.on("SIGINT", () => forward("SIGINT"));
-	process.on("SIGTERM", () => forward("SIGTERM"));
-}
-function initMcpConfig(opts) {
-	const cwd = process.cwd();
-	const projectName = readPackageName(cwd) ?? basename(cwd);
-	const serverName = opts.name ?? projectName;
-	const outPath = opts.global ? resolve(process.env.HOME ?? ".", ".mcp.json") : resolve(cwd, opts.out);
-	const entry = {
-		command: "kick",
-		args: ["mcp"],
-		cwd
-	};
-	let config = { mcpServers: {} };
-	if (existsSync(outPath)) try {
-		const raw = readFileSync(outPath, "utf8");
-		const parsed = JSON.parse(raw);
-		if (parsed && typeof parsed === "object" && parsed.mcpServers) config = { mcpServers: { ...parsed.mcpServers } };
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		process.stderr.write(`Error: existing ${outPath} is not valid JSON (${message}).\nFix the file or pass --force to overwrite the entry.\n`);
-		process.exit(1);
-	}
-	if (config.mcpServers[serverName] && !opts.force) {
-		process.stderr.write(`Error: an entry for "${serverName}" already exists in ${outPath}.\nPass --force to overwrite it, or use --name to pick a different key.\n`);
-		process.exit(1);
-	}
-	config.mcpServers[serverName] = entry;
-	writeFileSync(outPath, JSON.stringify(config, null, 2) + "\n", "utf8");
-	process.stdout.write(`\n  ✓ Wrote MCP server entry "${serverName}" to ${outPath}\n\n  To activate it:\n    1. Build your app:    kick build\n    2. Restart your MCP client (Claude Code, Cursor, Zed)\n    3. The server should appear in the client's tool picker\n\n`);
-}
-/**
-* Read the `name` field from the project's `package.json`. Returns
-* null if the file is missing or unparseable — callers fall back to
-* the directory name in that case.
-*/
-function readPackageName(cwd) {
-	const pkgPath = resolve(cwd, "package.json");
-	if (!existsSync(pkgPath)) return null;
-	try {
-		const raw = readFileSync(pkgPath, "utf8");
-		const parsed = JSON.parse(raw);
-		if (typeof parsed.name === "string") return parsed.name;
-		return null;
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region src/commands/tinker.ts
-function registerTinkerCommand(program) {
-	program.command("tinker").description("Interactive REPL with DI container and services loaded").option("-e, --entry <file>", "Entry file to load", "src/index.ts").action(async (opts) => {
-		const cwd = process.cwd();
-		const entryPath = resolve(cwd, opts.entry);
-		if (!existsSync(entryPath)) {
-			console.error(`\n  Error: ${opts.entry} not found.\n`);
-			process.exit(1);
-		}
-		const tsxBin = findBin(cwd, "tsx");
-		if (!tsxBin) {
-			console.error("\n  Error: tsx not found. Install it: pnpm add -D tsx\n");
-			process.exit(1);
-		}
-		const tinkerScript = generateTinkerScript(entryPath, opts.entry);
-		const tmpFile = join(cwd, ".kick-tinker.mjs");
-		const { writeFileSync, unlinkSync } = await import("node:fs");
-		writeFileSync(tmpFile, tinkerScript, "utf-8");
-		try {
-			const child = fork(tmpFile, [], {
-				cwd,
-				execPath: tsxBin,
-				stdio: "inherit"
-			});
-			await new Promise((resolve) => {
-				child.on("exit", () => resolve());
-			});
-		} finally {
-			try {
-				unlinkSync(tmpFile);
-			} catch {}
-		}
-	});
-}
-function generateTinkerScript(entryPath, displayPath) {
-	return `
-import 'reflect-metadata'
-
-// Prevent bootstrap() from starting the HTTP server
-process.env.KICK_TINKER = '1'
-
-console.log('\\n  🔧 KickJS Tinker')
-console.log('  Loading: ${displayPath}\\n')
-
-// Load core
-let Container, Logger, HttpException, HttpStatus
-try {
-  const core = await import('@forinda/kickjs')
-  Container = core.Container
-  Logger = core.Logger
-  HttpException = core.HttpException
-  HttpStatus = core.HttpStatus
-} catch {
-  console.error('  Error: @forinda/kickjs not found.')
-  console.error('  Install it: pnpm add @forinda/kickjs\\n')
-  process.exit(1)
-}
-
-// Load entry to trigger decorator registration
-try {
-  await import('${pathToFileURL(entryPath).href}')
-} catch (err) {
-  console.warn('  Warning: ' + err.message)
-  console.warn('  Container may be partially initialized.\\n')
-}
-
-const container = Container.getInstance()
-
-// Start REPL
-const repl = await import('node:repl')
-const server = repl.start({ prompt: 'kick> ', useGlobal: true })
-
-server.context.container = container
-server.context.Container = Container
-server.context.resolve = (token) => container.resolve(token)
-server.context.Logger = Logger
-server.context.HttpException = HttpException
-server.context.HttpStatus = HttpStatus
-
-console.log('  Available globals:')
-console.log('    container    — DI container instance')
-console.log('    resolve(T)   — shorthand for container.resolve(T)')
-console.log('    Container, Logger, HttpException, HttpStatus')
-console.log()
-
-server.on('exit', () => {
-  console.log('\\n  Goodbye!\\n')
-  process.exit(0)
-})
-`;
-}
-function findBin(startDir, name) {
-	let dir = startDir;
-	while (true) {
-		const candidate = join(dir, "node_modules", ".bin", name);
-		if (existsSync(candidate)) return candidate;
-		const parent = resolve(dir, "..");
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return null;
-}
-//#endregion
-//#region src/generators/remove-module.ts
-/**
-* Remove a module — deletes its directory and unregisters it from the modules index.
-*/
-async function removeModule(options) {
-	const { name, modulesDir, force } = options;
-	const shouldPluralize = options.pluralize !== false;
-	const kebab = toKebabCase(name);
-	const pascal = toPascalCase(name);
-	const plural = shouldPluralize ? pluralize(kebab) : kebab;
-	const moduleDir = join(modulesDir, plural);
-	if (!await fileExists(moduleDir)) {
-		console.log(`\n  Module not found: ${moduleDir}\n`);
-		return;
-	}
-	if (!force) {
-		if (!await confirm({
-			message: pc.red(`Delete module '${plural}' at ${moduleDir}? This cannot be undone.`),
-			initialValue: false
-		})) {
-			console.log("\n  Cancelled.\n");
-			return;
-		}
-	}
-	await rm(moduleDir, {
-		recursive: true,
-		force: true
-	});
-	console.log(`  Deleted: ${moduleDir}`);
-	const indexPath = join(modulesDir, "index.ts");
-	if (await fileExists(indexPath)) {
-		let content = await readFile(indexPath, "utf-8");
-		const originalContent = content;
-		const importPattern = new RegExp(`^import\\s*\\{\\s*${pascal}Module\\s*\\}\\s*from\\s*['"][^'"]*${plural}(?:/[^'"]*)?['"].*\\n?`, "gm");
-		content = content.replace(importPattern, "");
-		content = content.replace(new RegExp(`\\s*,?\\s*${pascal}Module\\s*,?`, "g"), (match) => {
-			const startsWithComma = match.trimStart().startsWith(",");
-			const endsWithComma = match.trimEnd().endsWith(",");
-			if (startsWithComma && endsWithComma) return ",";
-			return "";
-		});
-		content = content.replace(/,(\s*])/, "$1");
-		content = content.replace(/\n{3,}/g, "\n\n");
-		if (content !== originalContent) {
-			await writeFile(indexPath, content, "utf-8");
-			console.log(`  Unregistered: ${pascal}Module from ${indexPath}`);
-		}
-	}
-	console.log(`\n  Module '${plural}' removed.\n`);
-}
-//#endregion
-//#region src/commands/remove.ts
-function registerRemoveCommand(program) {
-	program.command("remove").alias("rm").description("Remove generated code").command("module <names...>").description("Remove one or more modules (e.g. kick rm module user task)").option("--modules-dir <dir>", "Modules directory").option("--no-pluralize", "Use singular module name").option("-f, --force", "Skip confirmation prompt").action(async (names, opts) => {
-		const mc = resolveModuleConfig(await loadKickConfig(process.cwd()));
-		const modulesDir = opts.modulesDir ?? mc.dir ?? "src/modules";
-		const shouldPluralize = opts.pluralize === false ? false : mc.pluralize ?? true;
-		for (const name of names) await removeModule({
-			name,
-			modulesDir: resolve(modulesDir),
-			force: opts.force,
-			pluralize: shouldPluralize
-		});
-	});
-}
-//#endregion
-//#region src/commands/typegen.ts
-/**
-* Parse the `--schema-validator` CLI flag. Returns `undefined` if the
-* flag was not passed (so the config default applies), `'zod'` if a
-* supported value was passed, or `false` if explicitly disabled.
-*/
-function parseSchemaValidatorFlag(value) {
-	if (value === void 0) return void 0;
-	if (value === "false" || value === "off" || value === "none") return false;
-	if (value === "zod") return "zod";
-	console.warn(`  kick typegen: unknown --schema-validator '${value}' (only 'zod' and 'false' are supported). Falling back to project config.`);
-}
-/**
-* Parse the `--env-file` CLI flag. Returns `undefined` to fall through
-* to the config default, `false` when the user disables env typing
-* with `--env-file false`, or the literal path string otherwise.
-*/
-function parseEnvFileFlag(value) {
-	if (value === void 0) return void 0;
-	if (value === "false" || value === "off" || value === "none") return false;
-	return value;
-}
-function registerTypegenCommand(program) {
-	program.command("typegen").description("Generate type-safe DI registry and module types into .kickjs/types/").option("-w, --watch", "Watch source files and regenerate on change").option("-s, --src <dir>", "Source directory to scan", "src").option("-o, --out <dir>", "Output directory", ".kickjs/types").option("--silent", "Suppress output").option("--allow-duplicates", "Auto-namespace duplicate class names instead of failing (use with caution)").option("--schema-validator <name>", "Schema validator for body/query/params typing (currently 'zod' or 'false')").option("--env-file <path>", "Path to env schema file for KickEnv typing (default 'src/env.ts'; pass 'false' to disable)").option("--check", "CI gate: fail on plugin-typegen drift instead of writing").option("--list", "List every registered typegen plugin id (use to populate `typegen.disable`)").action(async (opts) => {
-		const cwd = process.cwd();
-		const config = await loadKickConfig(cwd);
-		if (opts.list) {
-			const { mergeCliPlugins } = await import("./plugin-6_YlK-JG.mjs").then((n) => n.t);
-			const { builtinCliPlugins } = await import("./builtins-C_VfEGdg.mjs");
-			const merged = mergeCliPlugins([...builtinCliPlugins, ...config?.plugins ?? []], config?.commands ?? []);
-			const disabled = new Set(config?.typegen?.disable ?? []);
-			if (merged.typegens.length === 0) {
-				console.log("  No typegen plugins registered.");
-				return;
-			}
-			const idWidth = Math.max(...merged.typegens.map((t) => t.id.length));
-			console.log("\n  Registered typegen plugins:\n");
-			for (const tg of merged.typegens) {
-				const status = disabled.has(tg.id) ? " (disabled)" : "";
-				console.log(`    ${tg.id.padEnd(idWidth + 2)}inputs: ${tg.inputs.join(", ") || "(none)"}${status}`);
-			}
-			console.log();
-			return;
-		}
-		const schemaValidator = parseSchemaValidatorFlag(opts.schemaValidator) ?? config?.typegen?.schemaValidator ?? "zod";
-		const envFile = parseEnvFileFlag(opts.envFile) ?? config?.typegen?.envFile;
-		const baseOpts = {
-			cwd,
-			srcDir: opts.src ?? config?.typegen?.srcDir,
-			outDir: opts.out ?? config?.typegen?.outDir,
-			silent: opts.silent,
-			allowDuplicates: opts.allowDuplicates,
-			schemaValidator,
-			envFile,
-			assetMap: config?.assetMap,
-			runPlugins: false
-		};
-		try {
-			if (opts.watch) {
-				const stop = await watchTypegen(baseOpts);
-				if (!opts.silent) console.log("  kick typegen: watching for changes (Ctrl-C to exit)");
-				const shutdown = () => {
-					stop();
-					process.exit(0);
-				};
-				process.on("SIGINT", shutdown);
-				process.on("SIGTERM", shutdown);
-				await new Promise(() => {});
-			} else {
-				await runTypegen$1(baseOpts);
-				const results = await runAllPluginTypegens({
-					cwd,
-					config: config ?? null,
-					silent: opts.silent,
-					check: opts.check
-				});
-				if (opts.check && results.some((r) => r.status === "written")) process.exit(1);
-			}
-		} catch (err) {
-			if (err instanceof TokenCollisionError) console.error("\n" + err.message + "\n");
-			else if (err instanceof Error) console.error(`\n  kick typegen failed: ${err.message}`);
-			else console.error(`\n  kick typegen failed: ${JSON.stringify(err)}`);
-			process.exit(1);
-		}
-	});
-}
-//#endregion
-//#region src/commands/check.ts
-/** Recursively collect all .ts files under a directory */
-function collectTsFiles(dir) {
-	const files = [];
-	if (!existsSync(dir)) return files;
-	const entries = readdirSync(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = join(dir, entry.name);
-		if (entry.isDirectory()) {
-			if ([
-				"node_modules",
-				"dist",
-				".kickjs",
-				".git"
-			].includes(entry.name)) continue;
-			files.push(...collectTsFiles(fullPath));
-		} else if (entry.isFile() && /\.tsx?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) files.push(fullPath);
-	}
-	return files;
-}
-/** Read a file safely, returning empty string on failure */
-function safeRead(filepath) {
-	try {
-		return readFileSync(filepath, "utf-8");
-	} catch {
-		return "";
-	}
-}
-const WEAK_SECRETS = new Set([
-	"secret",
-	"changeme",
-	"password",
-	"test",
-	"default",
-	""
-]);
-function checkJwtSecret(cwd, sourceContents) {
-	const envContent = safeRead(join(cwd, ".env"));
-	if (envContent) {
-		const match = envContent.match(/^JWT_SECRET\s*=\s*['"]?([^'"\n]*)['"]?/m);
-		if (match) {
-			const value = match[1].trim();
-			if (WEAK_SECRETS.has(value.toLowerCase()) || value.length < 32) return {
-				severity: "CRITICAL",
-				message: "JWT_SECRET appears to be a default value or too short (< 32 chars) — change it"
-			};
-		}
-	}
-	for (const content of sourceContents) for (const pattern of [/JWT_SECRET['"]?\s*[:=]\s*['"]?(secret|changeme|password|test|default)['"]?/i, /secret\s*[:=]\s*['"]?(secret|changeme|password|test|default)['"]?/i]) if (pattern.test(content)) return {
-		severity: "CRITICAL",
-		message: "JWT_SECRET appears to be a default value in source code — use an environment variable"
-	};
-	return null;
-}
-function checkCorsOrigin(sourceContents) {
-	for (const content of sourceContents) if (/cors\s*\(/.test(content) && /origin\s*:\s*['"]\*['"]/.test(content)) return {
-		severity: "CRITICAL",
-		message: "CORS origin is '*' — restrict to your domains"
-	};
-	return null;
-}
-function checkRateLimiting(sourceContents) {
-	for (const content of sourceContents) if (/rateLimit/i.test(content) || /@RateLimit/i.test(content)) return null;
-	return {
-		severity: "WARNING",
-		message: "No rate limiting detected — add rateLimit() middleware or @RateLimit decorator"
-	};
-}
-function checkNodeEnv() {
-	if (process.env.NODE_ENV !== "production") return {
-		severity: "WARNING",
-		message: `NODE_ENV is '${process.env.NODE_ENV ?? "undefined"}', not 'production'`
-	};
-	return null;
-}
-function checkTokenStore(sourceContents) {
-	let hasTokenStore = false;
-	let usesMemoryStore = false;
-	for (const content of sourceContents) {
-		if (/tokenStore/i.test(content)) hasTokenStore = true;
-		if (/MemoryTokenStore/i.test(content)) usesMemoryStore = true;
-	}
-	if (usesMemoryStore) return {
-		severity: "WARNING",
-		message: "MemoryTokenStore detected — use a persistent store (Redis, DB) for production deployments"
-	};
-	if (!hasTokenStore) return {
-		severity: "WARNING",
-		message: "No token revocation store detected — consider adding one for auth token management"
-	};
-	return null;
-}
-function checkHelmet(sourceContents) {
-	for (const content of sourceContents) if (/helmet\s*\(/.test(content)) {
-		if (/security\s*\.\s*helmet\s*.*false/.test(content)) return {
-			severity: "WARNING",
-			message: "Helmet security headers are disabled — enable them for production"
-		};
-		return {
-			severity: "INFO",
-			message: "Helmet security headers active"
-		};
-	}
-	return {
-		severity: "WARNING",
-		message: "Helmet not detected — add helmet() middleware for security headers"
-	};
-}
-function checkAuthAdapter(sourceContents) {
-	for (const content of sourceContents) if (/AuthAdapter/i.test(content)) return {
-		severity: "INFO",
-		message: "AuthAdapter configured"
-	};
-	return {
-		severity: "INFO",
-		message: "No AuthAdapter detected — add one if your app requires authentication"
-	};
-}
-function runDeployChecks(cwd) {
-	const sourceContents = collectTsFiles(join(cwd, "src")).map((f) => safeRead(f));
-	const results = [];
-	const jwtResult = checkJwtSecret(cwd, sourceContents);
-	if (jwtResult) results.push(jwtResult);
-	const corsResult = checkCorsOrigin(sourceContents);
-	if (corsResult) results.push(corsResult);
-	const rateLimitResult = checkRateLimiting(sourceContents);
-	if (rateLimitResult) results.push(rateLimitResult);
-	const nodeEnvResult = checkNodeEnv();
-	if (nodeEnvResult) results.push(nodeEnvResult);
-	const tokenStoreResult = checkTokenStore(sourceContents);
-	if (tokenStoreResult) results.push(tokenStoreResult);
-	results.push(checkHelmet(sourceContents));
-	results.push(checkAuthAdapter(sourceContents));
-	return results;
-}
-function registerCheckCommand(program) {
-	program.command("check").description("Audit project for common issues").option("--deploy", "Run production readiness checks").action((opts) => {
-		if (!opts.deploy) {
-			console.log("\n  Usage: kick check --deploy\n\n  Available checks:\n    --deploy    Audit for production readiness (security, config, best practices)\n");
-			return;
-		}
-		const cwd = process.cwd();
-		intro("KickJS Deploy Check");
-		const s = spinner();
-		s.start("Scanning project...");
-		const results = runDeployChecks(cwd);
-		s.stop("Scan complete");
-		const order = {
-			CRITICAL: 0,
-			WARNING: 1,
-			INFO: 2
-		};
-		results.sort((a, b) => order[a.severity] - order[b.severity]);
-		for (const r of results) log.message(`${severityColor(r.severity)} ${r.message}`);
-		const critical = results.filter((r) => r.severity === "CRITICAL").length;
-		const warnings = results.filter((r) => r.severity === "WARNING").length;
-		const info = results.filter((r) => r.severity === "INFO").length;
-		const warnLabel = warnings === 1 ? "warning" : "warnings";
-		const summary = [
-			critical > 0 ? pc.red(`${critical} critical`) : `${critical} critical`,
-			warnings > 0 ? pc.yellow(`${warnings} ${warnLabel}`) : `${warnings} ${warnLabel}`,
-			`${info} info`
-		].join(", ");
-		if (critical > 0) {
-			outro(pc.red(`${summary} — fix critical issues before deploying`));
-			process.exit(1);
-		} else outro(pc.green(`${summary} — looking good!`));
-	});
-}
-//#endregion
-//#region src/commands/db.ts
-async function loadConfig(opts) {
-	return resolveDbConfig({ configPath: path.resolve(process.cwd(), opts.config) });
-}
-/**
-* Resolve a MigrationAdapter from config:
-*  1. config.adapter() — explicit factory wins.
-*  2. config.connectionString — built-in pgAdapter path; we dynamically
-*     import @forinda/kickjs-db-pg + pg so the CLI doesn't pull pg into
-*     non-PG workflows.
-*/
-async function resolveAdapter(config) {
-	if (config.adapter) {
-		const adapter = await config.adapter();
-		return {
-			adapter,
-			cleanup: async () => adapter.close()
-		};
-	}
-	if (!config.connectionString) throw new Error("kickjs-db: no adapter resolved — set db.connectionString (or DATABASE_URL) in kick.config.ts, or supply db.adapter() factory");
-	const dialect = config.dialect ?? "postgres";
-	if (dialect !== "postgres") throw new Error(`kickjs-db: built-in CLI adapter only supports postgres in M1 (dialect=${dialect}); use db.adapter() factory for other dialects`);
-	const [{ pgAdapter }, pg] = await Promise.all([import("@forinda/kickjs-db-pg"), import("pg")]);
-	const pool = new pg.default.Pool({ connectionString: config.connectionString });
-	const adapter = pgAdapter({ pool });
-	return {
-		adapter,
-		cleanup: async () => {
-			await adapter.close();
-			await pool.end();
-		}
-	};
-}
-function printStatusTable(status) {
-	if (status.length === 0) {
-		console.log("No migrations.");
-		return;
-	}
-	console.table(status.map((s) => ({
-		id: s.id,
-		state: s.state,
-		batch: s.batch ?? "-",
-		reviewed: s.reviewed,
-		applied: s.appliedAt ?? "-"
-	})));
-}
-function registerDbCommands(program) {
-	const db = program.command("db").description("Database commands (kickjs-db)");
-	db.command("generate <name>").description("Generate a new migration from schema diff").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").option("-e, --empty", "Skip schema diff and create an empty migration shell (data migration, seed, freeform SQL)").action(async (name, opts) => {
-		const cwd = process.cwd();
-		const result = await generate({
-			name,
-			config: await loadConfig(opts),
-			cwd,
-			empty: opts.empty
-		});
-		if (result.status === "no-changes") {
-			console.log("No schema changes detected.");
-			return;
-		}
-		if (result.empty) {
-			console.log(`Created empty migration ${result.migrationDir} (author up.sql + down.sql).`);
-			return;
-		}
-		const plural = result.changeCount === 1 ? "" : "s";
-		console.log(`Created migration ${result.migrationDir} (${result.changeCount} change${plural}).`);
-	});
-	const migrate = db.command("migrate").description("Migration runner subcommands");
-	migrate.command("latest").description("Apply all pending migrations in a new batch").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").action(async (opts) => {
-		const config = await loadConfig(opts);
-		const { adapter, cleanup } = await resolveAdapter(config);
-		try {
-			const r = await migrateLatest({
-				adapter,
-				migrationsDir: config.migrationsDir
-			});
-			if (r.applied.length === 0) console.log("No pending migrations.");
-			else console.log(`Applied batch ${r.batch}: ${r.applied.join(", ")}`);
-		} finally {
-			await cleanup();
-		}
-	});
-	migrate.command("up").description("Apply the next single pending migration").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").action(async (opts) => {
-		const config = await loadConfig(opts);
-		const { adapter, cleanup } = await resolveAdapter(config);
-		try {
-			const r = await migrateUp({
-				adapter,
-				migrationsDir: config.migrationsDir
-			});
-			if (r.applied.length === 0) console.log("No pending migrations.");
-			else console.log(`Applied ${r.applied[0]} (batch ${r.batch})`);
-		} finally {
-			await cleanup();
-		}
-	});
-	migrate.command("down").description("Reverse the most recent applied migration").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").action(async (opts) => {
-		const config = await loadConfig(opts);
-		const { adapter, cleanup } = await resolveAdapter(config);
-		try {
-			const r = await migrateDown({
-				adapter,
-				migrationsDir: config.migrationsDir
-			});
-			if (!r.reversed) console.log("Nothing to reverse.");
-			else console.log(`Reversed ${r.reversed}.`);
-		} finally {
-			await cleanup();
-		}
-	});
-	migrate.command("rollback").description("Reverse the entire last batch as a single unit").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").action(async (opts) => {
-		const config = await loadConfig(opts);
-		const { adapter, cleanup } = await resolveAdapter(config);
-		try {
-			const r = await migrateRollback({
-				adapter,
-				migrationsDir: config.migrationsDir
-			});
-			if (r.reversed.length === 0) console.log("Nothing to roll back.");
-			else console.log(`Rolled back batch ${r.batch}: ${r.reversed.join(", ")}`);
-		} finally {
-			await cleanup();
-		}
-	});
-	migrate.command("status").description("Print applied + pending migrations").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").action(async (opts) => {
-		const config = await loadConfig(opts);
-		const { adapter, cleanup } = await resolveAdapter(config);
-		try {
-			printStatusTable(await migrateStatus({
-				adapter,
-				migrationsDir: config.migrationsDir
-			}));
-		} finally {
-			await cleanup();
-		}
-	});
-	db.command("introspect").description("Generate a TypeScript schema file from a live database").option("-c, --config <path>", "Path to kick.config.ts", "kick.config.ts").option("--out <path>", "Output file (defaults to db.schemaPath from config)").option("--json", "Print the raw SchemaSnapshot JSON to stdout instead of writing TS source").action(async (opts) => {
-		const config = await loadConfig(opts);
-		const { adapter, cleanup } = await resolveAdapter(config);
-		try {
-			const snapshot = await adapter.introspect();
-			if (opts.json) {
-				console.log(JSON.stringify(snapshot, null, 2));
-				return;
-			}
-			const out = opts.out ?? config.schemaPath;
-			await writeFile(out, renderSchemaSource(snapshot), "utf8");
-			const tableCount = Object.keys(snapshot.tables).length;
-			console.log(`Wrote ${out} (${tableCount} table${tableCount === 1 ? "" : "s"}).`);
-		} finally {
-			await cleanup();
-		}
-	});
-}
-//#endregion
-//#region src/typegen/builtin/db.ts
-const DEFAULT_SCHEMA_PATHS = [
-	"src/db/schema.ts",
-	"src/db/schema/index.ts",
-	"src/db/schema"
-];
-const kickDbTypegen = () => ({
-	id: "kick/db",
-	inputs: ["src/db/schema.ts", "src/db/schema/**/*.ts"],
-	async generate(ctx) {
-		const schemaAbs = resolveSchema(ctx.cwd);
-		if (!schemaAbs) return null;
-		const typesDir = path.resolve(ctx.cwd, ".kickjs/types");
-		return [
-			`import type { SchemaToTypes, KickDbClient } from '@forinda/kickjs-db'`,
-			`import type * as appSchema from '${posix(path.relative(typesDir, schemaAbs)).replace(/\.ts$/, "").replace(/\/index$/, "")}'`,
-			``,
-			`declare global {`,
-			`  interface KickDbSchema extends SchemaToTypes<typeof appSchema> {}`,
-			`}`,
-			``,
-			`declare module '@forinda/kickjs-db' {`,
-			`  interface KickDbRegister {`,
-			`    db: KickDbClient<KickDbSchema>`,
-			`  }`,
-			`}`
-		].join("\n");
-	}
-});
-function resolveSchema(cwd) {
-	for (const candidate of DEFAULT_SCHEMA_PATHS) {
-		const abs = path.resolve(cwd, candidate);
-		if (candidate.endsWith(".ts")) {
-			if (existsSync(abs)) return abs;
-		} else {
-			const idx = path.join(abs, "index.ts");
-			if (existsSync(idx)) return idx;
-		}
-	}
-	return null;
-}
-function posix(p) {
-	return p.replace(/\\/g, "/");
-}
-//#endregion
-//#region src/typegen/builtin/assets.ts
-const kickAssetsTypegen = () => ({
-	id: "kick/assets",
-	inputs: [
-		"kick.config.ts",
-		"kick.config.js",
-		"kick.config.mjs"
-	],
-	async generate(ctx) {
-		if (!existsSync(path.resolve(ctx.cwd, "kick.config.ts"))) return null;
-		const config = await loadKickConfig(ctx.cwd);
-		if (!config?.assetMap) return null;
-		const discovered = discoverAssets(config.assetMap, ctx.cwd);
-		if (discovered.count === 0) return null;
-		return renderAssetTypes(discovered);
-	}
-});
-//#endregion
-//#region src/typegen/render/routes.ts
-const ROUTES_HEADER = `/* eslint-disable */
-// AUTO-GENERATED by \`kick typegen\`. DO NOT EDIT.
-// Re-run with \`kick typegen\` or rely on \`kick dev\` to refresh.
-`;
-/**
-* Render the `KickRoutes` global namespace augmentation. Each interface
-* inside corresponds to a controller class; each property is a single
-* route method on that controller, conforming to `RouteShape`.
-*
-* Fills `params` from URL patterns, `query` from `@ApiQueryParams`, and
-* `body`/`query`/`params` (when schema-validated) from the configured
-* schema validator. `response` is emitted as `unknown`.
-*/
-function renderRoutes(routes, routesOutFile, schemaValidator) {
-	if (routes.length === 0) return `${ROUTES_HEADER}
-// (no routes discovered yet — annotate a controller method with
-//  @Get/@Post/@Put/@Delete/@Patch and re-run \`kick typegen\`)
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace KickRoutes {}
-}
-
-export {}
-`;
-	const byController = /* @__PURE__ */ new Map();
-	for (const r of routes) {
-		const arr = byController.get(r.controller) ?? [];
-		arr.push(r);
-		byController.set(r.controller, arr);
-	}
-	const schemaImports = /* @__PURE__ */ new Map();
-	const renderField = (schema, routeFilePath) => {
-		const alias = planSchemaImport(schema, routeFilePath, routesOutFile, schemaValidator, schemaImports);
-		return alias ? `import('zod').infer<typeof ${alias}>` : null;
-	};
-	const interfaces = [];
-	for (const [controller, methods] of byController) {
-		const lines = [`    interface ${controller} {`];
-		for (const m of methods) {
-			const urlParamsType = m.pathParams.length > 0 ? `{ ${m.pathParams.map((p) => `${p}: string`).join("; ")} }` : "{}";
-			const bodySchemaType = renderField(m.bodySchema, m.filePath);
-			const querySchemaType = renderField(m.querySchema, m.filePath);
-			const paramsType = renderField(m.paramsSchema, m.filePath) ?? urlParamsType;
-			const bodyType = bodySchemaType ?? "unknown";
-			const queryType = querySchemaType ?? renderQueryShape(m);
-			const docLines = renderQueryDocLines(m);
-			lines.push(`      /**`, `       * ${m.httpMethod} ${m.path}`, ...docLines.map((d) => `       * ${d}`), `       */`, `      ${m.method}: {`, `        params: ${paramsType}`, `        body: ${bodyType}`, `        query: ${queryType}`, `        response: unknown`, `      }`);
-		}
-		lines.push("    }");
-		interfaces.push(lines.join("\n"));
-	}
-	return `${ROUTES_HEADER}${renderSchemaImports(schemaImports)}
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace KickRoutes {
-${interfaces.join("\n")}
-  }
-}
-
-export {}
-`;
-}
-function renderQueryShape(m) {
-	if (m.queryFilterable === null) return "unknown";
-	const sortable = m.querySortable ?? [];
-	return `{ filter?: string | string[]; sort?: ${sortable.length > 0 ? sortable.flatMap((f) => [`'${f}'`, `'-${f}'`]).join(" | ") : "string"}; q?: string; page?: string; limit?: string }`;
-}
-function renderQueryDocLines(m) {
-	const lines = [];
-	if (m.queryFilterable && m.queryFilterable.length > 0) lines.push(`Filterable: ${m.queryFilterable.join(", ")}`);
-	if (m.querySortable && m.querySortable.length > 0) lines.push(`Sortable: ${m.querySortable.join(", ")}`);
-	if (m.querySearchable && m.querySearchable.length > 0) lines.push(`Searchable: ${m.querySearchable.join(", ")}`);
-	return lines;
-}
-/**
-* Plan a schema import for hoisting at the top of `routes.ts`. Returns
-* the alias the in-namespace code should use, or `null` if the schema
-* cannot be referenced (no validator configured, or source unresolvable).
-*/
-function planSchemaImport(schema, routeFilePath, routesOutFile, schemaValidator, imports) {
-	if (!schema || schemaValidator !== "zod") return null;
-	if (schema.source === null) return null;
-	const specifier = resolveSchemaImportSpecifier(schema.source, routeFilePath, routesOutFile);
-	if (specifier === "unknown") return null;
-	const key = `${specifier}::${schema.identifier}`;
-	let alias = imports.get(key)?.specifier;
-	if (!alias) {
-		alias = `_S${imports.size}`;
-		imports.set(key, {
-			identifier: schema.identifier,
-			specifier: alias
-		});
-	} else alias = imports.get(key).specifier;
-	return alias;
-}
-function renderSchemaImports(imports) {
-	if (imports.size === 0) return "";
-	const lines = [];
-	for (const [key, value] of imports) {
-		const [path] = key.split("::");
-		lines.push(`import type { ${value.identifier} as ${value.specifier} } from '${path}'`);
-	}
-	return lines.join("\n") + "\n";
-}
-/**
-* Compute the import specifier the generated `routes.d.ts` should use
-* to reach a schema declared either in the controller file (empty
-* string) or imported from elsewhere (relative path or bare module).
-*/
-function resolveSchemaImportSpecifier(source, routeFilePath, routesOutFile) {
-	if (source === null) return "unknown";
-	const routesDir = dirname(routesOutFile);
-	if (source === "") {
-		let rel = relative(routesDir, routeFilePath).split(sep).join("/");
-		rel = rel.replace(/\.(ts|tsx|mts|cts)$/i, "");
-		if (!rel.startsWith(".")) rel = "./" + rel;
-		return rel;
-	}
-	if (!source.startsWith(".") && !source.startsWith("/")) return source;
-	let rel = relative(routesDir, resolve(dirname(routeFilePath), source)).split(sep).join("/");
-	rel = rel.replace(/\.(ts|tsx|mts|cts)$/i, "");
-	if (!rel.startsWith(".")) rel = "./" + rel;
-	return rel;
-}
-//#endregion
-//#region src/typegen/builtin/routes.ts
-const kickRoutesTypegen = () => ({
-	id: "kick/routes",
-	outExtension: ".ts",
-	inputs: ["src/**/*.controller.ts", "src/**/*.module.ts"],
-	async generate(ctx) {
-		const scan = await ctx.getScanResult({
-			root: resolveSrcDir$1(ctx),
-			cwd: ctx.cwd,
-			envFile: resolveEnvFile$1(ctx)
-		});
-		const schemaValidator = ctx.config?.typegen?.schemaValidator ?? "zod";
-		const outFile = path.resolve(ctx.cwd, ".kickjs/types/kick__routes.ts");
-		return renderRoutes(scan.routes, outFile, schemaValidator);
-	}
-});
-function resolveSrcDir$1(ctx) {
-	return path.resolve(ctx.cwd, ctx.config?.typegen?.srcDir ?? "src");
-}
-function resolveEnvFile$1(ctx) {
-	const cfg = ctx.config?.typegen?.envFile;
-	if (cfg === false) return void 0;
-	return cfg;
-}
-//#endregion
-//#region src/typegen/render/env.ts
-const ENV_HEADER = `/* eslint-disable */
-// AUTO-GENERATED by \`kick typegen\`. DO NOT EDIT.
-// Re-run with \`kick typegen\` or rely on \`kick dev\` to refresh.
-`;
-/**
-* Render the `KickEnv` + `NodeJS.ProcessEnv` augmentation file from a
-* detected env schema. Returns `null` when no env file was discovered,
-* so the caller can skip emission entirely (rather than emitting an
-* empty augmentation that would shadow `KickEnv` to a useless `{}`).
-*/
-function renderEnv(env, envOutFile) {
-	if (!env) return null;
-	let rel = relative(dirname(envOutFile), env.filePath).split(sep).join("/");
-	rel = rel.replace(/\.(ts|tsx|mts|cts)$/i, "");
-	if (!rel.startsWith(".")) rel = "./" + rel;
-	return `${ENV_HEADER}
-// Importing the schema as a type lets us infer its shape without
-// pulling in any runtime code. \`Awaited<>\` strips an accidental
-// Promise wrap on dynamic-imported defaults.
-import type _envSchema from '${rel}'
-
-// Local type alias — interfaces can only \`extend\` an identifier,
-// not an inline import expression, so we resolve the schema's
-// inferred shape into a named type first.
-type _KickEnvShape = import('zod').infer<typeof _envSchema>
-
-declare global {
-  /**
-   * Typed environment registry. Augmented from \`${env.relativePath}\`
-   * so \`@Value('PORT')\`, \`Env<'PORT'>\`, and \`process.env.PORT\` are
-   * all type-safe and autocomplete.
-   */
-  interface KickEnv extends _KickEnvShape {}
-
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace NodeJS {
-    /**
-     * Narrow \`process.env\` so known keys exist as \`string\` (the raw
-     * pre-Zod-coercion form). \`@Value\` and the \`ConfigService\` apply
-     * the schema's transforms internally; access \`process.env\` directly
-     * only when you need the raw string. Unknown keys still resolve to
-     * \`string | undefined\` via the base @types/node declaration.
-     */
-    interface ProcessEnv extends Record<keyof KickEnv, string> {}
-  }
-}
-
-export {}
-`;
-}
-//#endregion
-//#region src/typegen/builtin/env.ts
-const kickEnvTypegen = () => ({
-	id: "kick/env",
-	outExtension: ".ts",
-	inputs: [
-		"src/env.ts",
-		"src/**/env.ts",
-		"src/**/*.env.ts"
-	],
-	async generate(ctx) {
-		const envFile = resolveEnvFile(ctx);
-		if (envFile === false) return null;
-		const scan = await ctx.getScanResult({
-			root: resolveSrcDir(ctx),
-			cwd: ctx.cwd,
-			envFile
-		});
-		if (!scan.env) return null;
-		const outFile = path.resolve(ctx.cwd, ".kickjs/types/kick__env.ts");
-		return renderEnv(scan.env, outFile);
-	}
-});
-function resolveSrcDir(ctx) {
-	return path.resolve(ctx.cwd, ctx.config?.typegen?.srcDir ?? "src");
-}
-function resolveEnvFile(ctx) {
-	return ctx.config?.typegen?.envFile;
-}
-//#endregion
-//#region src/plugin/builtins.ts
-const builtinCliPlugins = [
-	defineCliPlugin({
-		name: "kick/init",
-		register: registerInitCommand
-	}),
-	defineCliPlugin({
-		name: "kick/generate",
-		register: registerGenerateCommand
-	}),
-	defineCliPlugin({
-		name: "kick/run",
-		register: registerRunCommands
-	}),
-	defineCliPlugin({
-		name: "kick/info",
-		register: registerInfoCommand
-	}),
-	defineCliPlugin({
-		name: "kick/inspect",
-		register: registerInspectCommand
-	}),
-	defineCliPlugin({
-		name: "kick/add",
-		register: registerAddCommand
-	}),
-	defineCliPlugin({
-		name: "kick/list",
-		register: registerListCommand
-	}),
-	defineCliPlugin({
-		name: "kick/explain",
-		register: registerExplainCommand
-	}),
-	defineCliPlugin({
-		name: "kick/mcp",
-		register: registerMcpCommand
-	}),
-	defineCliPlugin({
-		name: "kick/tinker",
-		register: registerTinkerCommand
-	}),
-	defineCliPlugin({
-		name: "kick/remove",
-		register: registerRemoveCommand
-	}),
-	defineCliPlugin({
-		name: "kick/typegen",
-		register: registerTypegenCommand
-	}),
-	defineCliPlugin({
-		name: "kick/check",
-		register: registerCheckCommand
-	}),
-	defineCliPlugin({
-		name: "kick/db",
-		register: registerDbCommands,
-		typegens: [kickDbTypegen()]
-	}),
-	defineCliPlugin({
-		name: "kick/assets",
-		typegens: [kickAssetsTypegen()]
-	}),
-	defineCliPlugin({
-		name: "kick/routes",
-		typegens: [kickRoutesTypegen()]
-	}),
-	defineCliPlugin({
-		name: "kick/env",
-		typegens: [kickEnvTypegen()]
-	})
-];
-//#endregion
-export { builtinCliPlugins, applyDisableFilter as n, runAllPluginTypegens as t };
-
-//# sourceMappingURL=builtins-C_VfEGdg.mjs.map