@znight/cli 0.0.0-stage → 0.1.0

package/dist/main-BWsiUsxN.mjs

@@ -0,0 +1,3865 @@
+import { n as orphanGuard } from "./orphan-Dn-2xMBd.mjs";
+import { createRequire } from "node:module";
+import { parseArgs } from "citty";
+import { stripVTControlCharacters } from "node:util";
+import picocolors from "picocolors";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, watch, writeFileSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+import { constants as constants$1 } from "node:os";
+// src/errors.ts
+/**
+* Errors thrown by commands. The dispatcher turns them into a message on stderr and an exit code;
+* any other error is reported as an unexpected failure (exit code 1, stack trace with `--debug`).
+*/
+/** Exit codes of the `znight` binary. */
+const ExitCode = {
+	/** The command succeeded. */
+	Ok: 0,
+	/** The command failed (compilation errors, failed build, stale generated file...). */
+	Failure: 1,
+	/** Invalid usage: unknown command or option, missing or invalid argument. */
+	Usage: 2,
+	/** The user cancelled an interactive prompt or interrupted the command. */
+	Cancelled: 130
+};
+/** An expected failure: printed without stack trace. */
+var CliError = class extends Error {
+	exitCode;
+	hints;
+	constructor(message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "CliError";
+		this.exitCode = options.exitCode ?? ExitCode.Failure;
+		this.hints = options.hints ?? [];
+	}
+};
+/** Invalid command line usage (exit code 2). The usage of the command is printed after the message. */
+var UsageError = class extends CliError {
+	constructor(message, hints = []) {
+		super(message, {
+			exitCode: ExitCode.Usage,
+			hints
+		});
+		this.name = "UsageError";
+	}
+};
+/** The user cancelled a prompt (exit code 130). */
+var CancelledError = class extends CliError {
+	constructor(message = "Cancelled") {
+		super(message, { exitCode: ExitCode.Cancelled });
+		this.name = "CancelledError";
+	}
+};
+/** Message of an unknown thrown value. */
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+// src/names.ts
+/**
+* Naming helpers shared by `znight new` and `znight g`: case conversions, npm package names,
+* "did you mean" suggestions.
+*/
+/** Splits an identifier into lower-case words: `UserProfile`, `user_profile`, `HTTPClient` → words. */
+function words(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter((word) => word !== "").map((word) => word.toLowerCase());
+}
+/** `user-profile` */
+function kebabCase(name) {
+	return words(name).join("-");
+}
+/** `UserProfile` */
+function pascalCase(name) {
+	return words(name).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+/** `userProfile` */
+function camelCase(name) {
+	const pascal = pascalCase(name);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/** `USER_PROFILE` */
+function constantCase(name) {
+	return words(name).map((word) => word.toUpperCase()).join("_");
+}
+const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+/**
+* Validates an npm package name (lower case, URL-safe, at most 214 characters, optional scope).
+* Returns a problem description, or `undefined` when the name is valid.
+*/
+function validatePackageName(name) {
+	if (name === "") return "the name cannot be empty";
+	if (name.length > 214) return "the name cannot be longer than 214 characters";
+	if (name !== name.trim()) return "the name cannot start or end with spaces";
+	if (name !== name.toLowerCase()) return "the name must be lower case";
+	if (name.startsWith(".") || name.startsWith("_")) return "the name cannot start with \".\" or \"_\"";
+	if (!PACKAGE_NAME.test(name)) return "the name may only contain lower-case letters, digits, \"-\", \".\", \"_\" and \"~\" (and an optional @scope/)";
+}
+/** Turns any string into a valid package name candidate: `My App!` → `my-app`. */
+function toPackageName(name) {
+	return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]+/, "").replace(/[^a-z0-9@/._~-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+/** The unscoped part of a package name: `@acme/api` → `api`. */
+function unscopedName(name) {
+	const slash = name.indexOf("/");
+	return name.startsWith("@") && slash !== -1 ? name.slice(slash + 1) : name;
+}
+/** Levenshtein distance (small strings only). */
+function editDistance(a, b) {
+	const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i++) {
+		let diagonal = previous[0] ?? 0;
+		previous[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const above = previous[j] ?? 0;
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			previous[j] = Math.min(above + 1, (previous[j - 1] ?? 0) + 1, diagonal + cost);
+			diagonal = above;
+		}
+	}
+	return previous[b.length] ?? 0;
+}
+/** The closest candidate within a distance of `max(2, length / 3)`, if any. */
+function suggest(input, candidates) {
+	let best;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	const limit = Math.max(2, Math.floor(input.length / 3));
+	for (const candidate of candidates) {
+		const distance = editDistance(input.toLowerCase(), candidate.toLowerCase());
+		if (distance < bestDistance && distance <= limit) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+// src/output.ts
+/**
+* Terminal output: color detection (NO_COLOR, FORCE_COLOR, `--color` / `--no-color`, TTY), a small
+* reporter writing consistent status lines, and formatting helpers.
+*/
+/**
+* Whether colors should be written: `--no-color` and a non-empty `NO_COLOR` disable them,
+* `--color` and `FORCE_COLOR` (other than `0`/`false`) force them, otherwise a TTY that is not
+* `TERM=dumb` gets colors.
+*/
+function shouldUseColor({ env, stream, flag }) {
+	if (flag !== void 0) return flag;
+	if (env["NO_COLOR"] !== void 0 && env["NO_COLOR"] !== "") return false;
+	const force = env["FORCE_COLOR"];
+	if (force !== void 0) return force !== "0" && force !== "false";
+	return stream.isTTY === true && env["TERM"] !== "dumb";
+}
+/** picocolors formatters, enabled or not. */
+function createColors(enabled) {
+	return picocolors.createColors(enabled);
+}
+/** Removes ANSI escape sequences. */
+function stripAnsi(text) {
+	return stripVTControlCharacters(text);
+}
+/** Creates a {@link Reporter} writing to the given streams. */
+function createReporter(stdout, stderr, colors) {
+	const line = (stream, text) => {
+		stream.write(`${text}\n`);
+	};
+	const withHints = (stream, hints) => {
+		for (const hint of hints ?? []) line(stream, `  ${colors.dim("=")} ${colors.bold("hint:")} ${hint}`);
+	};
+	return {
+		colors,
+		log: (message = "") => line(stdout, message),
+		info: (message) => line(stdout, `${colors.cyan("›")} ${message}`),
+		success: (message) => line(stdout, `${colors.green("✓")} ${message}`),
+		warn: (message, hints) => {
+			line(stderr, `${colors.yellow("!")} ${message}`);
+			withHints(stderr, hints);
+		},
+		error: (message, hints) => {
+			line(stderr, `${colors.red("✗")} ${colors.red(message)}`);
+			withHints(stderr, hints);
+		},
+		logError: (message = "") => line(stderr, message)
+	};
+}
+/** `850ms`, `1.24s`, `2m 05s`. */
+function formatDuration(ms) {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
+	const minutes = Math.floor(ms / 6e4);
+	const seconds = Math.round(ms % 6e4 / 1e3);
+	return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+/** `512 B`, `1.5 kB`, `2.31 MB` (SI units, like Vite). */
+function formatBytes(bytes) {
+	if (bytes < 1e3) return `${bytes} B`;
+	if (bytes < 1e6) return `${(bytes / 1e3).toFixed(2)} kB`;
+	return `${(bytes / 1e6).toFixed(2)} MB`;
+}
+/** `1 provider`, `3 providers`. */
+function plural(count, singular, pluralForm = `${singular}s`) {
+	return `${count} ${count === 1 ? singular : pluralForm}`;
+}
+// src/command.ts
+/** Whether an option was explicitly given (`--install`, `--no-install`, `--install=false`). */
+function hasFlag(rawArgs, name) {
+	return rawArgs.some((arg) => arg === `--${name}` || arg === `--no-${name}` || arg.startsWith(`--${name}=`) || arg.startsWith(`--no-${name}=`));
+}
+/** Creates a {@link Command}; `args` keep their literal types in `run`. */
+function defineCommand(definition) {
+	return {
+		meta: definition.meta,
+		args: definition.args,
+		execute: async (argv, passthrough, cli) => {
+			const args = parseCommandArgs(definition, argv);
+			return await definition.run({
+				args,
+				cli,
+				rawArgs: argv,
+				passthrough
+			}) ?? 0;
+		}
+	};
+}
+/** Parses `argv` (without the command name and without `--` pass-through) for `command`. */
+function parseCommandArgs(command, argv) {
+	checkOptions(command, argv);
+	let parsed;
+	try {
+		parsed = parseArgs([...argv], command.args);
+	} catch (error) {
+		throw new UsageError(stripAnsi(error instanceof Error ? error.message : String(error)));
+	}
+	const positionals = Object.values(command.args).filter((arg) => arg.type === "positional").length;
+	const extra = parsed._.slice(positionals);
+	if (extra.length > 0) throw new UsageError(`Unexpected argument${extra.length > 1 ? "s" : ""}: ${extra.join(" ")}`);
+	return parsed;
+}
+function optionTable(args) {
+	const table = /* @__PURE__ */ new Map([["help", { type: "boolean" }], ["h", { type: "boolean" }]]);
+	for (const [name, def] of Object.entries(args)) {
+		if (def.type === "positional") continue;
+		const info = { type: def.type };
+		for (const key of [
+			name,
+			kebabCase(name),
+			camelCase(name),
+			...aliasesOf(def)
+		]) table.set(key, info);
+	}
+	return table;
+}
+function aliasesOf(def) {
+	if (!("alias" in def) || def.alias === void 0) return [];
+	return Array.isArray(def.alias) ? [...def.alias] : [def.alias];
+}
+function checkOptions(command, argv) {
+	const table = optionTable(command.args);
+	const longNames = [...table.keys()].filter((name) => name.length > 1);
+	for (let index = 0; index < argv.length; index++) {
+		const token = argv[index] ?? "";
+		if (!token.startsWith("-") || token === "-") continue;
+		if (token.startsWith("--")) {
+			const [rawName = "", inlineValue] = token.slice(2).split(/=(.*)/s, 2);
+			let info = table.get(rawName);
+			if (info === void 0 && rawName.startsWith("no-")) {
+				const negated = table.get(rawName.slice(3));
+				if (negated?.type === "boolean") info = negated;
+			}
+			if (info === void 0) {
+				const candidate = suggest(rawName, longNames);
+				throw new UsageError(`Unknown option --${rawName}`, candidate === void 0 ? [] : [`did you mean --${candidate}?`]);
+			}
+			if ((info.type === "string" || info.type === "enum") && inlineValue === void 0) index++;
+			continue;
+		}
+		const letters = token.slice(1);
+		for (const [position, letter] of [...letters].entries()) {
+			const info = table.get(letter);
+			if (info === void 0) throw new UsageError(`Unknown option -${letter}`);
+			if ((info.type === "string" || info.type === "enum") && position === letters.length - 1) index++;
+		}
+	}
+}
+/** Formats the help of a command. */
+function renderCommandHelp(command, colors) {
+	const { meta } = command;
+	const entries = Object.entries(command.args);
+	const positionals = entries.filter(([, def]) => def.type === "positional");
+	const options = entries.filter(([, def]) => def.type !== "positional");
+	const usage = meta.usage ?? [...positionals.map(([name, def]) => def.required === false || def.default !== void 0 ? `[${name}]` : `<${name}>`), options.length > 0 ? "[options]" : ""].filter(Boolean).join(" ");
+	const lines = [`${colors.bold(`znight ${meta.name}`)} ${colors.dim("—")} ${meta.description}`, ""];
+	lines.push(colors.bold("Usage"), `  ${colors.cyan(`znight ${meta.name}${usage === "" ? "" : ` ${usage}`}`)}`, "");
+	if (meta.aliases !== void 0 && meta.aliases.length > 0) lines.push(colors.bold("Aliases"), `  ${meta.aliases.join(", ")}`, "");
+	if (positionals.length > 0) {
+		lines.push(colors.bold("Arguments"));
+		lines.push(...table(positionals.map(([name, def]) => [name, def.description ?? ""]), colors));
+		lines.push("");
+	}
+	const optionRows = options.map(([name, def]) => [optionLabel(name, def), describeOption(def)]);
+	optionRows.push(["-h, --help", "Show this help"]);
+	lines.push(colors.bold("Options"), ...table(optionRows, colors), "");
+	if (meta.details !== void 0) lines.push(typeof meta.details === "function" ? meta.details(colors) : meta.details, "");
+	if (meta.examples !== void 0 && meta.examples.length > 0) lines.push(colors.bold("Examples"), ...meta.examples.map((example) => `  ${colors.dim("$")} ${example}`), "");
+	return lines.join("\n");
+}
+function optionLabel(name, def) {
+	const short = aliasesOf(def).filter((alias) => alias.length === 1).map((alias) => `-${alias}, `).join("");
+	const flag = def.type === "boolean" && def.default === true ? `--no-${name}` : `--${name}`;
+	let value = "";
+	if (def.type === "enum") value = ` <${(def.options ?? []).join("|")}>`;
+	else if (def.type === "string") value = ` <${def.valueHint ?? name}>`;
+	return `${short}${flag}${value}`;
+}
+function describeOption(def) {
+	const description = def.description ?? "";
+	if (def.type === "boolean") return description;
+	return def.default === void 0 || def.default === "" ? description : `${description} (default: ${def.default})`;
+}
+/** Two aligned columns. */
+function table(rows, colors) {
+	const width = Math.max(0, ...rows.map(([left]) => left.length));
+	return rows.map(([left, right]) => `  ${colors.cyan(left.padEnd(width))}  ${right}`.trimEnd());
+}
+// src/integrations/resolve.ts
+/**
+* Imports `specifier` as resolved from the project `root` (the versions the project installed, like
+* `vite` and `tsc` do), or with `fallback` (resolved from the CLI) when the project does not have it.
+*/
+async function importFromProject(specifier, root, fallback) {
+	const resolved = resolveFromProject(specifier, root);
+	if (resolved !== void 0) try {
+		return await import(pathToFileURL(resolved).href);
+	} catch (error) {
+		if (!isModuleNotFound(error)) throw error;
+	}
+	return fallback();
+}
+/** Absolute path of `specifier` resolved from `root`, or `undefined`. */
+function resolveFromProject(specifier, root) {
+	try {
+		return createRequire(join(root, "package.json")).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+function isModuleNotFound(error) {
+	const code = error?.code;
+	return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+}
+// src/integrations/compiler.ts
+/**
+* The `@znight/compiler` programmatic API (spec §6.2), loaded lazily: commands that do not compile
+* (`new`, `g`, `start`) never load it. Commands use {@link CompilerApi} so tests can inject a fake.
+*
+* The CLI only relies on the documented shapes below (structural types, no type import from the
+* compiler), so any `@znight/compiler` of the same major version works.
+*/
+/**
+* Not a literal in `import()`: the CLI type-checks and bundles without the compiler (an optional
+* peer dependency), whose version is the project's.
+*/
+const COMPILER_PACKAGE = "@znight/compiler";
+/**
+* Loads `@znight/compiler` as installed in the project (falls back to the CLI's own peer) and adapts
+* it to {@link CompilerApi}.
+*/
+async function loadCompiler(root) {
+	let module;
+	try {
+		module = await importFromProject(COMPILER_PACKAGE, root, () => import(COMPILER_PACKAGE));
+	} catch (error) {
+		throw new CliError("Cannot load @znight/compiler", {
+			cause: error,
+			hints: ["install it in your project: npm install -D @znight/compiler vite"]
+		});
+	}
+	return adaptCompilerModule(module);
+}
+function readText(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+}
+/**
+* Adapts a loaded compiler module: `generate()` / `generate({ check })` / `createCompiler()` when
+* available, otherwise the same behaviour built on `compile()`.
+*/
+function adaptCompilerModule(module) {
+	const { compile, generate, createCompiler, loadZnightConfig } = module;
+	if (typeof compile !== "function" && typeof generate !== "function") throw new CliError("This version of @znight/compiler exposes neither compile() nor generate()", { hints: ["upgrade @znight/compiler to the version of @znight/cli"] });
+	const format = module.formatDiagnostics ?? fallbackFormatDiagnostics;
+	/** Pure compile: `compile()`, else `generate({ check: true })` (never writes). */
+	const compileOnly = (options) => typeof compile === "function" ? compile(options) : generate({
+		...options,
+		check: true
+	});
+	/** Write-if-changed on top of a compile result, when the compiler did not write itself. */
+	const written = (result, before) => ({
+		...result,
+		written: Array.isArray(result.written) ? result.written.length > 0 : before !== readText(result.outFile)
+	});
+	const generateOnce = async (options) => {
+		if (typeof generate === "function") {
+			const before = readText(resolveOutFile(options));
+			return written(await generate(options), before);
+		}
+		const result = await compileOnly(options);
+		const changed = !hasErrors(result.diagnostics) && writeIfChanged(result.outFile, result.diskCode ?? result.code);
+		return {
+			...result,
+			written: changed
+		};
+	};
+	return {
+		generate: generateOnce,
+		check: async (options) => {
+			const result = typeof generate === "function" ? await generate({
+				...options,
+				check: true
+			}) : await compileOnly(options);
+			const staleFiles = Array.isArray(result.staleFiles) ? result.staleFiles : staleOutputs(result);
+			const stale = typeof result.stale === "boolean" ? result.stale : staleFiles.length > 0;
+			return {
+				...result,
+				stale,
+				staleFiles: stale ? staleFiles : []
+			};
+		},
+		createIncremental: (options) => {
+			const compiler = typeof createCompiler === "function" ? createCompiler(options) : void 0;
+			const incremental = compiler?.generate;
+			const outFile = resolveOutFile(options);
+			const isOutFile = (file) => typeof compiler?.isOutFile === "function" ? compiler.isOutFile(file) : resolve(file) === outFile;
+			const { includeRoots, isRelevantChange } = module;
+			return {
+				generate: async (changes) => {
+					if (compiler === void 0 || typeof incremental !== "function") return generateOnce(options);
+					const before = readText(outFile);
+					return written(await incremental.call(compiler, changes), before);
+				},
+				isOutFile,
+				includeRoots: () => compiler !== void 0 && typeof includeRoots === "function" ? includeRoots(compiler) : [resolve(options.root ?? ".")],
+				isRelevantChange: (kind, file, watched, roots) => compiler !== void 0 && typeof isRelevantChange === "function" ? isRelevantChange(compiler, kind, file, watched, roots) : !isOutFile(file)
+			};
+		},
+		formatDiagnostics: (diagnostics, options) => format(diagnostics, options),
+		...typeof loadZnightConfig === "function" ? { loadConfig: (root) => loadZnightConfig(root) } : {}
+	};
+}
+/**
+* The generated files of a compile result that differ from the disk: the module, and
+* `znight.providers.json` in library mode. None with errors (nothing would be written).
+*/
+function staleOutputs(result) {
+	if (hasErrors(result.diagnostics)) return [];
+	const outputs = [{
+		file: result.outFile,
+		content: result.diskCode ?? result.code
+	}];
+	const { file, content } = result.library ?? {};
+	if (typeof file === "string" && typeof content === "string") outputs.push({
+		file,
+		content
+	});
+	return outputs.filter((output) => readText(output.file) !== output.content).map((output) => output.file);
+}
+/** Absolute path of the generated module for `options`. */
+function resolveOutFile(options) {
+	return resolve(options.root ?? ".", options.outFile ?? "src/.znight/container.generated.ts");
+}
+/** Whether a list of diagnostics contains an error. */
+function hasErrors(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+/** Writes `content` to `file` unless it already has that exact content. Returns whether it wrote. */
+function writeIfChanged(file, content) {
+	if (existsSync(file) && readFileSync(file, "utf8") === content) return false;
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, content);
+	return true;
+}
+/**
+* Plain formatter used when the installed compiler has no `formatDiagnostics()`:
+*
+* ```
+* ✗ ZNIGHT001: Missing provider for 'EmailService' required by NotificationService
+*   --> src/notification/notification.service.ts:12:5
+*   = hint: Add @Injectable() to EmailService
+* ```
+*/
+function fallbackFormatDiagnostics(diagnostics, options = {}) {
+	const colors = createColors(options.color === true);
+	const blocks = [];
+	for (const diagnostic of diagnostics) {
+		const head = diagnostic.severity === "error" ? colors.red(`✗ ${diagnostic.code}: ${diagnostic.message}`) : colors.yellow(`! ${diagnostic.code}: ${diagnostic.message}`);
+		const lines = [colors.bold(head)];
+		if (diagnostic.location !== void 0) lines.push(`  ${colors.cyan("-->")} ${formatLocation(diagnostic.location, options.cwd)}`);
+		for (const hint of diagnostic.hints ?? []) lines.push(`  ${colors.dim("=")} ${colors.bold("hint:")} ${hint}`);
+		for (const related of diagnostic.related ?? []) lines.push(`  ${colors.dim("=")} ${colors.bold("note:")} ${related.message} (${formatLocation(related.location, options.cwd)})`);
+		blocks.push(lines.join("\n"));
+	}
+	return blocks.join("\n\n");
+}
+function formatLocation(location, cwd) {
+	return `${cwd === void 0 ? location.file : relative(cwd, location.file).replaceAll("\\", "/")}:${location.line}:${location.column}`;
+}
+// src/integrations/openapi.ts
+/** Not literals in `import()`: the CLI builds without `@znight/openapi` (an optional peer). */
+const EMIT_MODULE = "@znight/openapi/emit";
+const VITE_MODULE = "@znight/openapi/vite";
+const MISSING_HINTS = ["install it in your project: npm install @znight/openapi"];
+/** Loads `@znight/openapi/emit` as installed in the project. */
+async function loadOpenApiEmit(root) {
+	let module;
+	try {
+		module = await importFromProject(EMIT_MODULE, root, () => import(EMIT_MODULE));
+	} catch (error) {
+		throw new CliError("Cannot load @znight/openapi", {
+			cause: error,
+			hints: MISSING_HINTS
+		});
+	}
+	if (typeof module.emitOpenApi !== "function") throw new CliError("This version of @znight/openapi has no emitOpenApi()", { hints: ["upgrade @znight/openapi to the version of @znight/cli"] });
+	return module;
+}
+/** Loads `@znight/openapi/vite` as installed in the project. */
+async function loadOpenApiVite(root) {
+	let module;
+	try {
+		module = await importFromProject(VITE_MODULE, root, () => import(VITE_MODULE));
+	} catch (error) {
+		throw new CliError("Cannot load @znight/openapi", {
+			cause: error,
+			hints: MISSING_HINTS
+		});
+	}
+	if (typeof module.openapi !== "function") throw new CliError("This version of @znight/openapi has no openapi() Vite plugin", { hints: ["upgrade @znight/openapi to the version of @znight/cli"] });
+	return module;
+}
+// src/integrations/process.ts
+/**
+* Child processes: the application (`znight dev` / `znight start`) and tools (`git`, package
+* managers). Behind {@link ProcessService} so that tests can use fake processes.
+*/
+const detachedChildren = /* @__PURE__ */ new Set();
+let exitHookInstalled = false;
+function killDetachedChildren() {
+	for (const child of detachedChildren) killTree(child, "SIGKILL", true);
+}
+function killTree(child, signal, detached) {
+	if (child.exitCode !== null || child.signalCode !== null) return false;
+	if (detached && child.pid !== void 0 && process.platform !== "win32") try {
+		process.kill(-child.pid, signal);
+		return true;
+	} catch {}
+	return child.kill(signal);
+}
+function cleanEnv(env) {
+	const result = {};
+	for (const [key, value] of Object.entries(env)) if (value !== void 0) result[key] = value;
+	return result;
+}
+/** Starts a process with `node:child_process`. */
+function spawnProcess(command, args, options) {
+	const detached = options.detached === true && process.platform !== "win32";
+	const child = spawn(command, [...args], {
+		cwd: options.cwd,
+		env: cleanEnv(options.env),
+		stdio: options.stdio ?? "inherit",
+		detached,
+		windowsHide: true
+	});
+	if (detached) {
+		detachedChildren.add(child);
+		if (!exitHookInstalled) {
+			exitHookInstalled = true;
+			process.on("exit", killDetachedChildren);
+		}
+	}
+	const exited = new Promise((resolve) => {
+		child.once("error", (error) => {
+			detachedChildren.delete(child);
+			resolve({
+				code: null,
+				signal: null,
+				error
+			});
+		});
+		child.once("exit", (code, signal) => {
+			detachedChildren.delete(child);
+			resolve({
+				code,
+				signal
+			});
+		});
+	});
+	return {
+		pid: child.pid,
+		kill: (signal) => killTree(child, signal, detached),
+		exited
+	};
+}
+/** Runs a command to completion with `node:child_process`, capturing stdout and stderr. */
+function runProcess(command, args, options) {
+	return new Promise((resolve) => {
+		const child = spawn(command, [...args], {
+			cwd: options.cwd,
+			env: cleanEnv(options.env),
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true,
+			shell: process.platform === "win32"
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.setEncoding("utf8").on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr?.setEncoding("utf8").on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.once("error", (error) => resolve({
+			code: null,
+			signal: null,
+			error,
+			stdout,
+			stderr
+		}));
+		child.once("close", (code, signal) => resolve({
+			code,
+			signal,
+			stdout,
+			stderr
+		}));
+	});
+}
+/** The default {@link ProcessService}. */
+function createProcessService() {
+	const execve = process.execve;
+	return {
+		spawn: spawnProcess,
+		run: runProcess,
+		execve: typeof execve === "function" && process.platform !== "win32" ? (file, args, env, cwd) => {
+			process.chdir(cwd);
+			execve.call(process, file, [...args], { ...env });
+		} : void 0
+	};
+}
+/** Exit code of the CLI mirroring a child's exit status (`128 + n` for signals, like shells). */
+function exitCodeOf(status) {
+	if (status.code !== null) return status.code;
+	if (status.signal !== null) return 128 + (constants$1.signals[status.signal] ?? 1);
+	return 1;
+}
+// src/integrations/prompts.ts
+/**
+* Interactive prompts of `znight new`, backed by `@clack/prompts` (loaded lazily). A cancelled
+* prompt (Ctrl+C, Escape) throws a {@link CancelledError}.
+*/
+/** Loads `@clack/prompts` and adapts it to {@link Prompts}. */
+async function loadPrompts() {
+	const clack = await import("@clack/prompts");
+	const unwrap = (value) => {
+		if (clack.isCancel(value) || typeof value === "symbol") throw new CancelledError("Operation cancelled");
+		return value;
+	};
+	const toOptions = (choices) => choices.map((choice) => ({
+		value: choice.value,
+		label: choice.label,
+		...choice.hint === void 0 ? {} : { hint: choice.hint }
+	}));
+	return {
+		intro: (title) => clack.intro(title),
+		outro: (message) => clack.outro(message),
+		text: async (options) => unwrap(await clack.text({
+			message: options.message,
+			...options.placeholder === void 0 ? {} : { placeholder: options.placeholder },
+			...options.initialValue === void 0 ? {} : { initialValue: options.initialValue },
+			...options.validate === void 0 ? {} : { validate: (value) => options.validate?.(value ?? "") }
+		})),
+		select: async (options) => {
+			const value = await clack.select({
+				message: options.message,
+				options: toOptions(options.choices),
+				...options.initialValue === void 0 ? {} : { initialValue: options.initialValue }
+			});
+			return unwrap(value);
+		},
+		multiselect: async (options) => {
+			const value = await clack.multiselect({
+				message: options.message,
+				required: false,
+				options: toOptions(options.choices),
+				...options.initialValues === void 0 ? {} : { initialValues: [...options.initialValues] }
+			});
+			return unwrap(value);
+		},
+		confirm: async (options) => unwrap(await clack.confirm({
+			message: options.message,
+			...options.initialValue === void 0 ? {} : { initialValue: options.initialValue }
+		})),
+		spinner: () => {
+			const spinner = clack.spinner();
+			return {
+				start: (message) => spinner.start(message),
+				stop: (message, failed = false) => failed ? spinner.error(message) : spinner.stop(message)
+			};
+		},
+		note: (message, title) => clack.note(message, title)
+	};
+}
+// src/integrations/vite.ts
+/** Loads `vite` as installed in the project. */
+async function loadVite(root) {
+	try {
+		return await importFromProject("vite", root, () => import("vite"));
+	} catch (error) {
+		throw new CliError("Cannot load vite", {
+			cause: error,
+			hints: ["install it in your project: npm install -D vite @znight/compiler"]
+		});
+	}
+}
+/** Creates an {@link OutputTracker}; relative output paths are resolved against the Vite root. */
+function createOutputTracker(root) {
+	let entry;
+	let started;
+	let api;
+	let compile;
+	let viteRoot = root;
+	return {
+		plugin: {
+			name: "znight:cli-output",
+			configResolved(config) {
+				api = findZnightApi(config.plugins);
+				if (typeof config.root === "string") viteRoot = config.root;
+			},
+			buildStart() {
+				started = performance.now();
+				compile = void 0;
+			},
+			writeBundle(outputOptions, bundle) {
+				compile = compileOutcome(api?.result);
+				const chunks = Object.values(bundle).filter((output) => output.type === "chunk" && output.isEntry);
+				const chunk = chunks.find((candidate) => candidate.name === "main") ?? chunks[0];
+				if (chunk === void 0) return;
+				entry = outputOptions.file === void 0 ? resolve(viteRoot, outputOptions.dir ?? "dist", chunk.fileName) : resolve(viteRoot, outputOptions.file);
+			}
+		},
+		entry: () => entry,
+		startedAt: () => started,
+		compile: () => compile
+	};
+}
+/** The `plugin.api` of the `znight()` plugin among the resolved plugins. */
+function findZnightApi(plugins) {
+	for (const plugin of plugins) {
+		if (typeof plugin !== "object" || plugin === null || plugin.name !== "znight") continue;
+		const api = plugin.api;
+		if (typeof api === "object" && api !== null && "result" in api) return api;
+	}
+}
+function compileOutcome(result) {
+	if (typeof result !== "object" || result === null) return void 0;
+	const { ok, diagnostics } = result;
+	if (typeof ok !== "boolean") return void 0;
+	return {
+		ok,
+		diagnostics: Array.isArray(diagnostics) ? diagnostics : []
+	};
+}
+/** Name of {@link projectRootPlugin}. */
+const ROOT_PLUGIN = "znight:cli-root";
+/**
+* Resolves the Vite root like the Vite CLI run in the project directory: the `root` of the config
+* file against `projectRoot`, or `projectRoot` without one. An inline `root` would override the
+* config file's, so the CLI sets it from the first `config` hook instead.
+*/
+function projectRootPlugin(projectRoot) {
+	return {
+		name: ROOT_PLUGIN,
+		config: {
+			order: "pre",
+			handler: (config) => ({ root: resolve(projectRoot, config.root ?? ".") })
+		}
+	};
+}
+function inlineConfig(options, watch) {
+	return {
+		configFile: findViteConfig(options.root, options.configFile) ?? false,
+		mode: options.mode,
+		logLevel: options.logLevel,
+		...options.configLoader === void 0 ? {} : { configLoader: options.configLoader },
+		clearScreen: false,
+		plugins: [projectRootPlugin(options.root), ...options.plugins ?? []],
+		build: watch ? { watch: {} } : {}
+	};
+}
+/** Runs `vite build` once. Throws the build error. */
+async function runBuild(vite, options) {
+	const result = await vite.build(inlineConfig(options, false));
+	if (isWatcher(result)) await result.close();
+}
+/** Starts `vite build --watch`. */
+async function watchBuild(vite, options) {
+	const result = await vite.build(inlineConfig(options, true));
+	if (!isWatcher(result)) throw new CliError("vite build did not start in watch mode", { hints: ["check that your Vite config does not override \"build.watch\""] });
+	return result;
+}
+function isWatcher(value) {
+	return typeof value === "object" && value !== null && typeof value.on === "function" && typeof value.close === "function";
+}
+/** Vite's `DEFAULT_CONFIG_FILES`, in its order. */
+const CONFIG_FILES = [
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.ts",
+	"vite.config.cjs",
+	"vite.config.mts",
+	"vite.config.cts"
+];
+/** The Vite config file of the project (the one Vite would load from `root`), if any. */
+function findViteConfig(root, configFile) {
+	if (configFile !== void 0) return resolve(root, configFile);
+	return CONFIG_FILES.map((file) => join(root, file)).find((file) => existsSync(file));
+}
+/**
+* Resolves the project's Vite config as `znight build` does and reads the options the `znight()`
+* plugin compiles with, so that `znight generate` compiles exactly like the Vite build. Returns
+* `undefined` without a config file. `process.env.NODE_ENV`, which Vite sets, is left untouched.
+*/
+async function readZnightPluginOptions(vite, root, configFile, configLoader) {
+	const file = findViteConfig(root, configFile);
+	const resolveConfig = vite.resolveConfig;
+	if (file === void 0 || resolveConfig === void 0) return void 0;
+	const inline = {
+		configFile: file,
+		mode: "production",
+		logLevel: "silent",
+		...configLoader === void 0 ? {} : { configLoader },
+		plugins: [projectRootPlugin(root)]
+	};
+	const config = await preservingNodeEnv(() => resolveConfig.call(vite, inline, "build", "production", "production"));
+	const loaded = config.configFile ?? file;
+	for (const plugin of config.plugins) {
+		if (typeof plugin !== "object" || plugin === null) continue;
+		const name = plugin.name;
+		if (typeof name !== "string" || !isZnightPluginName(name)) continue;
+		return {
+			configFile: loaded,
+			found: true,
+			options: compileOptionsOf(plugin, config)
+		};
+	}
+	return {
+		configFile: loaded,
+		found: false
+	};
+}
+/** `znight` and its sub-plugins (`znight:*`), not the CLI's own plugins. */
+function isZnightPluginName(name) {
+	return name === "znight" || name.startsWith("znight:") && !name.startsWith("znight:cli-");
+}
+async function preservingNodeEnv(run) {
+	const nodeEnv = process.env["NODE_ENV"];
+	try {
+		return await run();
+	} finally {
+		if (nodeEnv === void 0) delete process.env["NODE_ENV"];
+		else process.env["NODE_ENV"] = nodeEnv;
+	}
+}
+const isObject = (value) => typeof value === "object" && value !== null;
+/** {@link ZnightPluginLookup.options}: the compiler's resolved options when exposed, else derived. */
+function compileOptionsOf(plugin, config) {
+	const api = plugin.api;
+	let options = {};
+	let resolved;
+	if (isObject(api)) {
+		const value = typeof api["getOptions"] === "function" ? api["getOptions"].call(api) : api["options"];
+		if (isObject(value)) options = value;
+		const compiler = api["compiler"];
+		if (isObject(compiler) && isObject(compiler["options"])) resolved = compiler["options"];
+	}
+	const root = typeof resolved?.["root"] === "string" ? resolved["root"] : resolve(config.root, options.root ?? ".");
+	const aliases = Array.isArray(resolved?.["aliases"]) ? resolved["aliases"] : stringAliases(config.resolve?.alias);
+	const conditions = resolved?.["runtimeConditions"];
+	return {
+		...options,
+		root,
+		...aliases.length > 0 ? { aliases } : {},
+		...Array.isArray(conditions) ? { runtimeConditions: conditions } : {}
+	};
+}
+/** The string entries of Vite's (resolved) `resolve.alias`: the compiler ignores RegExp aliases. */
+function stringAliases(alias) {
+	if (!Array.isArray(alias)) return [];
+	return alias.filter((entry) => isObject(entry) && typeof entry["find"] === "string" && typeof entry["replacement"] === "string");
+}
+/** Message of a Vite/Rolldown build error, with its location and code frame when available. */
+function formatBuildError(error) {
+	if (!(error instanceof Error)) return String(error);
+	const details = error;
+	const lines = [details.plugin === void 0 ? error.message : `[${details.plugin}] ${error.message}`];
+	const file = details.loc?.file ?? details.id;
+	if (file !== void 0 && !error.message.includes(file)) lines.push(details.loc === void 0 ? `  --> ${file}` : `  --> ${file}:${details.loc.line}:${details.loc.column}`);
+	if (details.frame !== void 0 && details.frame !== "" && !error.message.includes(details.frame)) lines.push(details.frame);
+	return lines.join("\n");
+}
+// src/integrations/watch.ts
+const IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"coverage"
+]);
+/** Native separators to forward slashes (the compiler's path style, also on Windows). */
+function toPosixPath(path) {
+	return path.includes("\\") ? path.replaceAll("\\", "/") : path;
+}
+/**
+* The absolute, POSIX-style real path of `path` (symbolic links resolved and the on-disk casing:
+* `/var` → `/private/var` on macOS), also when its last segments do not exist (anymore): the real
+* path of the deepest existing parent, then the rest. Makes watcher paths comparable with the
+* compiler's.
+*/
+function realPath(path) {
+	const absolute = resolve(path);
+	try {
+		return toPosixPath(realpathSync.native(absolute));
+	} catch {
+		const parent = resolve(absolute, "..");
+		if (parent === absolute) return toPosixPath(absolute);
+		return `${realPath(parent).replace(/\/$/, "")}/${posix.basename(toPosixPath(absolute))}`;
+	}
+}
+/**
+* Whether a path relative to a watched directory is never relevant: inside `node_modules`, `dist`,
+* `coverage` or a dot directory (`.git`, `.znight`...).
+*/
+function isIgnoredPath(relativePath) {
+	return relativePath.split(/[\\/]/).some((segment) => IGNORED_SEGMENTS.has(segment) || segment.startsWith("."));
+}
+/** `true` when `file` is `directory` or inside it (absolute POSIX paths). */
+function isWithin(directory, file) {
+	return file === directory || file.startsWith(directory.endsWith("/") ? directory : `${directory}/`);
+}
+/** Drops the directories nested in another one; sorted, de-duplicated. */
+function outermost(directories) {
+	const sorted = [...new Set(directories)].sort();
+	return sorted.filter((directory) => !sorted.some((other) => other !== directory && isWithin(other, directory)));
+}
+/**
+* Directories to watch: the include `roots` (`includeRoots()` of the compiler) recursively; the
+* project `root` and the directories of `files` (the `watchFiles` of the last compile) that are
+* outside them, non-recursively.
+*/
+function watchTargets(root, roots, files = []) {
+	const recursive = outermost(roots.map(toPosixPath));
+	const covered = (directory) => recursive.some((base) => isWithin(base, directory));
+	const flat = /* @__PURE__ */ new Set();
+	const directories = [toPosixPath(resolve(root))];
+	for (const file of files) directories.push(posix.dirname(toPosixPath(resolve(file))));
+	for (const directory of directories) if (!covered(directory)) flat.add(directory);
+	return [...recursive.map((path) => ({
+		path,
+		recursive: true
+	})), ...[...flat].sort().map((path) => ({
+		path,
+		recursive: false
+	}))];
+}
+function kindOf(path) {
+	try {
+		return statSync(path).isDirectory() ? "directory" : "file";
+	} catch {
+		return "missing";
+	}
+}
+/** The known files inside `directory`. */
+function knownWithin(known, directory) {
+	const prefix = directory.endsWith("/") ? directory : `${directory}/`;
+	return [...known].filter((file) => file.startsWith(prefix));
+}
+/**
+* The kind of an `fs.watch` event on `file` (absolute, real, POSIX-style), which `fs.watch` does not
+* tell, from the disk and the files of the last compile (`known`): `removed` when it is gone,
+* `changed` for a known file, `added` otherwise (a new file, a directory created or moved there).
+*/
+function changeKind(file, known) {
+	switch (kindOf(file)) {
+		case "missing": return "removed";
+		case "directory": return "added";
+		default: return known.has(file) ? "changed" : "added";
+	}
+}
+/**
+* Classifies relevant paths (`isRelevantChange()` of the compiler) for the incremental compiler,
+* given the files of the last compile: a deleted path is removed with the known files it contained
+* (a directory moved away), an existing directory is added (the compiler re-runs the scan) and the
+* known files it contains are re-read (or removed when gone), an existing file is changed when
+* known, added otherwise.
+*/
+function classifyChanges(files, known) {
+	const changed = /* @__PURE__ */ new Set();
+	const added = /* @__PURE__ */ new Set();
+	const removed = /* @__PURE__ */ new Set();
+	for (const file of files) switch (kindOf(file)) {
+		case "missing":
+			removed.add(file);
+			for (const inner of knownWithin(known, file)) removed.add(inner);
+			break;
+		case "directory":
+			added.add(file);
+			for (const inner of knownWithin(known, file)) (existsSync(inner) ? changed : removed).add(inner);
+			break;
+		default: if (known.has(file)) changed.add(file);
+		else added.add(file);
+	}
+	return {
+		changed: [...changed].filter((file) => !removed.has(file)),
+		added: [...added].filter((file) => !removed.has(file)),
+		removed: [...removed]
+	};
+}
+/** The default {@link WatchFactory}, based on `fs.watch`. */
+const watchFiles = (targets, onChange) => {
+	const watchers = [];
+	for (const target of targets) {
+		if (!existsSync(target.path)) continue;
+		let watcher;
+		try {
+			watcher = watch(target.path, { recursive: target.recursive }, (_event, filename) => {
+				if (filename === null) {
+					onChange(target.path);
+					return;
+				}
+				const name = filename.toString();
+				if (!isIgnoredPath(name)) onChange(join(target.path, name));
+			});
+		} catch {
+			continue;
+		}
+		watcher.on("error", () => {});
+		watchers.push(watcher);
+	}
+	return { close: () => {
+		for (const watcher of watchers) watcher.close();
+	} };
+};
+const targetKey = (target) => `${target.recursive ? "r" : "f"}:${target.path}`;
+/**
+* The watchers of a set of targets that changes after every compile: one watcher per target (started
+* with a {@link WatchFactory}), so that unchanged targets keep their watcher.
+*/
+var TargetWatchers = class {
+	#factory;
+	#onChange;
+	#watchers = /* @__PURE__ */ new Map();
+	constructor(factory, onChange) {
+		this.#factory = factory;
+		this.#onChange = onChange;
+	}
+	/** The watched targets. */
+	get targets() {
+		return [...this.#watchers.keys()].map((key) => ({
+			path: key.slice(2),
+			recursive: key.startsWith("r")
+		}));
+	}
+	/**
+	* Watches exactly `targets`: stops the watchers of the targets that are gone, starts the new ones,
+	* and restarts those whose directory was missing when they started, or was itself created, moved or
+	* deleted since (`touched`: the paths of the last changes).
+	*/
+	update(targets, touched = /* @__PURE__ */ new Set()) {
+		const wanted = new Map(targets.map((target) => [targetKey(target), target]));
+		for (const [key, entry] of this.#watchers) {
+			if (wanted.has(key)) continue;
+			entry.watcher.close();
+			this.#watchers.delete(key);
+		}
+		for (const [key, target] of wanted) {
+			const entry = this.#watchers.get(key);
+			const exists = existsSync(target.path);
+			if (entry !== void 0) {
+				if (!exists || entry.existed && !touched.has(target.path)) continue;
+				entry.watcher.close();
+			}
+			this.#watchers.set(key, {
+				watcher: this.#factory([target], this.#onChange),
+				existed: exists
+			});
+		}
+	}
+	close() {
+		for (const entry of this.#watchers.values()) entry.watcher.close();
+		this.#watchers.clear();
+	}
+};
+// src/runtime.ts
+/**
+* JavaScript runtimes the application can run on (`znight dev`, `znight start`) and executable
+* lookup in `PATH`.
+*/
+/** Detects the runtime executing this process. */
+function detectHostRuntime() {
+	return {
+		name: typeof process.versions["bun"] === "string" ? "bun" : "node",
+		execPath: process.execPath,
+		platform: process.platform
+	};
+}
+/** Resolves `auto`. */
+function resolveRuntime(option, host) {
+	return option === void 0 || option === "auto" ? host.name : option;
+}
+/**
+* Finds an executable in `PATH` (`PATHEXT` extensions on Windows). Absolute paths are checked as is.
+* Returns `undefined` when not found.
+*/
+function which(command, env, platform = process.platform) {
+	const extensions = platform === "win32" ? ["", ...(env["PATHEXT"] ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)] : [""];
+	const candidates = isAbsolute(command) ? [command] : (env["PATH"] ?? env["Path"] ?? "").split(platform === "win32" ? ";" : delimiter).filter((directory) => directory !== "").map((directory) => join(directory, command));
+	for (const candidate of candidates) for (const extension of extensions) {
+		const file = candidate + extension;
+		if (isExecutable(file, platform)) return file;
+	}
+}
+function isExecutable(file, platform) {
+	try {
+		if (!statSync(file).isFile()) return false;
+		if (platform !== "win32") accessSync(file, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* The executable of `runtime`: the running executable when it is that runtime, otherwise the one
+* found in `PATH`.
+*/
+function runtimeExecutable(runtime, host, env) {
+	if (runtime === host.name) return host.execPath;
+	return which(runtime, env, host.platform);
+}
+/** Runtime arguments placed before the entry file. */
+function runtimeArguments(runtime, extra = []) {
+	return runtime === "node" ? ["--enable-source-maps", ...extra] : [...extra];
+}
+// src/version.ts
+let cached;
+/**
+* Version of `@znight/cli`, read from its `package.json` (one level above both `src/` and `dist/`).
+* Projects created by `znight new` depend on `@znight/*` packages at `^<version>`.
+*/
+function cliVersion() {
+	if (cached === void 0) try {
+		const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+		cached = typeof version === "string" ? version : "0.0.0";
+	} catch {
+		cached = "0.0.0";
+	}
+	return cached;
+}
+// src/context.ts
+const processSignals = {
+	on: (signal, listener) => {
+		process.on(signal, listener);
+	},
+	off: (signal, listener) => {
+		process.off(signal, listener);
+	}
+};
+/**
+* Creates a context from the current process, with optional overrides. The environment is a copy
+* of `process.env` taken now: tools running in the CLI process (Vite sets `NODE_ENV`) do not change
+* what the commands see and pass to the application.
+*/
+function createContext(options = {}) {
+	const env = options.env ?? { ...process.env };
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	const colors = createColors(shouldUseColor({
+		env,
+		stream: stdout,
+		flag: options.color
+	}));
+	const interactive = options.interactive ?? (process.stdin.isTTY === true && stdout.isTTY === true && env["CI"] === void 0 && env["TERM"] !== "dumb");
+	return {
+		cwd: options.cwd ?? process.cwd(),
+		env,
+		stdout,
+		stderr,
+		interactive,
+		colors,
+		reporter: createReporter(stdout, stderr, colors),
+		runtime: options.runtime ?? detectHostRuntime(),
+		version: options.version ?? cliVersion(),
+		signals: options.signals ?? processSignals,
+		debug: options.debug ?? (env["ZNIGHT_DEBUG"] !== void 0 && env["ZNIGHT_DEBUG"] !== "" && env["ZNIGHT_DEBUG"] !== "0"),
+		services: {
+			loadCompiler: options.services?.loadCompiler ?? loadCompiler,
+			loadVite: options.services?.loadVite ?? loadVite,
+			loadPrompts: options.services?.loadPrompts ?? loadPrompts,
+			loadOpenApi: options.services?.loadOpenApi ?? loadOpenApiEmit,
+			loadOpenApiVite: options.services?.loadOpenApiVite ?? loadOpenApiVite,
+			processes: options.services?.processes ?? createProcessService(),
+			watch: options.services?.watch ?? watchFiles
+		}
+	};
+}
+// src/dev/supervisor.ts
+/** Keeps one application process running and restarts it on demand. */
+var AppSupervisor = class {
+	#spawn;
+	#debounceMs;
+	#killTimeoutMs;
+	#events;
+	#stopping = /* @__PURE__ */ new Set();
+	#current;
+	#debounce;
+	#queue = Promise.resolve();
+	#queued = false;
+	#closed = false;
+	#started = 0;
+	constructor(options) {
+		this.#spawn = options.spawn;
+		this.#debounceMs = options.debounceMs ?? 100;
+		this.#killTimeoutMs = options.killTimeoutMs ?? 5e3;
+		this.#events = options.events ?? {};
+	}
+	/** Whether an application process is running. */
+	get running() {
+		return this.#current !== void 0;
+	}
+	/** The running process. */
+	get current() {
+		return this.#current;
+	}
+	/** Number of processes started so far. */
+	get starts() {
+		return this.#started;
+	}
+	/** Restarts after `debounceMs`; calls in between postpone it. */
+	scheduleRestart() {
+		if (this.#closed) return;
+		if (this.#debounce !== void 0) clearTimeout(this.#debounce);
+		this.#debounce = setTimeout(() => {
+			this.#debounce = void 0;
+			this.restart();
+		}, this.#debounceMs);
+	}
+	/**
+	* Cancels a restart scheduled by {@link scheduleRestart} and not started yet (the output it would
+	* run turned out to be broken, e.g. a failed compilation). Returns whether one was pending.
+	*/
+	cancelRestart() {
+		if (this.#debounce === void 0) return false;
+		clearTimeout(this.#debounce);
+		this.#debounce = void 0;
+		return true;
+	}
+	/**
+	* Stops the current process (if any) and starts a new one. Restarts never overlap; a restart
+	* requested while another one is waiting to run is merged with it.
+	*/
+	restart() {
+		if (this.#closed) return this.#queue;
+		if (this.#queued) return this.#queue;
+		this.#queued = true;
+		this.#queue = this.#queue.then(async () => {
+			this.#queued = false;
+			if (this.#closed) return;
+			await this.#stopCurrent("SIGTERM");
+			if (this.#closed) return;
+			this.#startNew();
+		}).catch((error) => {
+			this.#queued = false;
+			this.#events.onError?.(error);
+		});
+		return this.#queue;
+	}
+	/** Stops the current process with `signal` (SIGKILL after the timeout) and refuses new starts. */
+	async stop(signal = "SIGTERM") {
+		this.#closed = true;
+		if (this.#debounce !== void 0) {
+			clearTimeout(this.#debounce);
+			this.#debounce = void 0;
+		}
+		await this.#queue;
+		await this.#stopCurrent(signal);
+	}
+	/** Immediately SIGKILLs every process (a second Ctrl+C). */
+	kill() {
+		this.#closed = true;
+		if (this.#debounce !== void 0) clearTimeout(this.#debounce);
+		this.#current?.kill("SIGKILL");
+		for (const child of this.#stopping) child.kill("SIGKILL");
+	}
+	#startNew() {
+		let child;
+		try {
+			child = this.#spawn();
+		} catch (error) {
+			this.#events.onError?.(error);
+			return;
+		}
+		const restart = this.#started > 0;
+		this.#started++;
+		this.#current = child;
+		child.exited.then((status) => {
+			if (this.#current !== child) return;
+			this.#current = void 0;
+			this.#events.onExit?.(status);
+		});
+		this.#events.onStart?.(child, restart);
+	}
+	async #stopCurrent(signal) {
+		const child = this.#current;
+		if (child === void 0) return;
+		this.#current = void 0;
+		this.#stopping.add(child);
+		try {
+			child.kill(signal);
+			let timer;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timeout"), this.#killTimeoutMs);
+			});
+			const first = await Promise.race([child.exited, timeout]);
+			clearTimeout(timer);
+			if (first === "timeout") {
+				child.kill("SIGKILL");
+				this.#events.onStop?.(await child.exited, true);
+			} else this.#events.onStop?.(first, false);
+		} finally {
+			this.#stopping.delete(child);
+		}
+	}
+};
+// src/commands/shared.ts
+/** `--root`, resolved against the working directory. Must be an existing directory. */
+function resolveRoot(cli, root) {
+	const directory = resolve(cli.cwd, root ?? ".");
+	let isDirectory = false;
+	try {
+		isDirectory = statSync(directory).isDirectory();
+	} catch {
+		isDirectory = false;
+	}
+	if (!isDirectory) throw new CliError(`Project root not found: ${directory}`);
+	return directory;
+}
+/** The nearest directory containing a `package.json`, from `start` upwards (`start` when none). */
+function findProjectRoot(start) {
+	let directory = start;
+	for (;;) {
+		if (existsSync(join(directory, "package.json"))) return directory;
+		const parent = dirname(directory);
+		if (parent === directory) return start;
+		directory = parent;
+	}
+}
+/** Reads `package.json` of `root` (an empty object when missing or invalid). */
+function readManifest(root) {
+	try {
+		const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+		return typeof manifest === "object" && manifest !== null ? manifest : {};
+	} catch {
+		return {};
+	}
+}
+/** Parses a non-negative integer option (milliseconds...). */
+function parseNonNegativeInteger(value, option, fallback) {
+	if (value === void 0 || value === "") return fallback;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 0) throw new UsageError(`Invalid value for --${option}: expected a non-negative integer, got "${value}"`);
+	return parsed;
+}
+/** An HTTP prefix option (`/api`, the `prefix` of `HttpPlugin`): `undefined` when not given. */
+function parseHttpPrefix(value, option) {
+	if (value === void 0) return void 0;
+	if (!value.startsWith("/")) throw new UsageError(`Invalid --${option} "${value}": expected a path starting with "/"`);
+	return value;
+}
+/** A path for messages: relative to `from`, or absolute when that is shorter. POSIX separators. */
+function displayPath(file, from) {
+	const path = relative(from, file);
+	if (path === "") return ".";
+	return (isAbsolute(path) || path.startsWith("..") && file.length < path.length ? file : path).split(sep).join("/");
+}
+/**
+* Signals stopping a long-running command: Ctrl+C, `kill`, the terminal closed (`SIGHUP`) and, on
+* POSIX, `Ctrl+\` (`SIGQUIT`). Without a listener the last two kill the CLI without running its exit
+* hooks, leaving the application of `znight dev` (in its own session) running.
+*/
+const TERMINATION_SIGNALS = process.platform === "win32" ? [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP"
+] : [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP",
+	"SIGQUIT"
+];
+/**
+* Calls `onFirst` on the first {@link TERMINATION_SIGNALS termination signal}; `onRepeat` runs on
+* any later one (force quit). Returns a function removing the listeners.
+*/
+function onTermination(cli, onFirst, onRepeat) {
+	let received = false;
+	const listeners = TERMINATION_SIGNALS.map((signal) => {
+		const listener = () => {
+			if (received) {
+				onRepeat(signal);
+				return;
+			}
+			received = true;
+			onFirst(signal);
+		};
+		cli.signals.on(signal, listener);
+		return [signal, listener];
+	});
+	return () => {
+		for (const [signal, listener] of listeners) cli.signals.off(signal, listener);
+	};
+}
+// src/commands/build.ts
+/** `znight build` */
+const buildCommand = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build the application for production (vite build)",
+		usage: "[options]",
+		examples: [
+			"znight build",
+			"znight build --mode staging",
+			"znight build --openapi   # also dist/openapi.json",
+			"znight build --openapi --openapi-prefix /api   # HttpPlugin.configure({ prefix: \"/api\" })"
+		],
+		details: [
+			"Fails on any compiler error. With the defaults of the znight() plugin, src/main.ts is built to dist/main.js.",
+			"--openapi emits the OpenAPI document after the bundle (dist/openapi.json, or --openapi=<path>) with the",
+			"openapi() Vite plugin of @znight/openapi, unless the Vite config already registers it. When HttpPlugin",
+			"has a prefix, pass it with --openapi-prefix: it becomes the servers of the document (unless",
+			"@OpenApiDocument declares servers), like the document the application serves in \"build\" mode."
+		].join("\n")
+	},
+	args: {
+		root: {
+			type: "string",
+			valueHint: "dir",
+			description: "Project root (default: the current directory)"
+		},
+		config: {
+			type: "string",
+			valueHint: "file",
+			description: "Vite config file (default: vite.config.*)"
+		},
+		mode: {
+			type: "string",
+			default: "production",
+			description: "Vite mode"
+		},
+		"config-loader": {
+			type: "enum",
+			options: [
+				"bundle",
+				"runner",
+				"native"
+			],
+			description: "How Vite loads the config file (default: bundle)"
+		},
+		"log-level": {
+			type: "enum",
+			options: [
+				"info",
+				"warn",
+				"error",
+				"silent"
+			],
+			default: "info",
+			description: "Vite log level"
+		},
+		openapi: {
+			type: "boolean",
+			description: "Also emit the OpenAPI document (dist/openapi.json, or --openapi=<path>; needs @znight/openapi)"
+		},
+		"openapi-prefix": {
+			type: "string",
+			valueHint: "path",
+			description: "With --openapi: the HTTP prefix of HttpPlugin, the servers default of the document (/api)"
+		}
+	},
+	async run({ args, cli, rawArgs }) {
+		const root = resolveRoot(cli, args.root);
+		const openapi = openapiOption(rawArgs, args.openapi);
+		const prefix = parseHttpPrefix(args["openapi-prefix"], "openapi-prefix");
+		if (prefix !== void 0 && openapi === void 0) throw new UsageError("--openapi-prefix needs --openapi", [`znight build --openapi --openapi-prefix ${prefix}`]);
+		const vite = await cli.services.loadVite(root);
+		const tracker = createOutputTracker(root);
+		const extra = [];
+		if (openapi !== void 0) {
+			const api = await cli.services.loadOpenApiVite(root);
+			const options = {
+				...openapi === true ? {} : { output: openapi },
+				...prefix === void 0 ? {} : { prefix }
+			};
+			const plugin = api.openapi(options);
+			extra.push(plugin);
+			const given = [...options.output === void 0 ? [] : [`--openapi=${options.output}`], ...options.prefix === void 0 ? [] : [`--openapi-prefix ${options.prefix}`]];
+			if (given.length > 0) extra.push(ignoredOpenApiOptions(cli, plugin, given));
+		}
+		const started = performance.now();
+		try {
+			await runBuild(vite, {
+				root,
+				configFile: args.config,
+				configLoader: args["config-loader"],
+				mode: args.mode,
+				logLevel: args["log-level"],
+				plugins: [tracker.plugin, ...extra]
+			});
+		} catch (error) {
+			cli.reporter.logError(formatBuildError(error));
+			throw new CliError("Build failed", { cause: error });
+		}
+		const entry = tracker.entry();
+		const duration = formatDuration(performance.now() - started);
+		if (entry === void 0) {
+			cli.reporter.success(`Built in ${duration}`);
+			return 0;
+		}
+		let size = "";
+		try {
+			size = ` ${cli.colors.dim(formatBytes(statSync(entry).size))}`;
+		} catch {
+			size = "";
+		}
+		cli.reporter.success(`Built ${cli.colors.bold(displayPath(entry, cli.cwd))}${size} in ${duration}`);
+		cli.reporter.log(`  ${cli.colors.dim("run it with")} ${cli.colors.cyan("znight start")}`);
+		return 0;
+	}
+});
+/** `--openapi` (`true`), `--openapi=<path>` (the path), or `undefined`. */
+function openapiOption(rawArgs, parsed) {
+	for (const token of rawArgs) {
+		if (token.startsWith("--openapi=")) {
+			const value = token.slice(10);
+			if (value === "false") return void 0;
+			return value === "" || value === "true" ? true : value;
+		}
+		if (token === "--no-openapi") return void 0;
+	}
+	return parsed === true || rawArgs.includes("--openapi") ? true : void 0;
+}
+/**
+* When the Vite config registers its own `openapi()`, that one emits the document and the copy of the
+* CLI stays inactive: the options given on the command line (`given`) do not apply. Says so, instead
+* of emitting a document without the requested output or prefix.
+*/
+function ignoredOpenApiOptions(cli, plugin, given) {
+	return {
+		name: "znight:cli-openapi-options",
+		apply: "build",
+		configResolved(config) {
+			const active = config.plugins.find((candidate) => candidate.name === plugin.name);
+			if (active === void 0 || active === plugin) return;
+			cli.reporter.warn(`${given.join(" and ")} ignored: the openapi() plugin of the Vite config emits the document with its own options`, ["set them on openapi() in the Vite config (openapi({ output, prefix })), or remove it from there"]);
+		}
+	};
+}
+// src/commands/dev.ts
+/** Clears the terminal and its scrollback. */
+const CLEAR_SCREEN = "\x1B[2J\x1B[3J\x1B[H";
+/** `znight dev` */
+const devCommand = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Build in watch mode and restart the application after every successful rebuild",
+		usage: "[options] [-- <application arguments>]",
+		examples: [
+			"znight dev",
+			"znight dev --runtime bun --clear",
+			"znight dev --inspect -- --verbose"
+		],
+		details: [
+			"Uses \"vite build --watch\" with the project Vite config (the znight() plugin regenerates the container).",
+			"On every successful build the application receives SIGTERM, gets --kill-timeout ms to stop gracefully",
+			"(then SIGKILL), and a new process starts. A failed build or compilation (ZNIGHT errors) keeps the",
+			"last good process running."
+		].join("\n")
+	},
+	args: {
+		root: {
+			type: "string",
+			valueHint: "dir",
+			description: "Project root (default: the current directory)"
+		},
+		config: {
+			type: "string",
+			valueHint: "file",
+			description: "Vite config file (default: vite.config.*)"
+		},
+		mode: {
+			type: "string",
+			default: "development",
+			description: "Vite mode"
+		},
+		"config-loader": {
+			type: "enum",
+			options: [
+				"bundle",
+				"runner",
+				"native"
+			],
+			description: "How Vite loads the config file (default: bundle)"
+		},
+		runtime: {
+			type: "enum",
+			options: [
+				"auto",
+				"node",
+				"bun"
+			],
+			default: "auto",
+			description: "Runtime of the application (auto: the runtime running the CLI)"
+		},
+		entry: {
+			type: "string",
+			valueHint: "file",
+			description: "File to run (default: the entry chunk of the build)"
+		},
+		inspect: {
+			type: "boolean",
+			description: "Start the application with --inspect (debugger)"
+		},
+		clear: {
+			type: "boolean",
+			description: "Clear the screen before each rebuild"
+		},
+		debounce: {
+			type: "string",
+			valueHint: "ms",
+			default: "100",
+			description: "Delay before restarting after a build"
+		},
+		"kill-timeout": {
+			type: "string",
+			valueHint: "ms",
+			default: "5000",
+			description: "Time the application gets to stop after SIGTERM before SIGKILL"
+		},
+		"log-level": {
+			type: "enum",
+			options: [
+				"info",
+				"warn",
+				"error",
+				"silent"
+			],
+			default: "warn",
+			description: "Vite log level"
+		}
+	},
+	async run({ args, cli, passthrough }) {
+		const root = resolveRoot(cli, args.root);
+		const debounceMs = parseNonNegativeInteger(args.debounce, "debounce", 100);
+		const killTimeoutMs = parseNonNegativeInteger(args["kill-timeout"], "kill-timeout", 5e3);
+		const runtime = resolveRuntime(args.runtime, cli.runtime);
+		const executable = runtimeExecutable(runtime, cli.runtime, cli.env);
+		if (executable === void 0) throw new CliError(`Cannot find "${runtime}" in PATH`, { hints: ["install it, or choose another --runtime"] });
+		const logLevel = args["log-level"];
+		const { colors, reporter } = cli;
+		const env = { ...cli.env };
+		const guard = orphanGuard(runtime, {
+			parentPid: process.pid,
+			pollMs: 500,
+			killTimeoutMs
+		});
+		const runtimeArgs = runtimeArguments(runtime, [...guard?.args ?? [], ...args.inspect === true ? ["--inspect"] : []]);
+		const vite = await cli.services.loadVite(root);
+		const tracker = createOutputTracker(root);
+		let entry;
+		const supervisor = new AppSupervisor({
+			debounceMs,
+			killTimeoutMs,
+			spawn: () => {
+				const file = entry ?? resolve(root, "dist/main.js");
+				return cli.services.processes.spawn(executable, [
+					...runtimeArgs,
+					file,
+					...passthrough
+				], {
+					cwd: root,
+					env: {
+						...env,
+						...guard?.env,
+						NODE_ENV: env["NODE_ENV"] ?? "development"
+					},
+					detached: true
+				});
+			},
+			events: {
+				onStart: (child, restart) => {
+					const file = displayPath(entry ?? resolve(root, "dist/main.js"), cli.cwd);
+					reporter.info(`${restart ? "Restarted" : "Started"} ${colors.bold(file)} ${colors.dim(`(${runtime}, pid ${child.pid ?? "?"})`)}`);
+				},
+				onStop: (_status, forced) => {
+					if (forced) reporter.warn(`The application did not stop within ${killTimeoutMs}ms: killed`);
+				},
+				onExit: (status) => {
+					if (status.error !== void 0) {
+						reporter.error(`Cannot start ${runtime}: ${status.error.message}`);
+						return;
+					}
+					const code = exitCodeOf(status);
+					const message = `The application exited with code ${code}${status.signal === null ? "" : ` (${status.signal})`}`;
+					if (code === 0) reporter.info(`${message}. Waiting for changes...`);
+					else reporter.error(`${message}. Waiting for changes...`);
+				},
+				onError: (error) => reporter.error(`Cannot start the application: ${error instanceof Error ? error.message : String(error)}`)
+			}
+		});
+		const state = {
+			failed: false,
+			first: true,
+			started: 0
+		};
+		const onEvent = (event) => {
+			switch (event.code) {
+				case "START":
+					state.failed = false;
+					state.started = performance.now();
+					if (!state.first) {
+						if (args.clear === true && cli.stdout.isTTY === true) cli.stdout.write(CLEAR_SCREEN);
+						reporter.info(colors.dim("Change detected, rebuilding..."));
+					}
+					break;
+				case "ERROR":
+					state.failed = true;
+					state.first = false;
+					Promise.resolve().then(() => event.result?.close()).catch(() => void 0);
+					if (logLevel === "silent") reporter.logError(formatBuildError(event.error));
+					reporter.error(`Build failed. ${supervisor.running ? "The last good build keeps running. " : ""}Waiting for changes...`);
+					break;
+				case "END": {
+					state.first = false;
+					if (state.failed) break;
+					const compile = tracker.compile();
+					if (compile !== void 0 && !compile.ok) {
+						supervisor.cancelRestart();
+						const errors = compile.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+						(logLevel === "silent" ? printDiagnostics$2(cli, root, compile.diagnostics) : Promise.resolve()).then(() => reporter.error(`Compilation failed with ${plural(errors, "error")}. ${supervisor.running ? "The last good build keeps running. " : ""}Waiting for changes...`));
+						break;
+					}
+					entry = args.entry === void 0 ? tracker.entry() ?? entry : resolve(root, args.entry);
+					reporter.success(`Built in ${formatDuration(performance.now() - (tracker.startedAt() ?? state.started))}`);
+					supervisor.scheduleRestart();
+					break;
+				}
+			}
+		};
+		reporter.info(`${colors.bold("znight dev")} ${colors.dim(`v${cli.version}`)} — vite build --watch, ${runtime} runtime`);
+		let watcher;
+		try {
+			watcher = await watchBuild(vite, {
+				root,
+				configFile: args.config,
+				configLoader: args["config-loader"],
+				mode: args.mode,
+				logLevel,
+				plugins: [tracker.plugin]
+			});
+		} catch (error) {
+			if (error instanceof CliError) throw error;
+			reporter.logError(formatBuildError(error));
+			throw new CliError("Cannot start the Vite build", { cause: error });
+		}
+		watcher.on("event", onEvent);
+		return waitForTermination(cli, watcher, supervisor);
+	}
+});
+/** Prints compiler diagnostics with the project's `formatDiagnostics()` (a built-in formatter otherwise). */
+async function printDiagnostics$2(cli, root, diagnostics) {
+	if (diagnostics.length === 0) return;
+	const options = {
+		color: cli.colors.isColorSupported,
+		cwd: root,
+		summary: false
+	};
+	let text;
+	try {
+		text = (await cli.services.loadCompiler(root)).formatDiagnostics(diagnostics, options);
+	} catch {
+		text = fallbackFormatDiagnostics(diagnostics, options);
+	}
+	cli.reporter.logError(text.trimEnd());
+}
+function waitForTermination(cli, watcher, supervisor) {
+	return new Promise((resolveExit) => {
+		const dispose = onTermination(cli, (signal) => {
+			if (signal !== "SIGHUP") cli.reporter.info(cli.colors.dim("Stopping... (press Ctrl+C again to force)"));
+			(async () => {
+				try {
+					await watcher.close();
+				} finally {
+					await supervisor.stop(signal === "SIGINT" ? "SIGINT" : "SIGTERM");
+					dispose();
+					resolveExit(0);
+				}
+			})();
+		}, () => {
+			supervisor.kill();
+			dispose();
+			resolveExit(130);
+		});
+	});
+}
+// src/commands/generate.ts
+/** `znight generate` */
+const generateCommand = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Generate the dependency injection container (src/.znight/container.generated.ts)",
+		usage: "[options]",
+		examples: [
+			"znight generate",
+			"znight generate --check   # in CI, before tsc",
+			"znight generate --watch"
+		],
+		details: [
+			"The compiler options are read from znight.config.* (or the file named by ZNIGHT_CONFIG), the file",
+			"shared with the Bun preload; without one, from the znight() plugin of vite.config.ts, so that the",
+			"generated file is the same as the one of the Vite build. --config reads the given Vite config.",
+			"\"znight generate <schematic> <name>\" is an alias of \"znight g <schematic> <name>\"."
+		].join("\n")
+	},
+	args: {
+		check: {
+			type: "boolean",
+			description: "Do not write: exit with code 1 when the generated file is missing or out of date"
+		},
+		watch: {
+			type: "boolean",
+			alias: "w",
+			description: "Regenerate on every change"
+		},
+		root: {
+			type: "string",
+			valueHint: "dir",
+			description: "Project root (default: the current directory)"
+		},
+		config: {
+			type: "string",
+			valueHint: "file",
+			description: "Vite config file to read the znight() options from (instead of znight.config.*)"
+		},
+		"config-loader": {
+			type: "enum",
+			options: [
+				"bundle",
+				"runner",
+				"native"
+			],
+			description: "How Vite loads the config file (default: bundle)"
+		}
+	},
+	async run({ args, cli }) {
+		const root = resolveRoot(cli, args.root);
+		const compiler = await cli.services.loadCompiler(root);
+		const configLoader = args["config-loader"];
+		const options = await compilerOptions(cli, compiler, root, args.config, configLoader);
+		if (args.check === true) return check(cli, compiler, options);
+		if (args.watch === true) return watch$1(cli, compiler, options);
+		return hasErrors((await generateOnce(cli, compiler, options)).diagnostics) ? 1 : 0;
+	}
+});
+/**
+* The compiler options, with `root`: those of `znight.config.*` when the project has one (unless a
+* Vite config is given with `--config`), else those of `znight()` in the Vite config (when exposed),
+* else the defaults.
+*/
+async function compilerOptions(cli, compiler, root, configFile, configLoader) {
+	if (configFile === void 0) {
+		const shared = await znightConfigOptions(compiler, root);
+		if (shared !== void 0) return shared;
+	}
+	let options;
+	if (findViteConfig(root, configFile) === void 0) return { root };
+	try {
+		const lookup = await readZnightPluginOptions(await cli.services.loadVite(root), root, configFile, configLoader);
+		if (lookup !== void 0 && !lookup.found) cli.reporter.warn(`${displayPath(lookup.configFile, cli.cwd)} does not register the znight() plugin`);
+		options = lookup?.options;
+	} catch (error) {
+		if (configFile !== void 0) throw new CliError(`Cannot load the Vite config ${configFile}`, {
+			cause: error,
+			hints: [errorMessage(error)]
+		});
+		cli.reporter.warn(`Cannot read the znight() options from the Vite config, using the defaults: ${errorMessage(error)}`);
+	}
+	return {
+		...options,
+		root: resolve(root, options?.root ?? ".")
+	};
+}
+/** Options of `znight.config.*` (`loadZnightConfig()` of the compiler), `undefined` without the file. */
+async function znightConfigOptions(compiler, root) {
+	if (compiler.loadConfig === void 0) return void 0;
+	let config;
+	try {
+		config = await compiler.loadConfig(root);
+	} catch (error) {
+		throw new CliError("Cannot load the Znight config (znight.config.*)", {
+			cause: error,
+			hints: [errorMessage(error)]
+		});
+	}
+	if (config.file === void 0) return void 0;
+	const { logLevel: _preloadLogLevel, ...options } = config.options;
+	return {
+		...options,
+		root: resolve(root, options.root ?? ".")
+	};
+}
+function printDiagnostics$1(cli, compiler, result, root) {
+	if (result.diagnostics.length === 0) return;
+	const text = compiler.formatDiagnostics(result.diagnostics, {
+		color: cli.colors.isColorSupported,
+		cwd: root,
+		summary: false
+	});
+	cli.reporter.logError(text.trimEnd());
+	cli.reporter.logError();
+}
+function statsOf(result, elapsedMs) {
+	const parts = [];
+	if (result.stats?.providers !== void 0) parts.push(plural(result.stats.providers, "provider"));
+	if (result.stats?.files !== void 0) parts.push(plural(result.stats.files, "file"));
+	parts.push(formatDuration(result.stats?.durationMs ?? elapsedMs));
+	return parts.join(", ");
+}
+function failure(cli, result) {
+	const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+	cli.reporter.error(`Generation failed with ${plural(errors, "error")}`);
+}
+/** Prints the outcome of a generation. */
+function report(cli, compiler, result, root, elapsed) {
+	printDiagnostics$1(cli, compiler, result, root);
+	if (hasErrors(result.diagnostics)) {
+		failure(cli, result);
+		return;
+	}
+	const file = displayPath(result.outFile, cli.cwd);
+	cli.reporter.success(`${result.written ? "Generated" : "Up to date:"} ${cli.colors.bold(file)} ${cli.colors.dim(`(${statsOf(result, elapsed)})`)}`);
+}
+async function generateOnce(cli, compiler, options) {
+	const started = performance.now();
+	const result = await compiler.generate(options);
+	report(cli, compiler, result, options.root ?? cli.cwd, performance.now() - started);
+	return result;
+}
+/**
+* The generated files `--check` reports, the module first: those the compiler says are stale (the
+* module when it does not say which), and the module when it is missing.
+*/
+function staleFilesOf(result) {
+	const stale = /* @__PURE__ */ new Set();
+	if (!existsSync(result.outFile)) stale.add(result.outFile);
+	if (result.stale) {
+		const files = result.staleFiles ?? [];
+		for (const file of files.length > 0 ? files : [result.outFile]) stale.add(file);
+	}
+	return [...stale].sort((a, b) => Number(b === result.outFile) - Number(a === result.outFile));
+}
+async function check(cli, compiler, options) {
+	const root = options.root ?? cli.cwd;
+	const started = performance.now();
+	const result = await compiler.check(options);
+	printDiagnostics$1(cli, compiler, result, root);
+	if (hasErrors(result.diagnostics)) {
+		failure(cli, result);
+		return 1;
+	}
+	const file = displayPath(result.outFile, cli.cwd);
+	const stale = staleFilesOf(result);
+	for (const path of stale) {
+		const shown = displayPath(path, cli.cwd);
+		const hint = path === result.outFile ? "run \"znight generate\" (it is git-ignored: generate it before tsc and tests)" : "run \"znight generate\" after the build: a build cleaning dist/ (tsdown, tsc --build --clean...) deletes it";
+		if (existsSync(path)) cli.reporter.error(`${shown} is out of date`, ["run \"znight generate\""]);
+		else cli.reporter.error(`${shown} is missing`, [hint]);
+	}
+	if (stale.length > 0) return 1;
+	cli.reporter.success(`${cli.colors.bold(file)} is up to date ${cli.colors.dim(`(${statsOf(result, performance.now() - started)})`)}`);
+	return 0;
+}
+async function watch$1(cli, compiler, options) {
+	const root = options.root ?? cli.cwd;
+	const realRoot = realPath(root);
+	const incremental = compiler.createIncremental(options);
+	let state = {
+		known: /* @__PURE__ */ new Set(),
+		roots: []
+	};
+	let pending = /* @__PURE__ */ new Set();
+	let running = false;
+	let timer;
+	const watchers = new TargetWatchers(cli.services.watch, (file) => {
+		const path = realPath(file);
+		if (!incremental.isRelevantChange(changeKind(path, state.known), path, state.known, state.roots)) return;
+		pending.add(path);
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = void 0;
+			run(false);
+		}, 50);
+	});
+	const run = async (initial) => {
+		if (running) return;
+		running = true;
+		let first = initial;
+		try {
+			do {
+				const files = pending;
+				pending = /* @__PURE__ */ new Set();
+				const started = performance.now();
+				let known = state.known;
+				try {
+					const result = await incremental.generate(first ? void 0 : classifyChanges(files, state.known));
+					if (result.watchFiles !== void 0) known = new Set(result.watchFiles.map((file) => toPosixPath(resolve(file))));
+					report(cli, compiler, result, root, performance.now() - started);
+				} catch (error) {
+					cli.reporter.error(`Generation failed: ${errorMessage(error)}`);
+				}
+				state = {
+					known,
+					roots: incremental.includeRoots().map(realPath)
+				};
+				watchers.update(watchTargets(realRoot, state.roots, state.known), files);
+				first = false;
+			} while (pending.size > 0);
+		} finally {
+			running = false;
+		}
+	};
+	await run(true);
+	cli.reporter.info(cli.colors.dim("Watching for changes... (Ctrl+C to stop)"));
+	return new Promise((resolveExit) => {
+		const dispose = onTermination(cli, () => {
+			if (timer !== void 0) clearTimeout(timer);
+			watchers.close();
+			dispose();
+			resolveExit(0);
+		}, () => void 0);
+	});
+}
+// src/scaffold/options.ts
+/** Every package manager, in display order. */
+const PACKAGE_MANAGERS = [
+	"bun",
+	"npm",
+	"pnpm",
+	"yarn"
+];
+/** Every HTTP adapter, in display order. */
+const HTTP_ADAPTERS = [
+	"node",
+	"fastify",
+	"express",
+	"hono"
+];
+/** Every feature, in display (and canonical) order. */
+const FEATURES = [
+	"config",
+	"observability",
+	"messaging",
+	"schedule",
+	"openapi"
+];
+/** Features selected when none are given. */
+const DEFAULT_FEATURES = ["config", "observability"];
+/** Labels shown by the prompts and the help. */
+const ADAPTER_LABELS = {
+	node: "node:http (built-in, zero dependency)",
+	fastify: "Fastify",
+	express: "Express",
+	hono: "Hono"
+};
+/** Labels shown by the prompts. */
+const FEATURE_LABELS = {
+	config: "Config: type-safe configuration classes (@znight/config)",
+	observability: "Observability: structured logs, metrics, tracing (@znight/observability)",
+	messaging: "Messaging: message consumers and publishing (@znight/messaging)",
+	schedule: "Schedule: cron, interval and timeout jobs (@znight/schedule)",
+	openapi: "OpenAPI: openapi.json and an API reference at /docs (@znight/openapi)"
+};
+/**
+* Parses `--features` (`config,observability`, `none`, `all`). Returns the features in canonical
+* order, or the unknown names.
+*/
+function parseFeatures(value) {
+	const names = value.split(",").map((name) => name.trim().toLowerCase()).filter((name) => name !== "");
+	if (names.length === 1 && names[0] === "none") return { features: [] };
+	if (names.length === 1 && names[0] === "all") return { features: [...FEATURES] };
+	const unknown = names.filter((name) => !FEATURES.includes(name));
+	if (unknown.length > 0) return { unknown };
+	return { features: FEATURES.filter((feature) => names.includes(feature)) };
+}
+/**
+* Default package manager: the one that launched the CLI (`npm_config_user_agent`: `pnpm dlx`,
+* `yarn dlx`, `bunx`, `npx`), else Bun when running on Bun, else npm.
+*/
+function detectPackageManager(env, runningOnBun) {
+	const name = (env["npm_config_user_agent"] ?? "").split("/")[0];
+	if (name === "bun" || name === "npm" || name === "pnpm" || name === "yarn") return name;
+	return runningOnBun ? "bun" : "npm";
+}
+/** `bun install`, `npm install`... */
+function installCommand(pm) {
+	return [pm, "install"];
+}
+/** `bun run dev`, `npm run dev`, `pnpm dev`, `yarn dev`. */
+function runScript(pm, script) {
+	return pm === "pnpm" || pm === "yarn" ? `${pm} ${script}` : `${pm} run ${script}`;
+}
+/** Runs a binary of the project: `npx znight`, `bunx znight`, `pnpm znight`, `yarn znight`. */
+function execBinary(pm, binary) {
+	switch (pm) {
+		case "npm": return `npx ${binary}`;
+		case "bun": return `bunx ${binary}`;
+		default: return `${pm} ${binary}`;
+	}
+}
+// src/scaffold/create.ts
+/** Entries tolerated in the target directory (a fresh clone, editor settings). */
+const IGNORABLE_ENTRIES = /* @__PURE__ */ new Set([
+	".git",
+	".DS_Store",
+	"Thumbs.db",
+	".idea",
+	".vscode"
+]);
+/** Inspects the target directory. */
+function targetState(directory) {
+	let stats;
+	try {
+		stats = statSync(directory);
+	} catch {
+		return "missing";
+	}
+	if (!stats.isDirectory()) return "file";
+	return readdirSync(directory).every((entry) => IGNORABLE_ENTRIES.has(entry)) ? "empty" : "not-empty";
+}
+/** Writes `files` under `directory` (created when missing). Returns the written paths. */
+function writeProject(directory, files) {
+	mkdirSync(directory, { recursive: true });
+	for (const file of files) {
+		const target = join(directory, file.path);
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, file.content);
+	}
+	return files.map((file) => file.path);
+}
+/** `git init` in `directory`, unless it already is inside a git work tree (monorepos). */
+async function initGit(processes, directory, env) {
+	const inside = await processes.run("git", ["rev-parse", "--is-inside-work-tree"], {
+		cwd: directory,
+		env
+	});
+	if (inside.error !== void 0) return "unavailable";
+	if (inside.code === 0 && inside.stdout.trim() === "true") return "inside-repository";
+	return (await processes.run("git", ["init", "--quiet"], {
+		cwd: directory,
+		env
+	})).code === 0 ? "initialized" : "failed";
+}
+/** `<pm> install` in `directory`, output captured. */
+function installDependencies(processes, directory, packageManager, env) {
+	const [command, ...args] = installCommand(packageManager);
+	return processes.run(command, args, {
+		cwd: directory,
+		env
+	});
+}
+// src/scaffold/versions.ts
+/**
+* Version ranges of the third-party dependencies of new projects. `@znight/*` packages use
+* `^<version of @znight/cli>` (they are released in lockstep).
+*/
+const DEPENDENCY_VERSIONS = {
+	"@hono/node-server": "^2.1.5",
+	"@types/bun": "^1.3.0",
+	"@types/express": "^5.0.6",
+	"@types/node": "^24.0.0",
+	express: "^5.3.0",
+	fastify: "^5.12.7",
+	hono: "^4.13.14",
+	"light-my-request": "^6.8.0",
+	typescript: "^7.0.0",
+	vite: "^8.0.0",
+	vitest: "^4.1.0",
+	zod: "^4.6.0"
+};
+/** Range of a third-party dependency. */
+function versionOf(name) {
+	const version = DEPENDENCY_VERSIONS[name];
+	if (version === void 0) throw new Error(`[znight] no version declared for ${name}`);
+	return version;
+}
+// src/scaffold/templates.ts
+function flagsOf(options) {
+	const has = (feature) => options.features.includes(feature);
+	return {
+		config: has("config"),
+		observability: has("observability"),
+		messaging: has("messaging"),
+		schedule: has("schedule"),
+		openapi: has("openapi"),
+		adapter: options.adapter,
+		pm: options.packageManager,
+		bun: options.packageManager === "bun"
+	};
+}
+/** Every file of a new project, sorted by path. */
+function renderProject(options) {
+	const flags = flagsOf(options);
+	const files = [
+		{
+			path: "package.json",
+			content: packageJson(options, flags)
+		},
+		{
+			path: "tsconfig.json",
+			content: tsconfigJson(flags)
+		},
+		{
+			path: "vite.config.ts",
+			content: viteConfig()
+		},
+		{
+			path: "znight.config.ts",
+			content: znightConfig(flags)
+		},
+		{
+			path: ".gitignore",
+			content: gitignore()
+		},
+		{
+			path: "README.md",
+			content: readme(options, flags)
+		},
+		{
+			path: "src/main.ts",
+			content: mainTs(flags)
+		},
+		{
+			path: "src/app/greeting.schemas.ts",
+			content: greetingSchemas(flags)
+		},
+		{
+			path: "src/app/greeting.service.ts",
+			content: greetingService(flags)
+		},
+		{
+			path: "src/app/greeting.controller.ts",
+			content: greetingController(flags)
+		},
+		{
+			path: "src/app/health.controller.ts",
+			content: healthController()
+		},
+		{
+			path: "test/greeting.service.test.ts",
+			content: greetingServiceTest(flags)
+		},
+		{
+			path: "test/greeting.controller.test.ts",
+			content: greetingControllerTest(flags)
+		}
+	];
+	if (flags.config) files.push({
+		path: "src/app/app.config.ts",
+		content: appConfig()
+	});
+	if (flags.messaging) files.push({
+		path: "src/app/greeting.consumer.ts",
+		content: greetingConsumer(flags)
+	});
+	if (flags.schedule) {
+		files.push({
+			path: "src/app/heartbeat.jobs.ts",
+			content: heartbeatJobs()
+		});
+		files.push({
+			path: "test/heartbeat.jobs.test.ts",
+			content: heartbeatJobsTest(flags)
+		});
+	}
+	if (flags.openapi) files.push({
+		path: "src/api.ts",
+		content: apiDocument(options)
+	});
+	if (flags.bun) files.push({
+		path: "bunfig.toml",
+		content: bunfig(flags)
+	});
+	if (flags.pm === "yarn") files.push({
+		path: ".yarnrc.yml",
+		content: "nodeLinker: node-modules\n"
+	});
+	return files.sort((a, b) => a.path < b.path ? -1 : 1);
+}
+function sortRecord(record) {
+	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a < b ? -1 : 1));
+}
+function packageJson(options, flags) {
+	const znight = `^${options.znightVersion}`;
+	const dependencies = {
+		"@znight/core": znight,
+		"@znight/http": znight,
+		zod: versionOf("zod")
+	};
+	if (flags.config) dependencies["@znight/config"] = znight;
+	if (flags.observability) dependencies["@znight/observability"] = znight;
+	if (flags.messaging) dependencies["@znight/messaging"] = znight;
+	if (flags.schedule) dependencies["@znight/schedule"] = znight;
+	if (flags.openapi) dependencies["@znight/openapi"] = znight;
+	if (flags.adapter === "fastify") dependencies["fastify"] = versionOf("fastify");
+	if (flags.adapter === "express") dependencies["express"] = versionOf("express");
+	if (flags.adapter === "hono") {
+		dependencies["hono"] = versionOf("hono");
+		dependencies["@hono/node-server"] = versionOf("@hono/node-server");
+	}
+	const devDependencies = {
+		"@types/node": versionOf("@types/node"),
+		"@znight/cli": znight,
+		"@znight/compiler": znight,
+		"@znight/testing": znight,
+		typescript: versionOf("typescript"),
+		vite: versionOf("vite")
+	};
+	if (flags.bun) devDependencies["@types/bun"] = versionOf("@types/bun");
+	else devDependencies["vitest"] = versionOf("vitest");
+	if (flags.adapter === "express") devDependencies["@types/express"] = versionOf("@types/express");
+	if (flags.adapter === "node" || flags.adapter === "express") devDependencies["light-my-request"] = versionOf("light-my-request");
+	const manifest = {
+		name: options.name,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		engines: { node: ">=24" },
+		scripts: {
+			dev: flags.bun ? "znight dev --runtime bun" : "znight dev",
+			build: "znight build",
+			start: flags.bun ? "znight start --runtime bun" : "znight start",
+			generate: "znight generate",
+			typecheck: "znight generate && tsc --noEmit",
+			test: flags.bun ? "bun test" : "vitest run",
+			...flags.openapi ? {
+				openapi: "znight openapi",
+				"openapi:check": "znight openapi --check"
+			} : {}
+		},
+		dependencies: sortRecord(dependencies),
+		devDependencies: sortRecord(devDependencies)
+	};
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+function tsconfigJson(flags) {
+	return `{
+  "compilerOptions": {
+    "target": "ES2024",
+    "lib": ["ES2024", "ESNext.Disposable"],
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "types": ["${flags.bun ? "bun" : "node"}"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    // Znight decorators are TypeScript decorators: no emitDecoratorMetadata nor reflect-metadata
+    "experimentalDecorators": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    // vite.config.ts imports ./znight.config.ts (also loaded as is by Node.js and Bun)
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src", "test", "vite.config.ts", "znight.config.ts"]
+}
+`;
+}
+function viteConfig() {
+	return `import { znight } from '@znight/compiler'
+import { defineConfig } from 'vite'
+
+import options from './znight.config.ts'
+
+// znight() generates the dependency injection container at build time and configures a server
+// build: src/main.ts -> dist/main.js (Node.js 24 target, source maps).
+export default defineConfig({
+  plugins: [znight(options)],
+})
+`;
+}
+function znightConfig(flags) {
+	return `import type { ZnightOptions } from '@znight/compiler'
+
+${flags.bun ? `// Options of the Znight compiler. The znight() Vite plugin (vite.config.ts), the Bun preload of the
+// tests (bunfig.toml) and \`znight generate\` read them, so they all generate the same container.` : `// Options of the Znight compiler. The znight() Vite plugin (vite.config.ts, also used by Vitest)
+// and \`znight generate\` read them, so they all generate the same container.`}
+// https://github.com/znight-org/znight/tree/main/packages/compiler#options
+export default {
+  // reportUnused: true, // warn about providers nothing uses (ZNIGHT019)
+} satisfies ZnightOptions
+`;
+}
+function bunfig(flags) {
+	return `${flags.config ? `# @znight/config loads the .env files (dotenv()), the same way on Node.js and Bun: Bun's own
+# loading would put them in process.env first, with its own precedence
+env = false
+
+` : ""}[test]
+# Regenerates the DI container (src/.znight/container.generated.ts) before the tests run
+preload = ["@znight/compiler/bun"]
+`;
+}
+function gitignore() {
+	return `node_modules
+dist
+coverage
+*.log
+
+# generated by the Znight compiler (znight generate, vite build, bun test)
+.znight
+
+# local environment
+.env.local
+.env.*.local
+`;
+}
+function adapterImport(adapter) {
+	switch (adapter) {
+		case "fastify": return "import { fastifyAdapter } from '@znight/http/fastify'";
+		case "express": return "import { expressAdapter } from '@znight/http/express'";
+		case "hono": return "import { honoAdapter } from '@znight/http/hono'";
+		default: return;
+	}
+}
+function adapterCall(adapter) {
+	return adapter === "node" ? void 0 : `${adapter}Adapter()`;
+}
+function mainTs(flags) {
+	const imports = [
+		flags.config ? "import { ConfigPlugin } from '@znight/config'" : void 0,
+		"import { Application } from '@znight/core'",
+		"import { HttpPlugin } from '@znight/http'",
+		adapterImport(flags.adapter),
+		flags.messaging ? "import { MessagingPlugin } from '@znight/messaging'" : void 0,
+		flags.messaging ? "import { memory } from '@znight/messaging/memory'" : void 0,
+		flags.observability ? "import { ObservabilityPlugin } from '@znight/observability'" : void 0,
+		flags.openapi ? "import { OpenApiPlugin } from '@znight/openapi'" : void 0,
+		flags.schedule ? "import { SchedulePlugin } from '@znight/schedule'" : void 0
+	].filter((line) => line !== void 0);
+	const localImports = ["import { __ZNIGHT_METADATA__ } from './.znight/container.generated.js'", flags.config ? "import { AppConfig } from './app/app.config.js'" : void 0].filter((line) => line !== void 0);
+	const plugins = [];
+	if (flags.observability) plugins.push("    // first, so that its hooks wrap everything: request logs, metrics (with prom-client), traces", "    ObservabilityPlugin.configure(),");
+	if (flags.config) plugins.push("    // loads .env files and the environment, validates every @Config class before anything starts", "    ConfigPlugin.configure(),");
+	if (flags.messaging) plugins.push("    // in-memory broker for development: use rabbitmq(), sqs() or kafka() in production", "    MessagingPlugin.configure({ driver: memory() }),");
+	if (flags.schedule) plugins.push("    // before HttpPlugin: plugins stop in reverse order, so HTTP stops first, then running jobs drain", "    SchedulePlugin.configure(),");
+	const adapter = adapterCall(flags.adapter);
+	if (flags.config) plugins.push("    HttpPlugin.configure(container => ({", ...adapter === void 0 ? [] : [`      adapter: ${adapter},`], "      port: container.get(AppConfig).port,", "    })),");
+	else {
+		const port = "port: Number(process.env.PORT ?? 3000)";
+		plugins.push(adapter === void 0 ? `    HttpPlugin.configure({ ${port} }),` : `    HttpPlugin.configure({ adapter: ${adapter}, ${port} }),`);
+	}
+	if (flags.openapi) plugins.push("    // GET /openapi.json and the API reference at /docs (document options: src/api.ts)", "    OpenApiPlugin.configure(),");
+	return `${imports.join("\n")}
+
+${localImports.join("\n")}
+
+const app = await Application.create({
+  metadata: __ZNIGHT_METADATA__,
+  plugins: [
+${plugins.join("\n")}
+  ],
+})
+
+// SIGINT / SIGTERM stop the application gracefully (in-flight requests are drained)
+await app.start()
+`;
+}
+function appConfig() {
+	return `import { Config, Env } from '@znight/config'
+
+/**
+ * Settings of the application, validated at boot by ConfigPlugin. Each property is read from the
+ * environment (or a .env file): APP_<PROPERTY> by default, or the name given to @Env. Properties
+ * with an initializer are optional; their type selects the coercion ("3000" -> 3000).
+ */
+@Config('app')
+export class AppConfig {
+  /** HTTP port (PORT). */
+  @Env('PORT')
+  port = 3000
+
+  /** Greeting used by GreetingService (APP_GREETING). */
+  greeting = 'Hello'
+}
+`;
+}
+function greetingSchemas(flags) {
+	return `import { z } from 'zod'
+
+/** ${flags.messaging ? "Body of POST /greetings and POST /greetings/async, payload of the \"greetings\" queue." : "Body of POST /greetings."} */
+export const CreateGreeting = z.object({
+  name: z.string().trim().min(1).max(100),
+  excited: z.boolean().default(false),
+})
+export type CreateGreeting = z.output<typeof CreateGreeting>
+`;
+}
+function greetingService(flags) {
+	const imports = ["import { Injectable } from '@znight/core'"];
+	if (flags.observability) imports.push("import { Logger } from '@znight/observability'");
+	const local = flags.config ? "\nimport { AppConfig } from './app.config.js'\n" : "";
+	const params = [];
+	if (flags.config) params.push("    private readonly config: AppConfig,");
+	if (flags.observability) params.push("    private readonly logger: Logger,");
+	let members = "";
+	if (params.length > 0) members = `  // dependencies are resolved at build time from the parameter types
+  constructor(
+${params.join("\n")}
+  ) {}
+
+`;
+	const greeting = flags.config ? "this.config.greeting" : "'Hello'";
+	const log = flags.observability ? "    this.logger.debug('Greeting', { name, excited })\n" : "";
+	return `${imports.join("\n")}
+${local}
+@Injectable()
+export class GreetingService {
+${members}  greet(name: string, excited = false): string {
+${log}    return \`\${${greeting}}, \${name}\${excited ? '!' : '.'}\`
+  }
+}
+`;
+}
+function greetingController(flags) {
+	const imports = [`import { ${flags.messaging ? "Body, Controller, Get, HttpCode, Param, Post, Query" : "Body, Controller, Get, Param, Post, Query"} } from '@znight/http'`];
+	if (flags.messaging) imports.push("import { MessageBroker } from '@znight/messaging'");
+	const ctor = flags.messaging ? `  constructor(
+    private readonly greetings: GreetingService,
+    private readonly broker: MessageBroker,
+  ) {}` : "  constructor(private readonly greetings: GreetingService) {}";
+	const enqueue = flags.messaging ? `
+
+  /** POST /greetings/async: published to the "greetings" queue, handled by GreetingConsumer. */
+  @Post('/async')
+  @HttpCode(202)
+  async enqueue(@Body(CreateGreeting) input: CreateGreeting): Promise<{ id: string }> {
+    const { id } = await this.broker.publish('greetings', input, { type: 'greeting.requested' })
+    return { id }
+  }` : "";
+	return `${imports.join("\n")}
+
+import { CreateGreeting } from './greeting.schemas.js'
+import { GreetingService } from './greeting.service.js'
+
+@Controller('/greetings')
+export class GreetingController {
+${ctor}
+
+  /** GET /greetings/Ada?excited=true: route and query parameters are coerced to their types. */
+  @Get('/:name')
+  greet(@Param('name') name: string, @Query('excited') excited?: boolean): { message: string } {
+    return { message: this.greetings.greet(name, excited) }
+  }
+
+  /** POST /greetings {"name": "Ada"}: the body is validated by the schema (400 otherwise). */
+  @Post()
+  create(@Body(CreateGreeting) input: CreateGreeting): { message: string } {
+    return { message: this.greetings.greet(input.name, input.excited) }
+  }${enqueue}
+}
+`;
+}
+function healthController() {
+	return `import { Controller, Get } from '@znight/http'
+
+@Controller('/health')
+export class HealthController {
+  /** GET /health */
+  @Get()
+  check(): { status: 'ok'; uptime: number } {
+    return { status: 'ok', uptime: Math.round(process.uptime()) }
+  }
+}
+`;
+}
+function greetingConsumer(flags) {
+	const imports = ["import { Consumer, Message, OnMessage, Retry } from '@znight/messaging'"];
+	if (flags.observability) imports.push("import { Logger } from '@znight/observability'");
+	const ctor = flags.observability ? `  constructor(
+    private readonly greetings: GreetingService,
+    private readonly logger: Logger,
+  ) {}` : "  constructor(private readonly greetings: GreetingService) {}";
+	const output = flags.observability ? "    this.logger.info(this.greetings.greet(request.name, request.excited))" : "    console.log(this.greetings.greet(request.name, request.excited))";
+	return `${imports.join("\n")}
+
+import { CreateGreeting } from './greeting.schemas.js'
+import { GreetingService } from './greeting.service.js'
+
+/**
+ * Consumes the "greetings" queue. Delivery is at-least-once: handlers must be idempotent. A failing
+ * handler is retried, then the message goes to the dead-letter queue (greetings.dlq).
+ */
+@Consumer('greetings')
+export class GreetingConsumer {
+${ctor}
+
+  @OnMessage('greeting.requested')
+  @Retry({ attempts: 3, backoff: 'exponential', delay: 500 })
+  handle(@Message(CreateGreeting) request: CreateGreeting): void {
+${output}
+  }
+}
+`;
+}
+function heartbeatJobs() {
+	return `import { Cron, type JobContext } from '@znight/schedule'
+
+/**
+ * Scheduled jobs. A class with @Cron, @Interval or @Timeout methods becomes a singleton provider
+ * (no decorator needed): its dependencies are constructor parameters. Running several instances?
+ * Give SchedulePlugin a lock store so that each occurrence runs on one of them.
+ */
+export class HeartbeatJobs {
+  /** Number of runs. */
+  beats = 0
+  /** The occurrence of the last run. */
+  last: Date | undefined
+
+  /** Every minute (cron expressions run in UTC unless they set a timeZone). */
+  @Cron('* * * * *', { name: 'heartbeat' })
+  beat(ctx: JobContext): void {
+    this.beats++
+    this.last = ctx.scheduledAt
+  }
+}
+`;
+}
+function apiDocument(options) {
+	return `import { OpenApiDocument } from '@znight/openapi'
+
+/**
+ * ${options.name}
+ *
+ * The HTTP API of ${options.name}. Title and description of the OpenAPI document come from this
+ * comment, the version from package.json.
+ */
+@OpenApiDocument({
+  tags: [{ name: 'Greeting', description: 'Greetings' }],
+})
+export class Api {}
+`;
+}
+function heartbeatJobsTest(flags) {
+	return `${testImports(flags, "describe, expect, test")}
+import { SchedulePlugin, SchedulerRegistry } from '@znight/schedule'
+import { createTestClock } from '@znight/schedule/testing'
+import { TestApp } from '@znight/testing'
+
+import { __ZNIGHT_METADATA__ as metadata } from '../src/.znight/container.generated.js'
+import { HeartbeatJobs } from '../src/app/heartbeat.jobs.js'
+
+// virtual time: the clock only moves when the test advances it, and waits for the runs it starts
+describe('HeartbeatJobs', () => {
+  test('beats every minute', async () => {
+    const clock = createTestClock('2026-01-01T00:00:30Z')
+    const app = await TestApp.create({
+      metadata,
+      plugins: [SchedulePlugin.configure({ clock })],
+      only: [HeartbeatJobs],
+    })
+    try {
+      await clock.advance('3m')
+
+      expect(app.get(HeartbeatJobs).beats).toBe(3)
+      expect(app.get(HeartbeatJobs).last?.toISOString()).toBe('2026-01-01T00:03:00.000Z')
+      const heartbeat = app.get(SchedulerRegistry).get('heartbeat')
+      expect(heartbeat?.nextRun?.toISOString()).toBe('2026-01-01T00:04:00.000Z')
+    } finally {
+      await app.close()
+    }
+  })
+})
+`;
+}
+function testImports(flags, names) {
+	return flags.bun ? `import { ${names} } from 'bun:test'` : `import { ${names} } from 'vitest'`;
+}
+function greetingServiceTest(flags) {
+	const imports = [testImports(flags, "describe, expect, test")];
+	if (flags.observability) imports.push("import { Logger } from '@znight/observability'");
+	imports.push("import { TestBed } from '@znight/testing'");
+	const configOption = flags.config ? "\n      config: { app: { greeting: 'Hi' } }, // @Config('app') values" : "";
+	const greeting = flags.config ? "Hi" : "Hello";
+	const loggerTest = flags.observability ? `
+
+  test('logs every greeting', async () => {
+    const { instance, mocks } = await TestBed.create(GreetingService, { metadata })
+
+    instance.greet('Grace')
+
+    // Logger is provided by ObservabilityPlugin at runtime: TestBed injects an auto-mock
+    expect(mocks.get(Logger).debug).toHaveBeenCalledWith('Greeting', { name: 'Grace', excited: false })
+  })` : "";
+	return `${imports.join("\n")}
+
+import { __ZNIGHT_METADATA__ as metadata } from '../src/.znight/container.generated.js'
+import { GreetingService } from '../src/app/greeting.service.js'
+
+// TestBed builds GreetingService with its generated factory and auto-mocks its dependencies
+describe('GreetingService', () => {
+  test('greets', async () => {
+    const { instance } = await TestBed.create(GreetingService, {
+      metadata,${configOption}
+    })
+
+    expect(instance.greet('Ada')).toBe('${greeting}, Ada.')
+    expect(instance.greet('Ada', true)).toBe('${greeting}, Ada!')
+  })${loggerTest}
+})
+`;
+}
+function greetingControllerTest(flags) {
+	const imports = [testImports(flags, "afterEach, beforeEach, describe, expect, test"), "import { HttpPlugin } from '@znight/http'"];
+	if (flags.messaging) {
+		imports.push("import { MessagingPlugin } from '@znight/messaging'");
+		imports.push("import { memory } from '@znight/messaging/memory'");
+	}
+	if (flags.observability) imports.push("import { ObservabilityPlugin } from '@znight/observability'");
+	imports.push("import { TestApp } from '@znight/testing'");
+	const plugins = [];
+	if (flags.observability) plugins.push("ObservabilityPlugin.configure({ logging: { level: 'silent' }, metrics: { server: false } })");
+	if (flags.messaging) plugins.push("MessagingPlugin.configure({ driver: memory() })");
+	plugins.push("HttpPlugin.configure({ port: 0 })");
+	const pluginList = plugins.length === 1 ? `[${plugins[0]}]` : `[\n${plugins.map((plugin) => `        ${plugin},`).join("\n")}\n      ]`;
+	const greeting = "Hello";
+	return `${imports.join("\n")}
+
+import { __ZNIGHT_METADATA__ as metadata } from '../src/.znight/container.generated.js'
+
+// TestApp starts the application (without signal handlers) and sends requests in memory
+describe('GreetingController', () => {
+  let app: TestApp
+
+  beforeEach(async () => {
+    app = await TestApp.create({
+      metadata,
+      plugins: ${pluginList},
+    })
+  })
+
+  afterEach(async () => {
+    await app.close()
+  })
+
+  test('GET /greetings/:name', async () => {
+    const response = await app.inject({ method: 'GET', url: '/greetings/Ada?excited=true' })
+
+    expect(response.status).toBe(200)
+    expect(response.json()).toEqual({ message: '${greeting}, Ada!' })
+  })
+
+  test('POST /greetings validates the body', async () => {
+    const created = await app.inject({ method: 'POST', url: '/greetings', body: { name: 'Grace' } })
+    expect(created.status).toBe(201)
+    expect(created.json()).toEqual({ message: '${greeting}, Grace.' })
+
+    const invalid = await app.inject({ method: 'POST', url: '/greetings', body: { name: '' } })
+    expect(invalid.status).toBe(400)
+  })
+})
+`;
+}
+function readme(options, flags) {
+	const run = (script) => runScript(flags.pm, script);
+	const znight = execBinary(flags.pm, "znight");
+	const features = [
+		`- **HTTP** with \`@znight/http\` (${flags.adapter === "node" ? "built-in node:http server" : `${flags.adapter} adapter`})`,
+		flags.config ? "- **Configuration** with `@znight/config` (`src/app/app.config.ts`, `.env` files)" : void 0,
+		flags.observability ? "- **Observability** with `@znight/observability` (structured logs, metrics, traces)" : void 0,
+		flags.messaging ? "- **Messaging** with `@znight/messaging` (in-memory broker in `src/main.ts`)" : void 0,
+		flags.schedule ? "- **Scheduled jobs** with `@znight/schedule` (`src/app/heartbeat.jobs.ts`)" : void 0,
+		flags.openapi ? "- **OpenAPI** with `@znight/openapi` (`/openapi.json`, API reference at `/docs`, options in `src/api.ts`)" : void 0
+	].filter((line) => line !== void 0);
+	const tree = [
+		"src/",
+		"├─ main.ts                    # Application.create() + plugins + start()",
+		flags.openapi ? "├─ api.ts                     # @OpenApiDocument: title, tags, security of openapi.json" : void 0,
+		"├─ .znight/                   # generated DI container (git-ignored)",
+		"└─ app/",
+		flags.config ? "   ├─ app.config.ts            # @Config: settings read from the environment" : void 0,
+		flags.messaging ? "   ├─ greeting.consumer.ts     # @Consumer: handles the \"greetings\" queue" : void 0,
+		"   ├─ greeting.controller.ts   # @Controller: /greetings routes",
+		"   ├─ greeting.schemas.ts      # Zod schemas",
+		"   ├─ greeting.service.ts      # @Injectable",
+		flags.schedule ? "   ├─ health.controller.ts     # GET /health" : "   └─ health.controller.ts     # GET /health",
+		flags.schedule ? "   └─ heartbeat.jobs.ts        # @Cron: a job every minute" : void 0,
+		"test/                          # TestBed (unit) and TestApp (HTTP) tests",
+		"vite.config.ts                 # znight() plugin: generates the container, server build",
+		"znight.config.ts               # compiler options"
+	].filter((line) => line !== void 0);
+	const configNote = flags.config ? `
+## Configuration
+
+\`AppConfig\` (\`src/app/app.config.ts\`) reads \`PORT\` and \`APP_GREETING\` from the environment or from
+\`.env\` / \`.env.local\` files. Missing or invalid values stop the application at boot with every
+problem listed.${flags.bun ? `
+
+\`bunfig.toml\` turns Bun's own \`.env\` loading off (\`env = false\`): the files are read by
+\`@znight/config\`, the same way on Node.js and Bun.` : ""}
+` : "";
+	const testNote = flags.bun ? "`bun test` regenerates the container first (`bunfig.toml` preloads `@znight/compiler/bun`)." : "Vitest uses `vite.config.ts`, so the `znight()` plugin regenerates the container before the tests.";
+	const compilerNote = flags.bun ? "the `znight()` Vite plugin, the Bun preload of the tests and `znight generate`" : "the `znight()` Vite plugin (builds and Vitest) and `znight generate`";
+	return `# ${options.name}
+
+A [Znight](https://github.com/znight-org/znight) application: dependency injection resolved at **build
+time** — no \`reflect-metadata\`, errors reported by the compiler with their location.
+
+${features.join("\n")}
+
+## Scripts
+
+| Command | Description |
+| --- | --- |
+| \`${run("dev")}\` | Build in watch mode and restart the application on every change |
+| \`${run("build")}\` | Production build (\`dist/main.js\`) |
+| \`${run("start")}\` | Run the production build |
+| \`${run("test")}\` | Run the tests |
+| \`${run("typecheck")}\` | Generate the container, then type-check with \`tsc\` |
+| \`${run("generate")}\` | Generate \`src/.znight/container.generated.ts\` (\`znight generate --check\` in CI) |
+${flags.openapi ? `| \`${run("openapi")}\` | Write \`openapi.json\` (commit it; \`${run("openapi:check")}\` in CI) |
+` : ""}
+\`\`\`sh
+${run("dev")}
+curl localhost:3000/health
+curl localhost:3000/greetings/Ada?excited=true
+curl -X POST localhost:3000/greetings -H 'content-type: application/json' -d '{"name":"Grace"}'${flags.openapi ? "\ncurl localhost:3000/openapi.json        # the API reference is at http://localhost:3000/docs" : ""}
+\`\`\`
+
+## Project structure
+
+\`\`\`txt
+${tree.join("\n")}
+\`\`\`
+
+Providers are discovered by the compiler from their decorators: there are no modules to declare.
+Its options live in \`znight.config.ts\`, read by ${compilerNote}.
+Add code with the generators:
+
+\`\`\`sh
+${znight} g service users/user        # src/users/user.service.ts
+${znight} g controller users/user     # src/users/user.controller.ts${flags.schedule ? `\n${znight} g job reports/digest        # src/reports/digest.jobs.ts` : ""}
+\`\`\`
+${configNote}
+## Tests
+
+${testNote}
+
+## Learn more
+
+- [Znight documentation](https://github.com/znight-org/znight#readme)
+`;
+}
+// src/commands/new.ts
+/** `znight new` */
+const newCommand = defineCommand({
+	meta: {
+		name: "new",
+		description: "Create a new Znight project",
+		usage: "[name] [options]",
+		aliases: ["create", "init"],
+		examples: [
+			"znight new my-service",
+			"znight new my-service --yes --pm pnpm --adapter fastify --features config,observability,messaging",
+			"znight new my-worker --yes --features config,schedule",
+			"znight new . --yes --no-install"
+		]
+	},
+	args: {
+		name: {
+			type: "positional",
+			required: false,
+			description: "Project name (npm package name), or \".\" for the current directory"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Do not ask questions: use the flags and the defaults"
+		},
+		pm: {
+			type: "enum",
+			options: [
+				"bun",
+				"npm",
+				"pnpm",
+				"yarn"
+			],
+			description: "Package manager (default: the one running the CLI, bun under Bun, else npm)"
+		},
+		adapter: {
+			type: "enum",
+			options: [
+				"node",
+				"fastify",
+				"express",
+				"hono"
+			],
+			description: "HTTP adapter (default: node, the built-in node:http server)"
+		},
+		features: {
+			type: "string",
+			valueHint: "list",
+			description: "Comma-separated features: config, observability, messaging, schedule, openapi, or \"all\" / \"none\" (default: config,observability)"
+		},
+		install: {
+			type: "boolean",
+			default: true,
+			description: "Do not install the dependencies"
+		},
+		git: {
+			type: "boolean",
+			default: true,
+			description: "Do not initialise a git repository"
+		},
+		dir: {
+			type: "string",
+			valueHint: "path",
+			description: "Target directory (default: ./<name>)"
+		},
+		force: {
+			type: "boolean",
+			description: "Write into a non-empty directory (existing files are overwritten)"
+		}
+	},
+	async run({ args: options, cli, rawArgs }) {
+		const prompts = cli.interactive && options.yes !== true ? await cli.services.loadPrompts() : void 0;
+		prompts?.intro(cli.colors.bold(`Create a Znight project ${cli.colors.dim(`v${cli.version}`)}`));
+		let name = options.name;
+		if (name === void 0 || name === "") {
+			if (prompts === void 0) throw new UsageError("Missing project name", ["znight new <name> (or \".\" to use the current directory)"]);
+			name = await prompts.text({
+				message: "Project name?",
+				placeholder: "my-service",
+				validate: (value) => value === "." ? void 0 : validatePackageName(value.trim())
+			});
+		}
+		name = name.trim();
+		const inPlace = name === ".";
+		if (inPlace) name = toPackageName(basename(cli.cwd));
+		const problem = validatePackageName(name);
+		if (problem !== void 0) {
+			const candidate = toPackageName(name);
+			throw new UsageError(`Invalid project name "${name}": ${problem}`, candidate !== "" && validatePackageName(candidate) === void 0 ? [`try "${candidate}"`] : []);
+		}
+		const directory = resolve(cli.cwd, options.dir ?? (inPlace ? "." : unscopedName(name)));
+		await checkTarget(directory, cli, prompts, options.force === true);
+		const packageManager = options.pm ?? await prompts?.select({
+			message: "Package manager?",
+			choices: PACKAGE_MANAGERS.map((pm) => ({
+				value: pm,
+				label: pm
+			})),
+			initialValue: detectPackageManager(cli.env, cli.runtime.name === "bun")
+		}) ?? detectPackageManager(cli.env, cli.runtime.name === "bun");
+		const adapter = options.adapter ?? await prompts?.select({
+			message: "HTTP adapter?",
+			choices: HTTP_ADAPTERS.map((value) => ({
+				value,
+				label: ADAPTER_LABELS[value]
+			})),
+			initialValue: "node"
+		}) ?? "node";
+		const features = await chooseFeatures(options.features, prompts);
+		const install = prompts === void 0 || hasFlag(rawArgs, "install") ? options.install !== false : await prompts.confirm({
+			message: `Install the dependencies with ${packageManager}?`,
+			initialValue: true
+		});
+		const git = prompts === void 0 || hasFlag(rawArgs, "git") ? options.git !== false : await prompts.confirm({
+			message: "Initialise a git repository?",
+			initialValue: true
+		});
+		const files = renderProject({
+			name,
+			packageManager,
+			adapter,
+			features,
+			znightVersion: cli.version
+		});
+		writeProject(directory, files);
+		const where = displayPath(directory, cli.cwd);
+		const summary = `${cli.colors.bold(name)} (${packageManager}, ${adapter}${features.length > 0 ? `, ${features.join(", ")}` : ""})`;
+		if (prompts === void 0) cli.reporter.success(`Created ${summary} in ${where}`);
+		else prompts.note(files.map((file) => file.path).join("\n"), `Created ${summary} in ${where}`);
+		if (git) await runGit(directory, cli, prompts);
+		let installed = false;
+		if (install) installed = await runInstall(directory, packageManager, cli, prompts);
+		const steps = [
+			...inPlace && options.dir === void 0 ? [] : [`cd ${where}`],
+			...installed ? [] : [installCommand(packageManager).join(" ")],
+			runScript(packageManager, "dev")
+		];
+		if (prompts === void 0) {
+			cli.reporter.log();
+			cli.reporter.log(cli.colors.bold("Next steps:"));
+			for (const step of steps) cli.reporter.log(`  ${cli.colors.cyan(step)}`);
+			cli.reporter.log();
+		} else prompts.outro(`Next steps:\n${steps.map((step) => `   ${cli.colors.cyan(step)}`).join("\n")}`);
+		if (install && !installed) throw new CliError("The project was created but installing the dependencies failed", { hints: [`run "${installCommand(packageManager).join(" ")}" in ${where}`] });
+		return 0;
+	}
+});
+async function checkTarget(directory, cli, prompts, force) {
+	const state = targetState(directory);
+	const where = displayPath(directory, cli.cwd);
+	if (state === "file") throw new CliError(`${where} exists and is not a directory`);
+	if (state !== "not-empty" || force) return;
+	if (prompts !== void 0) {
+		if (await prompts.confirm({
+			message: `${where} is not empty. Write the project into it anyway (existing files are overwritten)?`,
+			initialValue: false
+		})) return;
+	}
+	throw new CliError(`${where} is not empty`, { hints: ["choose another name or --dir, or pass --force to write into it anyway"] });
+}
+async function chooseFeatures(value, prompts) {
+	if (value !== void 0) {
+		const parsed = parseFeatures(value);
+		if ("unknown" in parsed) throw new UsageError(`Unknown feature${parsed.unknown.length > 1 ? "s" : ""}: ${parsed.unknown.join(", ")}`, [`available features: ${FEATURES.join(", ")} (or "all", "none")`]);
+		return parsed.features;
+	}
+	if (prompts === void 0) return [...DEFAULT_FEATURES];
+	const selected = await prompts.multiselect({
+		message: "Features? (space to toggle)",
+		choices: FEATURES.map((feature) => ({
+			value: feature,
+			label: FEATURE_LABELS[feature]
+		})),
+		initialValues: DEFAULT_FEATURES
+	});
+	return FEATURES.filter((feature) => selected.includes(feature));
+}
+async function runGit(directory, cli, prompts) {
+	const outcome = await initGit(cli.services.processes, directory, cli.env);
+	const message = {
+		initialized: "Initialised a git repository",
+		"inside-repository": "Already inside a git repository: skipped git init",
+		unavailable: "git is not available: skipped git init",
+		failed: "git init failed: skipped"
+	}[outcome];
+	if (outcome === "initialized") {
+		if (prompts === void 0) cli.reporter.success(message);
+	} else cli.reporter.warn(message);
+}
+async function runInstall(directory, packageManager, cli, prompts) {
+	const command = installCommand(packageManager).join(" ");
+	const spinner = prompts?.spinner();
+	if (spinner === void 0) cli.reporter.info(`Installing the dependencies (${command})...`);
+	else spinner.start(`Installing the dependencies (${command})`);
+	const result = await installDependencies(cli.services.processes, directory, packageManager, cli.env);
+	if (result.code === 0 && result.error === void 0) {
+		if (spinner === void 0) cli.reporter.success("Installed the dependencies");
+		else spinner.stop("Installed the dependencies");
+		return true;
+	}
+	const reason = result.error === void 0 ? `${command} exited with code ${result.code ?? result.signal}` : `${packageManager} could not be started (${result.error.message})`;
+	if (spinner === void 0) cli.reporter.error(reason);
+	else spinner.stop(reason, true);
+	const output = `${result.stdout}${result.stderr}`.trim();
+	if (output !== "") cli.reporter.logError(output.split("\n").slice(-30).join("\n"));
+	return false;
+}
+// src/commands/openapi.ts
+/** Values of a repeatable string option (`-o a -o b`, `--output=a`, `--output b,c`). */
+function repeatedOption(rawArgs, name, alias) {
+	const values = [];
+	for (let index = 0; index < rawArgs.length; index++) {
+		const token = rawArgs[index] ?? "";
+		let value;
+		if (token === `--${name}` || token === `-${alias}`) value = rawArgs[++index];
+		else if (token.startsWith(`--${name}=`)) value = token.slice(name.length + 3);
+		else if (token.startsWith(`-${alias}=`)) value = token.slice(alias.length + 2);
+		if (value === void 0) continue;
+		for (const part of value.split(",")) if (part.trim() !== "") values.push(part.trim());
+	}
+	return values;
+}
+/** `znight openapi` */
+const openapiCommand = defineCommand({
+	meta: {
+		name: "openapi",
+		description: "Emit the OpenAPI document of the application (openapi.json, --check in CI)",
+		usage: "[options]",
+		examples: [
+			"znight openapi                      # writes openapi.json at the project root",
+			"znight openapi -o docs/openapi.yaml # YAML, chosen by the extension (needs yaml)",
+			"znight openapi --check              # CI: exit 1 when the file is missing or stale",
+			"znight openapi --prefix /api        # servers default when @OpenApiDocument declares none",
+			"znight openapi --runtime bun        # load the modules with Bun"
+		],
+		details: [
+			"The application is compiled like \"znight generate\" (compile errors stop everything), then its",
+			"generated module is loaded in a child process (Bun: the compiler preload; Node.js: a Vite server)",
+			"and @znight/openapi assembles the document. Nothing is instantiated. Outputs are only written",
+			"when they change. Requires @znight/openapi in the project."
+		].join("\n")
+	},
+	args: {
+		output: {
+			type: "string",
+			alias: "o",
+			valueHint: "file",
+			description: "Output file, repeatable (.yaml / .yml write YAML). Default: openapi.json"
+		},
+		check: {
+			type: "boolean",
+			description: "Do not write: exit with code 1 when an output is missing or stale"
+		},
+		prefix: {
+			type: "string",
+			valueHint: "path",
+			description: "HTTP prefix: the servers default (/api)"
+		},
+		runtime: {
+			type: "enum",
+			options: [
+				"auto",
+				"node",
+				"bun"
+			],
+			description: "Runtime loading the application modules (default: auto, the one running the CLI)"
+		},
+		converters: {
+			type: "string",
+			valueHint: "file",
+			description: "Module whose default export is a SchemaConverter[] (custom schema libraries)"
+		},
+		root: {
+			type: "string",
+			valueHint: "dir",
+			description: "Project root (default: the current directory)"
+		},
+		config: {
+			type: "string",
+			valueHint: "file",
+			description: "Vite config file (default: vite.config.*)"
+		},
+		"config-loader": {
+			type: "enum",
+			options: [
+				"bundle",
+				"runner",
+				"native"
+			],
+			description: "How Vite loads the config file (default: bundle)"
+		}
+	},
+	async run({ args, cli, rawArgs }) {
+		const root = resolveRoot(cli, args.root);
+		const outputs = repeatedOption(rawArgs, "output", "o");
+		const prefix = parseHttpPrefix(args.prefix, "prefix");
+		const compiler = await cli.services.loadCompiler(root);
+		const configLoader = args["config-loader"];
+		const options = await compilerOptions(cli, compiler, root, args.config, configLoader);
+		const openapi = await cli.services.loadOpenApi(root);
+		const started = performance.now();
+		let result;
+		try {
+			result = await openapi.emitOpenApi({
+				root,
+				output: outputs.length > 0 ? outputs : ["openapi.json"],
+				...args.check === true ? { check: true } : {},
+				...prefix === void 0 ? {} : { prefix },
+				...args.runtime === void 0 ? {} : { runtime: args.runtime },
+				...args.converters === void 0 ? {} : { converters: args.converters },
+				...args.config === void 0 ? {} : { config: args.config },
+				...configLoader === void 0 ? {} : { configLoader },
+				compilerOptions: options
+			});
+		} catch (error) {
+			const hints = error?.hints;
+			throw new CliError(`OpenAPI emission failed: ${errorMessage(error)}`, {
+				cause: error,
+				hints: Array.isArray(hints) ? hints : []
+			});
+		}
+		printDiagnostics(cli, compiler, result.diagnostics, root);
+		if (!result.ok || hasErrors(result.diagnostics)) {
+			const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+			cli.reporter.error(`OpenAPI emission failed: the application does not compile (${plural(errors, "error")})`);
+			return 1;
+		}
+		for (const warning of result.warnings) cli.reporter.warn(`${warning.code}: ${warning.message}`);
+		const elapsed = formatDuration(performance.now() - started);
+		const operations = Object.values(result.document?.paths ?? {}).reduce((count, item) => count + Object.keys(item).length, 0);
+		const stats = cli.colors.dim(`(${plural(operations, "operation")}, ${result.runtime}, ${elapsed})`);
+		if (args.check === true) {
+			for (const file of result.staleFiles) {
+				const shown = displayPath(file, cli.cwd);
+				if (existsSync(file)) cli.reporter.error(`${shown} is out of date`, ["run \"znight openapi\" and commit the result"]);
+				else cli.reporter.error(`${shown} is missing`, ["run \"znight openapi\" and commit the result"]);
+			}
+			if (result.stale) return 1;
+			cli.reporter.success(`${result.outputs.map((file) => cli.colors.bold(displayPath(file, cli.cwd))).join(", ")} up to date ${stats}`);
+			return 0;
+		}
+		for (const file of result.outputs) {
+			const shown = cli.colors.bold(displayPath(file, cli.cwd));
+			cli.reporter.success(`${result.written.includes(file) ? "Wrote" : "Up to date:"} ${shown} ${stats}`);
+		}
+		return 0;
+	}
+});
+function printDiagnostics(cli, compiler, diagnostics, root) {
+	if (diagnostics.length === 0) return;
+	const text = compiler.formatDiagnostics(diagnostics, {
+		color: cli.colors.isColorSupported,
+		cwd: root,
+		summary: false
+	});
+	cli.reporter.logError(text.trimEnd());
+	cli.reporter.logError();
+}
+/** Every schematic, in display order. */
+const SCHEMATICS = [
+	{
+		name: "service",
+		aliases: ["s"],
+		description: "An @Injectable() provider",
+		suffix: "service",
+		render: (names) => `import { Injectable } from '@znight/core'
+
+@Injectable()
+export class ${names.className} {
+  // Declare dependencies as constructor parameters: the compiler resolves them from their types.
+  // constructor(private readonly repository: ${names.pascal}Repository) {}
+}
+`
+	},
+	{
+		name: "controller",
+		aliases: ["co"],
+		description: "An HTTP @Controller() with two routes",
+		suffix: "controller",
+		render: (names) => `import { Controller, Get, Param } from '@znight/http'
+
+@Controller('/${names.kebab}')
+export class ${names.className} {
+  /** GET /${names.kebab} */
+  @Get()
+  list(): unknown[] {
+    return []
+  }
+
+  /** GET /${names.kebab}/:id */
+  @Get('/:id')
+  find(@Param('id') id: string): { id: string } {
+    return { id }
+  }
+}
+`
+	},
+	{
+		name: "consumer",
+		aliases: ["cs"],
+		description: "A message @Consumer() (@znight/messaging)",
+		suffix: "consumer",
+		render: (names, context) => context.zod ? `import { Consumer, Message, OnMessage, Retry } from '@znight/messaging'
+import { z } from 'zod'
+
+export const ${names.pascal}Message = z.object({
+  id: z.string(),
+})
+export type ${names.pascal}Message = z.output<typeof ${names.pascal}Message>
+
+/**
+ * Consumes the "${names.kebab}" queue.
+ * Delivery is at-least-once: make the handler idempotent. Throw to retry, throw a NonRetryableError
+ * to dead-letter the message right away.
+ */
+@Consumer('${names.kebab}')
+export class ${names.className} {
+  @OnMessage()
+  @Retry({ attempts: 3, backoff: 'exponential', delay: 1000 })
+  handle(@Message(${names.pascal}Message) message: ${names.pascal}Message): void {
+    console.log('received', message.id)
+  }
+}
+` : `import { Consumer, Ctx, type InboundMessage, OnMessage, Retry } from '@znight/messaging'
+
+/**
+ * Consumes the "${names.kebab}" queue.
+ * Delivery is at-least-once: make the handler idempotent. Throw to retry, throw a NonRetryableError
+ * to dead-letter the message right away.
+ */
+@Consumer('${names.kebab}')
+export class ${names.className} {
+  @OnMessage()
+  @Retry({ attempts: 3, backoff: 'exponential', delay: 1000 })
+  handle(@Ctx() message: InboundMessage): void {
+    console.log('received', message.id, message.payload)
+  }
+}
+`,
+		hint: () => "consumers run with MessagingPlugin.configure({ driver }) in src/main.ts"
+	},
+	{
+		name: "config",
+		aliases: ["cf"],
+		description: "A @Config() class read from the environment (@znight/config)",
+		suffix: "config",
+		render: (names) => `import { Config } from '@znight/config'
+
+/**
+ * Settings read from the ${constantCase(names.camel)}_* environment variables (or .env files).
+ * Validated at boot by ConfigPlugin: the type of a property selects its coercion, an initializer
+ * makes it optional.
+ */
+@Config('${names.camel}')
+export class ${names.className} {
+  /** ${constantCase(names.camel)}_ENABLED */
+  enabled = true
+}
+`,
+		hint: (names) => `inject ${names.className} anywhere; values are loaded by ConfigPlugin.configure() in src/main.ts`
+	},
+	{
+		name: "guard",
+		aliases: ["gu"],
+		description: "An HTTP guard (CanActivate)",
+		suffix: "guard",
+		render: (names) => `import type { CanActivate, HttpContext } from '@znight/http'
+
+import { Injectable } from '@znight/core'
+
+@Injectable()
+export class ${names.className} implements CanActivate {
+  // The route decisions this guard enforces (createRouteDecorator groups, see "Route decisions" in
+  // the @znight/http README): the boot fails when a route of a required group has no guard
+  // enforcing its decision.
+  // static readonly enforces = [Public, Roles]
+
+  canActivate(ctx: HttpContext): boolean | Promise<boolean> {
+    // Return false (403 Forbidden) or throw an HttpException (UnauthorizedException...) to reject
+    // the request, e.g. return ctx.header('authorization') !== undefined
+    return true
+  }
+}
+`,
+		hint: (names) => `use it with @UseGuard(${names.className}) on a controller or a route, or HttpPlugin.configure({ guards: [${names.className}] })`
+	},
+	{
+		name: "interceptor",
+		aliases: ["itc"],
+		description: "An HTTP interceptor (HttpInterceptor), or a method interceptor with --aop",
+		suffix: "interceptor",
+		render: (names, context) => context.aop ? `import { Injectable, type MethodInterceptor, type MethodInvocation } from '@znight/core'
+
+@Injectable()
+export class ${names.className} implements MethodInterceptor {
+  intercept(invocation: MethodInvocation): unknown {
+    // Runs around every intercepted call. For a synchronous method, return synchronously.
+    return invocation.proceed()
+  }
+}
+` : `import type { CallHandler, HttpContext, HttpInterceptor } from '@znight/http'
+
+import { Injectable } from '@znight/core'
+
+@Injectable()
+export class ${names.className} implements HttpInterceptor {
+  async intercept(ctx: HttpContext, next: CallHandler): Promise<unknown> {
+    const started = performance.now()
+    try {
+      // the handler result (before serialisation): return it, transform it or replace it
+      return await next()
+    } finally {
+      ctx.setHeader('server-timing', \`app;dur=\${(performance.now() - started).toFixed(1)}\`)
+    }
+  }
+}
+`,
+		hint: (names, context) => context.aop ? `use it with @Intercept(${names.className}) on any provider method` : `use it with @UseInterceptor(${names.className}) on a controller or a route, or HttpPlugin.configure({ interceptors: [${names.className}] })`
+	},
+	{
+		name: "factory",
+		aliases: ["f"],
+		description: "A @Factory() whose @Provides() methods provide objects you do not own",
+		suffix: "factory",
+		render: (names) => `import { Factory, Provides } from '@znight/core'
+
+/** Replace with the type you provide: a database pool, an SDK client... */
+export class ${names.pascal}Client {
+  close(): void {}
+}
+
+/**
+ * @Provides methods create providers for classes you cannot decorate. Their parameters are injected,
+ * their explicit return type is the provided type (Promise<T> for an async initialisation).
+ */
+@Factory()
+export class ${names.className} {
+  @Provides({ dispose: 'close' })
+  create${names.pascal}Client(): ${names.pascal}Client {
+    return new ${names.pascal}Client()
+  }
+}
+`
+	},
+	{
+		name: "job",
+		aliases: ["j"],
+		description: "Scheduled jobs: @Cron, @Interval, @Timeout methods (@znight/schedule)",
+		suffix: "jobs",
+		render: (names) => `import { Cron, type JobContext } from '@znight/schedule'
+
+/**
+ * Scheduled jobs. A class with @Cron, @Interval or @Timeout methods becomes a singleton provider
+ * (no decorator needed): declare its dependencies as constructor parameters.
+ */
+export class ${names.className} {
+  /** Every day at 03:00 UTC (set timeZone to follow a local clock). A run still running is skipped. */
+  @Cron('0 3 * * *', { name: '${names.qualified}.daily' })
+  daily(ctx: JobContext): void {
+    // checkpoint: throws when the run is aborted (shutdown, maxDuration or a lost lock)
+    ctx.signal.throwIfAborted()
+  }
+}
+`,
+		hint: () => "jobs run with SchedulePlugin.configure() in src/main.ts; test them with createTestClock() from @znight/schedule/testing"
+	}
+];
+/** Finds a schematic by name or alias. */
+function findSchematic(name) {
+	const key = name.toLowerCase();
+	return SCHEMATICS.find((schematic) => schematic.name === key || schematic.aliases.includes(key));
+}
+/**
+* Parses `users/user-profile`, `UserProfile`, `user_profile.service.ts`... A trailing suffix
+* matching the schematic (`user-service`, `UserService`, `user.service`) is dropped.
+*
+* @throws Error with a user-facing message when the name is invalid.
+*/
+function parseSchematicName(input, schematic) {
+	const segments = input.trim().split(/[\\/]+/).filter((segment) => segment !== "");
+	if (segments.length === 0) throw new Error("the name cannot be empty");
+	if (isAbsolute(input) || segments.some((segment) => segment === "." || segment === "..")) throw new Error(`invalid name "${input}": use a path relative to src/ without "." or ".." segments`);
+	let words = kebabCase((segments.at(-1) ?? "").replace(/\.[cm]?tsx?$/, ""));
+	for (const suffix of [`-${schematic.suffix}`, `.${schematic.suffix}`]) if (words.endsWith(suffix) && words !== suffix.slice(1)) words = words.slice(0, -suffix.length);
+	if (words === "") throw new Error(`invalid name "${input}"`);
+	if (!/^[a-z]/.test(words)) throw new Error(`invalid name "${input}": it must start with a letter`);
+	const directories = segments.slice(0, -1).map((segment) => kebabCase(segment));
+	if (directories.some((directory) => directory === "")) throw new Error(`invalid name "${input}"`);
+	const pascal = pascalCase(words);
+	return {
+		directories,
+		names: {
+			kebab: words,
+			pascal,
+			camel: camelCase(words),
+			className: `${pascal}${pascalCase(schematic.suffix)}`,
+			qualified: qualifiedName(directories, words)
+		}
+	};
+}
+/** `reports` + `digest` → `reports.digest`; the directory named after the element is left out. */
+function qualifiedName(directories, kebab) {
+	return [...directories.at(-1) === kebab ? directories.slice(0, -1) : directories, kebab].join(".");
+}
+/**
+* Directories of `directory` relative to `<root>/src`, or to `root` outside `src/`, kebab-cased
+* (`undefined` outside the project).
+*/
+function sourceDirectories(root, directory) {
+	for (const base of [join(root, "src"), root]) {
+		const path = relative(base, directory);
+		if (isAbsolute(path) || path === ".." || /^\.\.[\\/]/.test(path)) continue;
+		return path.split(/[\\/]+/).map((segment) => kebabCase(segment)).filter((segment) => segment !== "");
+	}
+}
+/**
+* Computes the file of a schematic:
+*
+* | Input                        | File                                  |
+* | ---------------------------- | ------------------------------------- |
+* | `service user`               | `src/user/user.service.ts`            |
+* | `service users/user`         | `src/users/user.service.ts`           |
+* | `service user --flat`        | `src/user.service.ts`                 |
+* | `service user --path lib/x`  | `lib/x/user.service.ts`               |
+*/
+function planSchematic(options) {
+	const { schematic, context } = options;
+	const parsed = parseSchematicName(options.name, schematic);
+	const base = options.path ?? join(options.root, "src");
+	let directories = [...parsed.directories];
+	if (directories.length === 0 && options.path === void 0 && options.flat !== true) directories = [parsed.names.kebab];
+	const file = normalize(join(base, ...directories, `${parsed.names.kebab}.${schematic.suffix}.ts`));
+	const located = options.path === void 0 ? void 0 : sourceDirectories(options.root, dirname(file));
+	const names = located === void 0 ? parsed.names : {
+		...parsed.names,
+		qualified: qualifiedName(located, parsed.names.kebab)
+	};
+	return {
+		schematic,
+		names,
+		file,
+		content: schematic.render(names, context),
+		hint: schematic.hint?.(names, context)
+	};
+}
+// src/commands/schematic.ts
+function schematicList(colors) {
+	return table(SCHEMATICS.map((schematic) => [`${schematic.name} (${schematic.aliases.join(", ")})`, schematic.description]), colors).join("\n");
+}
+/** `znight g` */
+const schematicCommand = defineCommand({
+	meta: {
+		name: "g",
+		description: "Generate a service, controller, consumer, config, guard, interceptor, factory or job",
+		usage: "<schematic> <name> [options]",
+		aliases: ["generate <schematic>"],
+		details: (colors) => `${colors.bold("Schematics")}\n${schematicList(colors)}\n\nFiles are named <name>.<schematic>.ts (kebab-case), classes <Name><Schematic> (PascalCase).`,
+		examples: [
+			"znight g service users/user           # src/users/user.service.ts (UserService)",
+			"znight g controller order             # src/order/order.controller.ts (OrderController)",
+			"znight g guard auth --flat            # src/auth.guard.ts (AuthGuard)",
+			"znight g interceptor timing --aop     # a method interceptor (@Intercept)",
+			"znight g consumer orders --path src/messaging",
+			"znight g job digest                   # src/digest/digest.jobs.ts (DigestJobs)"
+		]
+	},
+	args: {
+		schematic: {
+			type: "positional",
+			required: false,
+			description: "What to generate (see Schematics below)"
+		},
+		name: {
+			type: "positional",
+			required: false,
+			description: "Name, optionally prefixed with directories relative to src/ (users/user-profile)"
+		},
+		path: {
+			type: "string",
+			valueHint: "dir",
+			description: "Directory of the file (default: src/<name>/)"
+		},
+		flat: {
+			type: "boolean",
+			description: "Do not create a directory named after the element"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Overwrite an existing file"
+		},
+		"dry-run": {
+			type: "boolean",
+			alias: "d",
+			description: "Print the file instead of writing it"
+		},
+		aop: {
+			type: "boolean",
+			description: "interceptor: a method interceptor (@Intercept) instead of an HTTP one"
+		},
+		root: {
+			type: "string",
+			valueHint: "dir",
+			description: "Project root (default: the nearest package.json)"
+		}
+	},
+	run({ args, cli }) {
+		if (args.schematic === void 0 || args.schematic === "") throw new UsageError("Missing <schematic>", [`available schematics:\n${schematicList(cli.colors)}`]);
+		const schematic = findSchematic(args.schematic);
+		if (schematic === void 0) {
+			const candidate = suggest(args.schematic, SCHEMATICS.map((item) => item.name));
+			throw new UsageError(`Unknown schematic "${args.schematic}"`, [...candidate === void 0 ? [] : [`did you mean "${candidate}"?`], `available schematics: ${SCHEMATICS.map((item) => item.name).join(", ")}`]);
+		}
+		if (args.name === void 0 || args.name === "") throw new UsageError("Missing <name>", [`znight g ${schematic.name} <name>, e.g. znight g ${schematic.name} users/user`]);
+		const root = args.root === void 0 ? findProjectRoot(cli.cwd) : resolveRoot(cli, args.root);
+		const manifest = readManifest(root);
+		const zod = manifest.dependencies?.["zod"] !== void 0 || manifest.devDependencies?.["zod"] !== void 0;
+		let plan;
+		try {
+			plan = planSchematic({
+				schematic,
+				name: args.name,
+				root,
+				path: args.path === void 0 ? void 0 : resolve(cli.cwd, args.path),
+				flat: args.flat === true,
+				context: {
+					zod,
+					aop: args.aop === true
+				}
+			});
+		} catch (error) {
+			throw new UsageError(error instanceof Error ? error.message : String(error));
+		}
+		const file = displayPath(plan.file, cli.cwd);
+		if (args["dry-run"] === true) {
+			cli.reporter.info(`Would create ${cli.colors.bold(file)} (${plan.names.className})`);
+			cli.reporter.log();
+			cli.reporter.log(plan.content);
+			return 0;
+		}
+		const exists = existsSync(plan.file);
+		if (exists && args.force !== true) throw new CliError(`${file} already exists`, { hints: ["pass --force to overwrite it"] });
+		mkdirSync(dirname(plan.file), { recursive: true });
+		writeFileSync(plan.file, plan.content);
+		cli.reporter.success(`${exists ? "Overwrote" : "Created"} ${cli.colors.bold(file)} ${cli.colors.dim(`(${plan.names.className})`)}`);
+		if (plan.hint !== void 0) cli.reporter.log(`  ${cli.colors.dim(plan.hint)}`);
+		return 0;
+	}
+});
+// src/commands/start.ts
+/** Entries tried when `--entry` is not given. */
+const DEFAULT_ENTRIES = ["dist/main.js", "dist/main.mjs"];
+/** `znight start` */
+const startCommand = defineCommand({
+	meta: {
+		name: "start",
+		description: "Run the production build",
+		usage: "[options] [-- <application arguments>]",
+		examples: [
+			"znight start",
+			"znight start --runtime bun",
+			"znight start --entry dist/worker.js -- --verbose"
+		],
+		details: "NODE_ENV defaults to \"production\". Signals (SIGINT, SIGTERM) reach the application, which stops gracefully."
+	},
+	args: {
+		root: {
+			type: "string",
+			valueHint: "dir",
+			description: "Project root (default: the current directory)"
+		},
+		entry: {
+			type: "string",
+			valueHint: "file",
+			description: "File to run (default: dist/main.js)"
+		},
+		runtime: {
+			type: "enum",
+			options: [
+				"auto",
+				"node",
+				"bun"
+			],
+			default: "auto",
+			description: "Runtime of the application (auto: the runtime running the CLI)"
+		}
+	},
+	async run({ args, cli, passthrough }) {
+		const root = resolveRoot(cli, args.root);
+		const candidates = args.entry === void 0 ? DEFAULT_ENTRIES : [args.entry];
+		const entry = candidates.map((file) => resolve(root, file)).find((file) => existsSync(file));
+		if (entry === void 0) throw new CliError(`${displayPath(resolve(root, candidates[0] ?? ""), cli.cwd)} not found`, { hints: ["build the application first: znight build"] });
+		const runtime = resolveRuntime(args.runtime, cli.runtime);
+		const executable = runtimeExecutable(runtime, cli.runtime, cli.env);
+		if (executable === void 0) throw new CliError(`Cannot find "${runtime}" in PATH`, { hints: ["install it, or choose another --runtime"] });
+		const argv = [
+			...runtimeArguments(runtime),
+			entry,
+			...passthrough
+		];
+		const env = {
+			...cli.env,
+			NODE_ENV: cli.env["NODE_ENV"] ?? "production"
+		};
+		const { processes } = cli.services;
+		if (processes.execve !== void 0) {
+			const clean = {};
+			for (const [key, value] of Object.entries(env)) if (value !== void 0) clean[key] = value;
+			processes.execve(executable, [executable, ...argv], clean, root);
+			return 0;
+		}
+		const child = processes.spawn(executable, argv, {
+			cwd: root,
+			env,
+			detached: true
+		});
+		const forward = (signal) => () => {
+			child.kill(signal);
+		};
+		const listeners = [
+			"SIGINT",
+			"SIGTERM",
+			"SIGHUP"
+		].map((signal) => [signal, forward(signal)]);
+		for (const [signal, listener] of listeners) cli.signals.on(signal, listener);
+		try {
+			const status = await child.exited;
+			if (status.error !== void 0) throw new CliError(`Cannot start ${runtime}: ${status.error.message}`);
+			return exitCodeOf(status);
+		} finally {
+			for (const [signal, listener] of listeners) cli.signals.off(signal, listener);
+		}
+	}
+});
+// src/main.ts
+/** Every command, in help order. */
+const COMMANDS = [
+	newCommand,
+	generateCommand,
+	schematicCommand,
+	devCommand,
+	buildCommand,
+	startCommand,
+	openapiCommand
+];
+/** Finds a command by name or alias. */
+function findCommand(name) {
+	return COMMANDS.find((command) => command.meta.name === name || command.meta.aliases?.includes(name) === true);
+}
+/** Extracts `--color`, `--no-color` and `--debug` (anywhere before `--`). */
+function extractGlobalOptions(argv) {
+	const separator = argv.indexOf("--");
+	const before = separator === -1 ? argv : argv.slice(0, separator);
+	const after = separator === -1 ? [] : argv.slice(separator);
+	const result = {
+		debug: false,
+		rest: []
+	};
+	for (const arg of before) if (arg === "--color") result.color = true;
+	else if (arg === "--no-color") result.color = false;
+	else if (arg === "--debug") result.debug = true;
+	else result.rest.push(arg);
+	result.rest.push(...after);
+	return result;
+}
+/**
+* Runs the CLI with `argv` (without the executable and script, i.e. `process.argv.slice(2)`).
+* Resolves with the exit code; never throws.
+*/
+async function main(argv, options = {}) {
+	const globals = extractGlobalOptions(argv);
+	const cli = createContext({
+		...options,
+		...globals.color === void 0 ? {} : { color: globals.color },
+		...globals.debug ? { debug: true } : {}
+	});
+	try {
+		return await dispatch(globals.rest, cli);
+	} catch (error) {
+		return reportError(error, cli);
+	}
+}
+async function dispatch(argv, cli) {
+	const separator = argv.indexOf("--");
+	const args = separator === -1 ? [...argv] : argv.slice(0, separator);
+	const passthrough = separator === -1 ? [] : argv.slice(separator + 1);
+	const [first, ...rest] = args;
+	if (first === void 0 || first === "-h" || first === "--help") {
+		cli.reporter.log(renderRootHelp(cli));
+		return ExitCode.Ok;
+	}
+	if (first === "-v" || first === "--version" || first === "version") {
+		cli.reporter.log(cli.version);
+		return ExitCode.Ok;
+	}
+	if (first === "help") {
+		const target = rest[0] === void 0 ? void 0 : findCommand(rest[0]);
+		if (rest[0] !== void 0 && target === void 0) throw unknownCommand(rest[0]);
+		cli.reporter.log(target === void 0 ? renderRootHelp(cli) : renderCommandHelp(target, cli.colors));
+		return ExitCode.Ok;
+	}
+	if (first.startsWith("-")) throw new UsageError(`Unknown option ${first}`, ["options go after the command: znight <command> [options]"]);
+	let command = findCommand(first);
+	let commandArgs = rest;
+	if (command === void 0 && first.startsWith("generate:")) {
+		command = schematicCommand;
+		commandArgs = [first.slice(9), ...rest];
+	} else if (command === generateCommand && rest[0] !== void 0 && !rest[0].startsWith("-")) command = schematicCommand;
+	if (command === void 0) throw unknownCommand(first);
+	if (commandArgs.includes("-h") || commandArgs.includes("--help")) {
+		cli.reporter.log(renderCommandHelp(command, cli.colors));
+		return ExitCode.Ok;
+	}
+	try {
+		return await command.execute(commandArgs, passthrough, cli);
+	} catch (error) {
+		if (error instanceof UsageError) throw new UsageError(error.message, [...error.hints, `run "znight ${command.meta.name} --help" for the usage`]);
+		throw error;
+	}
+}
+function unknownCommand(name) {
+	const candidate = suggest(name, COMMANDS.flatMap((command) => [command.meta.name, ...command.meta.aliases ?? []]));
+	return new UsageError(`Unknown command "${name}"`, [...candidate === void 0 ? [] : [`did you mean "znight ${candidate}"?`], "run \"znight --help\" for the list of commands"]);
+}
+/** The help of `znight` (list of commands). */
+function renderRootHelp(cli) {
+	const { colors } = cli;
+	const commands = table([
+		["new <name>", newCommand.meta.description],
+		["generate", "Generate the DI container (--check in CI, --watch)"],
+		["g <schematic> <name>", "Generate a service, controller, consumer, config, guard, interceptor, factory or job"],
+		["dev", "Build in watch mode, restart the application on every change"],
+		["build", buildCommand.meta.description],
+		["start", startCommand.meta.description],
+		["openapi", openapiCommand.meta.description]
+	], colors);
+	const options = table([
+		["-h, --help", "Show the help (also: znight <command> --help)"],
+		["-v, --version", "Show the version"],
+		["--color, --no-color", "Force or disable colors (NO_COLOR and FORCE_COLOR are honoured)"],
+		["--debug", "Print the stack trace of unexpected errors (or ZNIGHT_DEBUG=1)"]
+	], colors);
+	return [
+		`${colors.bold("znight")} ${colors.dim(`v${cli.version}`)} ${colors.dim("—")} compile-time dependency injection for TypeScript`,
+		"",
+		colors.bold("Usage"),
+		`  ${colors.cyan("znight <command> [options]")}`,
+		"",
+		colors.bold("Commands"),
+		...commands,
+		"",
+		colors.bold("Global options"),
+		...options,
+		"",
+		`Run ${colors.cyan("znight <command> --help")} for the options of a command.`,
+		""
+	].join("\n");
+}
+function reportError(error, cli) {
+	if (error instanceof CancelledError) {
+		cli.reporter.warn(error.message);
+		return error.exitCode;
+	}
+	if (error instanceof CliError) {
+		cli.reporter.error(error.message, error.hints);
+		if (cli.debug && error.cause !== void 0) cli.reporter.logError(stackOf(error.cause));
+		return error.exitCode;
+	}
+	cli.reporter.error(`Unexpected error: ${errorMessage(error)}`);
+	if (cli.debug) cli.reporter.logError(stackOf(error));
+	else cli.reporter.logError(cli.colors.dim("  run with --debug (or ZNIGHT_DEBUG=1) for the stack trace"));
+	return ExitCode.Failure;
+}
+function stackOf(error) {
+	return error instanceof Error && error.stack !== void 0 ? error.stack : String(error);
+}
+export { CancelledError as _, planSchematic as a, UsageError as b, FEATURES as c, AppSupervisor as d, createContext as f, defineCommand as g, loadCompiler as h, findSchematic as i, HTTP_ADAPTERS as l, adaptCompilerModule as m, main as n, renderProject as o, cliVersion as p, SCHEMATICS as r, DEFAULT_FEATURES as s, COMMANDS as t, PACKAGE_MANAGERS as u, CliError as v, ExitCode as y };
+
+//# sourceMappingURL=main-BWsiUsxN.mjs.map