@nectar-js/nectar 0.1.0

package/dist/cli-Ce-ZUj6M.js

@@ -0,0 +1,2225 @@
+import { T as version, _ as parseSegment, a as MANIFEST_FILE, b as loadModule, c as writeManifest, d as checkDeclaredRoute, f as compileComponents, g as formatSegment, i as pluginGraph, o as stableStringify, r as applyPlugins, s as toManifest, t as PluginError, v as enableModuleReloading, x as Diagnostics, y as invalidateModuleGraph } from "./plugins-CGvM19v9.js";
+import { a as checkIntents, c as configFor, i as scopeKey, n as syncCommands, r as RegistrationError, s as ConfigError, t as UnsafeSyncError, u as validateConfig } from "./registration-CaE0QBT6.js";
+import { i as createLogger, l as createSignals, n as createRuntime, r as manifestFiles, s as HandlerLoadError, t as LoginError, u as loadManifest } from "./runtime-CZJeZvSL.js";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, rmSync, watch, writeFileSync } from "node:fs";
+import { Events } from "discord.js";
+import { ApplicationCommandOptionType, ApplicationCommandType } from "discord-api-types/v10";
+import { parseArgs, styleText } from "node:util";
+//#region src/registration/targets.ts
+/**
+* Where this environment registers commands. Development and test use `dev.guilds` only, so a
+* project without dev guilds registers nothing until some are configured. Production uses
+* `commands.target`, global by default.
+*/
+function registrationScopes(config, env) {
+	if (env !== "production") return (config.dev?.guilds ?? []).map((guild) => ({ guild }));
+	const target = config.commands?.target ?? "global";
+	return target === "global" ? ["global"] : target.map((guild) => ({ guild }));
+}
+//#endregion
+//#region src/typegen/emit.ts
+const TYPES_FILE = "types.d.ts";
+const PACKAGE = "@nectar-js/nectar";
+const COMMAND_TYPE$1 = {
+	[ApplicationCommandType.ChatInput]: "chatInput",
+	[ApplicationCommandType.User]: "user",
+	[ApplicationCommandType.Message]: "message"
+};
+const OPTION_TYPE$1 = {
+	[ApplicationCommandOptionType.String]: "string",
+	[ApplicationCommandOptionType.Integer]: "integer",
+	[ApplicationCommandOptionType.Number]: "number",
+	[ApplicationCommandOptionType.Boolean]: "boolean",
+	[ApplicationCommandOptionType.User]: "user",
+	[ApplicationCommandOptionType.Channel]: "channel",
+	[ApplicationCommandOptionType.Role]: "role",
+	[ApplicationCommandOptionType.Mentionable]: "mentionable",
+	[ApplicationCommandOptionType.Attachment]: "attachment"
+};
+/**
+* Renders `types.d.ts`: a module augmentation of `@nectar-js/nectar` that lists every route with
+* its parameters, options, and the context its middleware chain adds. Handler and middleware
+* types are pulled in with `import()` type queries relative to `outDir`. Whatever a plugin's
+* `types` hook returns is appended after the augmentation.
+*/
+function toTypes(graph, outDir, plugins = []) {
+	const absoluteOut = path.resolve(outDir);
+	const middlewareAliases = /* @__PURE__ */ new Map();
+	const aliasFor = (file) => {
+		let alias = middlewareAliases.get(file);
+		if (alias === void 0) {
+			alias = `M${middlewareAliases.size}`;
+			middlewareAliases.set(file, alias);
+		}
+		return alias;
+	};
+	const contextOf = (route) => {
+		const files = graph.chains.get(route.file)?.middleware ?? [];
+		return files.length === 0 ? "{}" : files.map(aliasFor).join(" & ");
+	};
+	const commands = [];
+	for (const command of [...graph.commands].sort((a, b) => a.name.localeCompare(b.name))) for (const [key, route] of Object.entries(command.handlers)) {
+		const options = Object.entries(optionsAt(command.payload, key)).map(([name, type]) => `${quote(name)}: ${quote(type)}`).join("; ");
+		commands.push(`    ${quote(route.path)}: { type: ${quote(COMMAND_TYPE$1[command.type] ?? "chatInput")}; options: {${options === "" ? "" : ` ${options} `}}; context: ${contextOf(route)} };`);
+	}
+	commands.sort();
+	const components = [...graph.components].sort((a, b) => a.path.localeCompare(b.path)).map((route) => {
+		const params = route.params.map((name) => `${quote(name)}: ${name === route.catchAll ? "string[]" : "string"}`).join("; ");
+		const kind = route.kind === "select" ? `select:${route.selectKind}` : route.kind;
+		return `    ${quote(route.path)}: { kind: ${quote(kind)}; params: {${params === "" ? "" : ` ${params} `}}; context: ${contextOf(route)} };`;
+	});
+	const events = graph.events.map((e) => `    ${quote(e.name)}: true;`);
+	const autocomplete = graph.autocomplete.map((a) => `    ${quote(a.route.path)}: ${a.options.map(quote).join(" | ") || "never"};`).sort();
+	const aliases = [...middlewareAliases].map(([file, alias]) => `type ${alias} = MiddlewareExtension<typeof import(${quote(importPath(absoluteOut, file))})>;`);
+	return [
+		"// Generated by Nectar. Do not edit.",
+		`import type { MiddlewareExtension } from ${quote(PACKAGE)};`,
+		...aliases.length === 0 ? [] : ["", ...aliases],
+		"",
+		`declare module ${quote(PACKAGE)} {`,
+		"  interface NectarRoutes {",
+		"    commands: {",
+		...commands.map(indent$1),
+		"    };",
+		"    components: {",
+		...components.map(indent$1),
+		"    };",
+		"    events: {",
+		...events.map(indent$1),
+		"    };",
+		"    autocomplete: {",
+		...autocomplete.map(indent$1),
+		"    };",
+		"  }",
+		"}",
+		"",
+		"export {};",
+		"",
+		...pluginTypes(graph, plugins)
+	].join("\n");
+}
+function pluginTypes(graph, plugins) {
+	const lines = [];
+	for (const plugin of plugins) {
+		if (plugin.types === void 0) continue;
+		let extra;
+		try {
+			extra = plugin.types(pluginGraph(graph));
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			throw new PluginError(plugin.name, `types failed: ${detail}`);
+		}
+		if (typeof extra !== "string" || extra.trim() === "") continue;
+		lines.push(`// From plugin ${JSON.stringify(plugin.name)}`, extra.trim(), "");
+	}
+	return lines;
+}
+function writeTypes(graph, outDir, plugins = []) {
+	mkdirSync(outDir, { recursive: true });
+	const file = path.join(outDir, TYPES_FILE);
+	writeFileSync(file, toTypes(graph, outDir, plugins));
+	return file;
+}
+/** Option name to option type name for one handler position of a command payload. */
+function optionsAt(payload, key) {
+	let options = payload.options;
+	for (const part of key === "" ? [] : key.split("/")) options = options?.find((o) => o.name === part)?.options;
+	const out = {};
+	for (const option of options ?? []) {
+		const type = option.type === void 0 ? void 0 : OPTION_TYPE$1[option.type];
+		if (option.name !== void 0 && type !== void 0) out[option.name] = type;
+	}
+	return out;
+}
+/** `../app/middleware.ts` becomes `../app/middleware.js`, which NodeNext resolves back to the source. */
+function importPath(fromDir, file) {
+	const mapped = path.relative(fromDir, file).split(path.sep).join("/").replace(/\.mts$/, ".mjs").replace(/\.ts$/, ".js");
+	return mapped.startsWith(".") ? mapped : `./${mapped}`;
+}
+function quote(value) {
+	return JSON.stringify(value);
+}
+function indent$1(line) {
+	return `  ${line}`;
+}
+//#endregion
+//#region src/autocomplete/compile.ts
+/**
+* Links every `autocomplete.ts` to its sibling command and checks that each named export
+* matches an option declared with `autocomplete: true`, and that no such option is left
+* without a handler.
+*/
+async function compileAutocomplete(table, commands) {
+	const diagnostics = new Diagnostics();
+	const routes = table.routes.filter((r) => r.kind === "autocomplete");
+	const targets = /* @__PURE__ */ new Map();
+	for (const command of commands) for (const [key, route] of Object.entries(command.handlers)) targets.set(route.id, {
+		command: route,
+		options: autocompleteOptions(command, key)
+	});
+	const results = await Promise.all(routes.map(async (route) => {
+		const target = targets.get(route.id);
+		if (target === void 0) {
+			diagnostics.error("autocomplete-without-command", `autocomplete.ts needs a command.ts in the same directory. None was found for "${route.path}".`, {
+				file: route.file,
+				route: route.id
+			});
+			return null;
+		}
+		let module;
+		try {
+			module = await loadModule(route.file);
+		} catch (error) {
+			diagnostics.error("module-load-failed", `Could not import this file: ${error instanceof Error ? error.message : String(error)}`, {
+				file: route.file,
+				route: route.id
+			});
+			return null;
+		}
+		const exported = Object.keys(module).filter((name) => name !== "default").sort();
+		let ok = true;
+		for (const name of exported) {
+			if (typeof module[name] !== "function") {
+				diagnostics.error("autocomplete-export-not-function", `Export "${name}" must be a function that answers autocomplete for the "${name}" option.`, {
+					file: route.file,
+					route: route.id
+				});
+				ok = false;
+				continue;
+			}
+			if (!target.options.has(name)) {
+				diagnostics.error("autocomplete-unknown-option", `Export "${name}" does not match an option with \`autocomplete: true\` in ${relative$2(target.command.file)}. ${expected(target.options)}`, {
+					file: route.file,
+					route: route.id
+				});
+				ok = false;
+			}
+		}
+		for (const name of [...target.options].sort()) {
+			if (exported.includes(name)) continue;
+			diagnostics.error("autocomplete-missing-handler", `Option "${name}" has \`autocomplete: true\` but ${relative$2(route.file)} does not export a "${name}" function.`, {
+				file: route.file,
+				route: route.id
+			});
+			ok = false;
+		}
+		return ok ? {
+			route,
+			command: target.command,
+			options: exported
+		} : null;
+	}));
+	for (const [id, target] of targets) {
+		if (target.options.size === 0 || routes.some((r) => r.id === id)) continue;
+		diagnostics.error("autocomplete-missing-file", `${[...target.options].map((o) => `"${o}"`).join(", ")} ${target.options.size === 1 ? "has" : "have"} \`autocomplete: true\` but there is no autocomplete.ts next to this command.`, {
+			file: target.command.file,
+			route: id
+		});
+	}
+	return {
+		autocomplete: results.filter((r) => r !== null),
+		diagnostics
+	};
+}
+/** Names of the options with `autocomplete: true` for one handler position of a command. */
+function autocompleteOptions(command, key) {
+	let options = command.payload.options;
+	for (const part of key === "" ? [] : key.split("/")) options = options?.find((o) => o.name === part)?.options;
+	return new Set((options ?? []).filter((o) => o.autocomplete === true).map((o) => o.name));
+}
+function expected(options) {
+	return options.size === 0 ? "The command declares no autocomplete options." : `Expected one of: ${[...options].sort().join(", ")}.`;
+}
+function relative$2(file) {
+	return path.relative(process.cwd(), file).split(path.sep).join("/");
+}
+//#endregion
+//#region src/commands/validate.ts
+const COMMAND_NAME = /^[-_\p{L}\p{N}\p{sc=Deva}\p{sc=Thai}]{1,32}$/u;
+const OPTION_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"integer",
+	"number",
+	"boolean",
+	"user",
+	"channel",
+	"role",
+	"mentionable",
+	"attachment"
+]);
+const COMMAND_TYPES = /* @__PURE__ */ new Set([
+	"chatInput",
+	"user",
+	"message"
+]);
+const TOP_LEVEL_KEYS = [
+	"defaultMemberPermissions",
+	"nsfw",
+	"contexts",
+	"integrationTypes"
+];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Validates the `meta` export of a `command.ts`. Returns null after reporting when unusable. */
+function validateCommandMeta(value, file, diagnostics) {
+	const ctx = {
+		diagnostics,
+		file
+	};
+	if (value === void 0) {
+		diagnostics.error("missing-meta", "command.ts must export a `meta` object with at least a description.", { file });
+		return null;
+	}
+	if (!isRecord(value)) {
+		fail$1(ctx, "invalid-meta", "`meta` must be an object.");
+		return null;
+	}
+	let ok = true;
+	const type = value.type ?? "chatInput";
+	if (typeof type !== "string" || !COMMAND_TYPES.has(type)) ok = fail$1(ctx, "invalid-meta", "`meta.type` must be \"chatInput\", \"user\", or \"message\".");
+	if (value.name !== void 0) ok = checkName(ctx, value.name, "meta.name", type === "chatInput") && ok;
+	if (type === "chatInput") {
+		ok = checkDescription(ctx, value.description, "meta.description") && ok;
+		if (value.options !== void 0) ok = checkOptions(ctx, value.options) && ok;
+	} else {
+		if (value.description !== void 0 && value.description !== "") ok = fail$1(ctx, "invalid-meta", "Context menu commands cannot have a description. Remove `meta.description`.");
+		if (value.options !== void 0) ok = fail$1(ctx, "invalid-meta", "Context menu commands cannot have options.");
+	}
+	ok = checkLocalizations(ctx, value.nameLocalizations, "meta.nameLocalizations") && ok;
+	ok = checkLocalizations(ctx, value.descriptionLocalizations, "meta.descriptionLocalizations") && ok;
+	ok = checkTopLevel(ctx, value) && ok;
+	return ok ? value : null;
+}
+/** Validates the `meta` export of a `route.ts` under `commands/`. */
+function validateCommandRouteMeta(value, file, diagnostics) {
+	const ctx = {
+		diagnostics,
+		file
+	};
+	if (value === void 0) {
+		diagnostics.error("missing-meta", "route.ts must export a `meta` object with a description.", { file });
+		return null;
+	}
+	if (!isRecord(value)) {
+		fail$1(ctx, "invalid-meta", "`meta` must be an object.");
+		return null;
+	}
+	let ok = checkDescription(ctx, value.description, "meta.description");
+	if (value.name !== void 0) ok = checkName(ctx, value.name, "meta.name", true) && ok;
+	ok = checkLocalizations(ctx, value.nameLocalizations, "meta.nameLocalizations") && ok;
+	ok = checkLocalizations(ctx, value.descriptionLocalizations, "meta.descriptionLocalizations") && ok;
+	ok = checkTopLevel(ctx, value) && ok;
+	return ok ? value : null;
+}
+/** Reports any top-level-only field so callers can reject them on nested commands. */
+function topLevelKeysUsed(meta) {
+	return TOP_LEVEL_KEYS.filter((key) => key in meta && meta[key] !== void 0);
+}
+function fail$1(ctx, code, message) {
+	ctx.diagnostics.error(code, message, { file: ctx.file });
+	return false;
+}
+function checkName(ctx, name, label, chatInput) {
+	if (typeof name !== "string" || name.length === 0 || name.length > 32) return fail$1(ctx, "invalid-name", `${label} must be a string of 1 to 32 characters.`);
+	if (chatInput) {
+		if (!COMMAND_NAME.test(name) || name !== name.toLowerCase()) return fail$1(ctx, "invalid-name", `${label} "${name}" is not a valid chat input command name. Discord requires lowercase letters, digits, hyphens, and underscores.`);
+	}
+	return true;
+}
+function checkDescription(ctx, description, label) {
+	if (typeof description !== "string" || description.length === 0 || description.length > 100) return fail$1(ctx, "invalid-description", `${label} must be a string of 1 to 100 characters.`);
+	return true;
+}
+function checkLocalizations(ctx, value, label) {
+	if (value === void 0) return true;
+	if (!isRecord(value)) return fail$1(ctx, "invalid-meta", `${label} must be an object of locale to string.`);
+	for (const [locale, text] of Object.entries(value)) if (typeof text !== "string") return fail$1(ctx, "invalid-meta", `${label}.${locale} must be a string.`);
+	return true;
+}
+function checkTopLevel(ctx, value) {
+	let ok = true;
+	const perms = value.defaultMemberPermissions;
+	if (perms !== void 0 && perms !== null && typeof perms !== "bigint" && typeof perms !== "string" && typeof perms !== "number") ok = fail$1(ctx, "invalid-meta", "`meta.defaultMemberPermissions` must be a permission bitfield (bigint, string, or number) or null.");
+	if (value.nsfw !== void 0 && typeof value.nsfw !== "boolean") ok = fail$1(ctx, "invalid-meta", "`meta.nsfw` must be a boolean.");
+	ok = checkEnumArray(ctx, value.contexts, "meta.contexts", [
+		0,
+		1,
+		2
+	]) && ok;
+	ok = checkEnumArray(ctx, value.integrationTypes, "meta.integrationTypes", [0, 1]) && ok;
+	return ok;
+}
+function checkEnumArray(ctx, value, label, allowed) {
+	if (value === void 0) return true;
+	if (!Array.isArray(value) || value.some((v) => !allowed.includes(v))) return fail$1(ctx, "invalid-meta", `${label} must be an array of ${allowed.join(", ")}. Use the discord.js enum values.`);
+	return true;
+}
+function checkOptions(ctx, options) {
+	if (!Array.isArray(options)) return fail$1(ctx, "invalid-option", "`meta.options` must be an array.");
+	if (options.length > 25) return fail$1(ctx, "invalid-option", "A command can have at most 25 options.");
+	let ok = true;
+	const names = /* @__PURE__ */ new Set();
+	let seenOptional = false;
+	for (const [index, option] of options.entries()) {
+		const label = `meta.options[${index}]`;
+		if (!isRecord(option)) {
+			ok = fail$1(ctx, "invalid-option", `${label} must be an object.`);
+			continue;
+		}
+		const typedOk = checkOption(ctx, option, label);
+		ok = typedOk && ok;
+		if (!typedOk) continue;
+		const typed = option;
+		if (names.has(typed.name)) ok = fail$1(ctx, "invalid-option", `${label}: option name "${typed.name}" is used twice.`);
+		names.add(typed.name);
+		if (typed.required) {
+			if (seenOptional) ok = fail$1(ctx, "invalid-option", `${label}: required option "${typed.name}" comes after an optional one. Discord requires all required options first.`);
+		} else seenOptional = true;
+	}
+	return ok;
+}
+function checkOption(ctx, option, label) {
+	let ok = true;
+	if (typeof option.type !== "string" || !OPTION_TYPES.has(option.type)) return fail$1(ctx, "invalid-option", `${label}.type must be one of ${[...OPTION_TYPES].map((t) => `"${t}"`).join(", ")}.`);
+	ok = checkName(ctx, option.name, `${label}.name`, true) && ok;
+	ok = checkDescription(ctx, option.description, `${label}.description`) && ok;
+	if (option.required !== void 0 && typeof option.required !== "boolean") ok = fail$1(ctx, "invalid-option", `${label}.required must be a boolean.`);
+	ok = checkLocalizations(ctx, option.nameLocalizations, `${label}.nameLocalizations`) && ok;
+	ok = checkLocalizations(ctx, option.descriptionLocalizations, `${label}.descriptionLocalizations`) && ok;
+	const type = option.type;
+	const numeric = type === "integer" || type === "number";
+	const choosable = type === "string" || numeric;
+	for (const key of [
+		"choices",
+		"autocomplete",
+		"minLength",
+		"maxLength",
+		"minValue",
+		"maxValue",
+		"channelTypes"
+	]) {
+		if (option[key] === void 0) continue;
+		if (!((key === "choices" || key === "autocomplete") && choosable ? true : (key === "minLength" || key === "maxLength") && type === "string" ? true : (key === "minValue" || key === "maxValue") && numeric ? true : key === "channelTypes" && type === "channel")) ok = fail$1(ctx, "invalid-option", `${label}.${key} is not valid for a "${type}" option.`);
+	}
+	if (option.autocomplete !== void 0 && typeof option.autocomplete !== "boolean") ok = fail$1(ctx, "invalid-option", `${label}.autocomplete must be a boolean.`);
+	if (option.choices !== void 0) {
+		if (option.autocomplete === true) ok = fail$1(ctx, "invalid-option", `${label} cannot have both choices and autocomplete.`);
+		ok = checkChoices(ctx, option.choices, `${label}.choices`, type === "string") && ok;
+	}
+	for (const key of [
+		"minLength",
+		"maxLength",
+		"minValue",
+		"maxValue"
+	]) {
+		const v = option[key];
+		if (v !== void 0 && typeof v !== "number") ok = fail$1(ctx, "invalid-option", `${label}.${key} must be a number.`);
+	}
+	if (typeof option.minLength === "number" && (option.minLength < 0 || option.minLength > 6e3)) ok = fail$1(ctx, "invalid-option", `${label}.minLength must be between 0 and 6000.`);
+	if (typeof option.maxLength === "number" && (option.maxLength < 1 || option.maxLength > 6e3)) ok = fail$1(ctx, "invalid-option", `${label}.maxLength must be between 1 and 6000.`);
+	if (option.channelTypes !== void 0) {
+		if (!Array.isArray(option.channelTypes) || option.channelTypes.some((c) => typeof c !== "number")) ok = fail$1(ctx, "invalid-option", `${label}.channelTypes must be an array of ChannelType values.`);
+	}
+	return ok;
+}
+function checkChoices(ctx, choices, label, isString) {
+	if (!Array.isArray(choices)) return fail$1(ctx, "invalid-option", `${label} must be an array.`);
+	if (choices.length > 25) return fail$1(ctx, "invalid-option", `${label} can have at most 25 entries.`);
+	let ok = true;
+	for (const [index, choice] of choices.entries()) {
+		const at = `${label}[${index}]`;
+		if (!isRecord(choice)) {
+			ok = fail$1(ctx, "invalid-option", `${at} must be an object with name and value.`);
+			continue;
+		}
+		const typed = choice;
+		if (typeof typed.name !== "string" || typed.name.length === 0 || typed.name.length > 100) ok = fail$1(ctx, "invalid-option", `${at}.name must be a string of 1 to 100 characters.`);
+		if (isString) {
+			if (typeof typed.value !== "string" || typed.value.length === 0 || typed.value.length > 100) ok = fail$1(ctx, "invalid-option", `${at}.value must be a string of 1 to 100 characters.`);
+		} else if (typeof typed.value !== "number") ok = fail$1(ctx, "invalid-option", `${at}.value must be a number.`);
+		ok = checkLocalizations(ctx, typed.nameLocalizations, `${at}.nameLocalizations`) && ok;
+	}
+	return ok;
+}
+//#endregion
+//#region src/commands/compile.ts
+const OPTION_TYPE = {
+	string: ApplicationCommandOptionType.String,
+	integer: ApplicationCommandOptionType.Integer,
+	number: ApplicationCommandOptionType.Number,
+	boolean: ApplicationCommandOptionType.Boolean,
+	user: ApplicationCommandOptionType.User,
+	channel: ApplicationCommandOptionType.Channel,
+	role: ApplicationCommandOptionType.Role,
+	mentionable: ApplicationCommandOptionType.Mentionable,
+	attachment: ApplicationCommandOptionType.Attachment
+};
+const COMMAND_TYPE = {
+	chatInput: ApplicationCommandType.ChatInput,
+	user: ApplicationCommandType.User,
+	message: ApplicationCommandType.Message
+};
+/** Compiles the command routes of a route table into Discord command definitions. */
+async function compileCommands(table) {
+	const diagnostics = new Diagnostics();
+	const commands = [];
+	const [loaded, routeMetas] = await Promise.all([loadRoutes(table.routes, diagnostics), loadRouteMetas(table.boundaries, diagnostics)]);
+	const byTopLevel = /* @__PURE__ */ new Map();
+	for (const entry of loaded) {
+		const top = entry.parts[0];
+		byTopLevel.set(top, [...byTopLevel.get(top) ?? [], entry]);
+	}
+	for (const [top, entries] of [...byTopLevel].sort(([a], [b]) => a.localeCompare(b))) {
+		const command = compileTopLevel(top, entries, routeMetas, diagnostics);
+		if (command !== null) commands.push(command);
+	}
+	for (const entry of routeMetas.values()) if (!entry.used) diagnostics.warn("unused-route-meta", "This route.ts does not describe a command with subcommands and has no effect.", { file: entry.boundary.file });
+	detectDuplicateNames(commands, diagnostics);
+	commands.sort((a, b) => a.type - b.type || a.name.localeCompare(b.name));
+	return {
+		commands,
+		diagnostics
+	};
+}
+async function loadRoutes(routes, diagnostics) {
+	const commandRoutes = routes.filter((r) => r.kind === "command");
+	return (await Promise.all(commandRoutes.map(async (route) => {
+		const module = await importOrReport(route.file, diagnostics);
+		if (module === null) return null;
+		if (!checkDeclaredRoute(module, route, diagnostics)) return null;
+		const meta = validateCommandMeta(module.meta, route.file, diagnostics);
+		if (meta === null) return null;
+		return {
+			route,
+			parts: route.path.split("/"),
+			meta
+		};
+	}))).filter((r) => r !== null);
+}
+async function loadRouteMetas(boundaries, diagnostics) {
+	const map = /* @__PURE__ */ new Map();
+	const relevant = boundaries.filter((b) => b.kind === "route" && b.category === "command");
+	await Promise.all(relevant.map(async (boundary) => {
+		const key = boundary.segments.filter((s) => s.type !== "group").map(formatSegment).join("/");
+		if (key === "") {
+			diagnostics.error("route-meta-without-path", "route.ts must live inside a command directory. At the commands root it describes nothing.", { file: boundary.file });
+			return;
+		}
+		const module = await importOrReport(boundary.file, diagnostics);
+		if (module === null) return;
+		const meta = validateCommandRouteMeta(module.meta, boundary.file, diagnostics);
+		if (meta === null) return;
+		map.set(key, {
+			boundary,
+			meta,
+			used: false
+		});
+	}));
+	return map;
+}
+async function importOrReport(file, diagnostics) {
+	try {
+		return await loadModule(file);
+	} catch (error) {
+		diagnostics.error("module-load-failed", `Could not import this file: ${error instanceof Error ? error.message : String(error)}`, { file });
+		return null;
+	}
+}
+function compileTopLevel(top, entries, routeMetas, diagnostics) {
+	const direct = entries.filter((e) => e.parts.length === 1);
+	const nested = entries.filter((e) => e.parts.length > 1);
+	if (direct.length > 0 && nested.length > 0) {
+		for (const entry of nested) diagnostics.error("mixed-command-and-subcommands", `"${top}" has its own command.ts and also subcommands. Discord does not allow both. Either remove ${relative$1(direct[0]?.route.file)} or move this handler out of ${top}/.`, {
+			file: entry.route.file,
+			route: entry.route.id
+		});
+		return null;
+	}
+	const tooDeep = nested.filter((e) => e.parts.length > 3);
+	if (tooDeep.length > 0) {
+		for (const entry of tooDeep) diagnostics.error("command-too-deep", `Commands can nest at most three levels (command / group / subcommand). "${entry.route.path}" has ${entry.parts.length}.`, {
+			file: entry.route.file,
+			route: entry.route.id
+		});
+		return null;
+	}
+	if (direct.length === 1) return compilePlainCommand(direct[0], diagnostics);
+	return compileParentCommand(top, nested, routeMetas, diagnostics);
+}
+function compilePlainCommand(entry, diagnostics) {
+	const { route, meta } = entry;
+	const name = meta.name ?? route.path;
+	const type = COMMAND_TYPE[meta.type ?? "chatInput"];
+	if (type === ApplicationCommandType.ChatInput && !isValidChatInputName(name)) {
+		reportDirectoryName(route, name, diagnostics);
+		return null;
+	}
+	const payload = {
+		name,
+		type,
+		...localizations(meta),
+		...topLevelPayload(meta)
+	};
+	if (type === ApplicationCommandType.ChatInput) {
+		payload.description = meta.description;
+		if (meta.options !== void 0) payload.options = meta.options.map(optionPayload);
+	}
+	return {
+		name,
+		type,
+		handlers: { "": route },
+		payload: compact(payload),
+		files: [route.file]
+	};
+}
+function compileParentCommand(top, nested, routeMetas, diagnostics) {
+	const parent = requireRouteMeta(top, nested[0], routeMetas, diagnostics);
+	if (parent === null) return null;
+	const name = parent.meta.name ?? top;
+	if (!isValidChatInputName(name)) {
+		reportDirectoryName(nested[0]?.route, name, diagnostics, parent.boundary.file);
+		return null;
+	}
+	const handlers = {};
+	const files = [parent.boundary.file];
+	const options = [];
+	let ok = true;
+	const bySecond = /* @__PURE__ */ new Map();
+	for (const entry of nested) {
+		const second = entry.parts[1];
+		bySecond.set(second, [...bySecond.get(second) ?? [], entry]);
+	}
+	if (bySecond.size > 25) {
+		diagnostics.error("too-many-subcommands", `"${top}" has ${bySecond.size} subcommands and groups. Discord allows at most 25.`, { file: parent.boundary.file });
+		ok = false;
+	}
+	for (const [second, entries] of [...bySecond].sort(([a], [b]) => a.localeCompare(b))) {
+		const subs = entries.filter((e) => e.parts.length === 2);
+		const grouped = entries.filter((e) => e.parts.length === 3);
+		if (subs.length > 0 && grouped.length > 0) {
+			for (const entry of grouped) diagnostics.error("mixed-subcommand-and-group", `"${top}/${second}" is both a subcommand (${relative$1(subs[0]?.route.file)}) and a subcommand group. Discord does not allow both.`, {
+				file: entry.route.file,
+				route: entry.route.id
+			});
+			ok = false;
+			continue;
+		}
+		if (subs.length === 1) {
+			const sub = compileSubcommand(subs[0], diagnostics);
+			if (sub === null) {
+				ok = false;
+				continue;
+			}
+			handlers[sub.name] = sub.route;
+			files.push(sub.route.file);
+			options.push(sub.payload);
+			continue;
+		}
+		const groupKey = `${top}/${second}`;
+		const group = requireRouteMeta(groupKey, grouped[0], routeMetas, diagnostics);
+		if (group === null) {
+			ok = false;
+			continue;
+		}
+		const groupName = group.meta.name ?? second;
+		if (!isValidChatInputName(groupName)) {
+			reportDirectoryName(grouped[0]?.route, groupName, diagnostics, group.boundary.file);
+			ok = false;
+			continue;
+		}
+		const extra = topLevelKeysUsed(group.meta);
+		if (extra.length > 0) {
+			diagnostics.error("top-level-field-on-group", `${extra.map((k) => `meta.${k}`).join(", ")} only applies to top-level commands. Move it to ${relative$1(parent.boundary.file)}.`, { file: group.boundary.file });
+			ok = false;
+			continue;
+		}
+		if (grouped.length > 25) {
+			diagnostics.error("too-many-subcommands", `Group "${groupKey}" has ${grouped.length} subcommands. Discord allows at most 25.`, { file: group.boundary.file });
+			ok = false;
+			continue;
+		}
+		files.push(group.boundary.file);
+		const groupOptions = [];
+		for (const entry of grouped.sort((a, b) => a.route.path.localeCompare(b.route.path))) {
+			const sub = compileSubcommand(entry, diagnostics);
+			if (sub === null) {
+				ok = false;
+				continue;
+			}
+			handlers[`${groupName}/${sub.name}`] = sub.route;
+			files.push(sub.route.file);
+			groupOptions.push(sub.payload);
+		}
+		options.push(compact({
+			type: ApplicationCommandOptionType.SubcommandGroup,
+			name: groupName,
+			description: group.meta.description,
+			...localizations(group.meta),
+			options: groupOptions
+		}));
+	}
+	if (!ok) return null;
+	const payload = compact({
+		name,
+		type: ApplicationCommandType.ChatInput,
+		description: parent.meta.description,
+		...localizations(parent.meta),
+		...topLevelPayload(parent.meta),
+		options
+	});
+	return {
+		name,
+		type: ApplicationCommandType.ChatInput,
+		handlers,
+		payload,
+		files
+	};
+}
+function compileSubcommand(entry, diagnostics) {
+	const { route, meta } = entry;
+	if (meta.type !== void 0 && meta.type !== "chatInput") {
+		diagnostics.error("context-menu-nested", `Context menu commands cannot be subcommands. Move ${relative$1(route.file)} to the top of commands/.`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	const extra = topLevelKeysUsed(meta);
+	if (extra.length > 0) {
+		diagnostics.error("top-level-field-on-subcommand", `${extra.map((k) => `meta.${k}`).join(", ")} only applies to top-level commands. Move it to the route.ts of "${entry.parts[0]}".`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	const name = meta.name ?? entry.parts.at(-1);
+	if (!isValidChatInputName(name)) {
+		reportDirectoryName(route, name, diagnostics);
+		return null;
+	}
+	return {
+		name,
+		route,
+		payload: compact({
+			type: ApplicationCommandOptionType.Subcommand,
+			name,
+			description: meta.description,
+			...localizations(meta),
+			options: meta.options?.map(optionPayload)
+		})
+	};
+}
+function requireRouteMeta(key, child, routeMetas, diagnostics) {
+	const entry = routeMetas.get(key);
+	if (entry !== void 0) {
+		entry.used = true;
+		return entry;
+	}
+	const dir = directoryForPath(child.route, key.split("/").length);
+	diagnostics.error("missing-route-meta", `"${key}" has subcommands but no route.ts. Discord needs a description for it. Add ${path.join(dir, "route.ts")} exporting \`meta\` with a description.`, {
+		file: child.route.file,
+		route: child.route.id
+	});
+	return null;
+}
+/** Directory of the Nth non-group segment of a route, walking up from the handler file. */
+function directoryForPath(route, depth) {
+	let seen = 0;
+	let index = route.segments.length;
+	for (let i = 0; i < route.segments.length; i++) {
+		if (route.segments[i]?.type === "group") continue;
+		seen++;
+		if (seen === depth) {
+			index = i;
+			break;
+		}
+	}
+	const levelsUp = route.segments.length - index - 1;
+	let dir = path.dirname(route.file);
+	for (let i = 0; i < levelsUp; i++) dir = path.dirname(dir);
+	return dir;
+}
+function isValidChatInputName(name) {
+	return /^[-_\p{L}\p{N}\p{sc=Deva}\p{sc=Thai}]{1,32}$/u.test(name) && name === name.toLowerCase();
+}
+function reportDirectoryName(route, name, diagnostics, file) {
+	diagnostics.error("invalid-name", `"${name}" is not a valid chat input command name. Discord requires lowercase letters, digits, hyphens, and underscores, 1 to 32 characters. Rename the directory or set \`meta.name\`.`, {
+		file: file ?? route.file,
+		route: route.id
+	});
+}
+function detectDuplicateNames(commands, diagnostics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const command of commands) {
+		const key = `${command.type}:${command.name}`;
+		const existing = seen.get(key);
+		if (existing === void 0) {
+			seen.set(key, command);
+			continue;
+		}
+		diagnostics.error("duplicate-command-name", `Two commands register as "${command.name}": ${relative$1(existing.files[0])} and ${relative$1(command.files[0])}. Check \`meta.name\` overrides.`, { file: command.files[0] });
+	}
+}
+function optionPayload(option) {
+	const base = {
+		type: OPTION_TYPE[option.type],
+		name: option.name,
+		description: option.description,
+		required: option.required,
+		...localizations(option)
+	};
+	switch (option.type) {
+		case "string":
+			base.choices = option.choices?.map(choicePayload);
+			base.autocomplete = option.autocomplete;
+			base.min_length = option.minLength;
+			base.max_length = option.maxLength;
+			break;
+		case "integer":
+		case "number":
+			base.choices = option.choices?.map(choicePayload);
+			base.autocomplete = option.autocomplete;
+			base.min_value = option.minValue;
+			base.max_value = option.maxValue;
+			break;
+		case "channel": base.channel_types = option.channelTypes;
+	}
+	return compact(base);
+}
+function choicePayload(choice) {
+	return compact({
+		name: choice.name,
+		value: choice.value,
+		name_localizations: choice.nameLocalizations
+	});
+}
+function localizations(meta) {
+	return {
+		name_localizations: meta.nameLocalizations,
+		description_localizations: meta.descriptionLocalizations
+	};
+}
+function topLevelPayload(meta) {
+	const perms = meta.defaultMemberPermissions;
+	return {
+		default_member_permissions: perms === void 0 ? void 0 : perms === null ? null : String(perms),
+		nsfw: meta.nsfw,
+		contexts: meta.contexts,
+		integration_types: meta.integrationTypes
+	};
+}
+function compact(object) {
+	const out = {};
+	for (const [key, value] of Object.entries(object)) if (value !== void 0) out[key] = value;
+	return out;
+}
+function relative$1(file) {
+	return file === void 0 ? "?" : path.relative(process.cwd(), file).split(path.sep).join("/");
+}
+//#endregion
+//#region src/events/compile.ts
+const EVENT_NAMES = new Set(Object.values(Events));
+/** Renamed events whose old name still shows up in older discord.js code. */
+const RENAMED = { ready: Events.ClientReady };
+/** Groups event routes by discord.js event and validates their names and `meta`. */
+async function compileEvents(table) {
+	const diagnostics = new Diagnostics();
+	const routes = table.routes.filter((r) => r.kind === "event");
+	const loaded = await Promise.all(routes.map((route) => loadHandler(route, diagnostics)));
+	const byName = /* @__PURE__ */ new Map();
+	for (const handler of loaded) {
+		if (handler === null) continue;
+		byName.set(handler.name, [...byName.get(handler.name) ?? [], handler]);
+	}
+	const events = [];
+	for (const [name, handlers] of [...byName].sort(([a], [b]) => a.localeCompare(b))) {
+		const modes = new Set(handlers.map((h) => h.mode).filter((m) => m !== void 0));
+		if (modes.size > 1) {
+			for (const handler of handlers) {
+				if (handler.mode === void 0) continue;
+				diagnostics.error("event-mode-conflict", `Handlers of "${name}" disagree on \`meta.mode\`: ${[...modes].map((m) => `"${m}"`).join(" and ")}. All handlers of one event share a mode; set it on one file or make them agree.`, {
+					file: handler.route.file,
+					route: handler.route.id
+				});
+			}
+			continue;
+		}
+		handlers.sort((a, b) => a.order - b.order || a.route.id.localeCompare(b.route.id));
+		events.push({
+			name,
+			mode: modes.values().next().value ?? "sequential",
+			handlers: handlers.map(({ route, once, order }) => ({
+				route,
+				once,
+				order
+			}))
+		});
+	}
+	return {
+		events,
+		diagnostics
+	};
+}
+async function loadHandler(route, diagnostics) {
+	const name = eventName(route, diagnostics);
+	if (name === null) return null;
+	let module;
+	try {
+		module = await loadModule(route.file);
+	} catch (error) {
+		diagnostics.error("module-load-failed", `Could not import this file: ${error instanceof Error ? error.message : String(error)}`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	if (!checkDeclaredRoute(module, route, diagnostics, name)) return null;
+	const meta = validateEventMeta(module.meta, route, diagnostics);
+	if (meta === null) return null;
+	return {
+		route,
+		name,
+		once: meta.once ?? false,
+		order: meta.order ?? 0,
+		mode: meta.mode
+	};
+}
+function eventName(route, diagnostics) {
+	const statics = route.segments.filter((s) => s.type !== "group");
+	const first = statics[0];
+	if (first === void 0 || first.type !== "static") return null;
+	if (statics.length > 1) {
+		diagnostics.error("event-nested-path", `Event handlers live directly under events/<eventName>/. "${route.path}" adds ${statics.slice(1).map(formatSegment).join("/")} below the event name. Use a route group like (${statics[1]?.name}) to keep several handlers apart.`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	const name = first.name;
+	if (EVENT_NAMES.has(name)) return name;
+	const renamed = RENAMED[name];
+	const hint = renamed !== void 0 ? `discord.js renamed it to "${renamed}".` : closest(name) ? `Did you mean "${closest(name)}"?` : "Event names are the lowerCamelCase values of discord.js's `Events` enum.";
+	diagnostics.error("unknown-event", `"${name}" is not a discord.js event. ${hint} Rename the directory.`, {
+		file: route.file,
+		route: route.id
+	});
+	return null;
+}
+function validateEventMeta(value, route, diagnostics) {
+	if (value === void 0) return {};
+	const fail = (message) => {
+		diagnostics.error("invalid-meta", message, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	};
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("`meta` must be an object.");
+	const meta = value;
+	if (meta.once !== void 0 && typeof meta.once !== "boolean") return fail("`meta.once` must be a boolean.");
+	if (meta.order !== void 0 && (typeof meta.order !== "number" || !Number.isFinite(meta.order))) return fail("`meta.order` must be a finite number.");
+	if (meta.mode !== void 0 && meta.mode !== "sequential" && meta.mode !== "concurrent") return fail("`meta.mode` must be \"sequential\" or \"concurrent\".");
+	return meta;
+}
+/** Case-insensitive match against known events, to catch `GuildMemberAdd` or `guildmemberadd`. */
+function closest(name) {
+	const lower = name.toLowerCase();
+	for (const known of EVENT_NAMES) if (known.toLowerCase() === lower) return known;
+	return null;
+}
+//#endregion
+//#region src/compiler/chains.ts
+/**
+* Picks the boundaries that apply to a route: everything at the app root, plus every
+* boundary in the route's category whose directory is an ancestor of (or equal to) the
+* route's directory. Route groups count as directories here, so a middleware inside
+* `(admin)/` covers only that group.
+*/
+function resolveChains(route, boundaries) {
+	const applicable = boundaries.filter((b) => (b.category === null || b.category === route.category) && isPrefix(b.segments, route.segments));
+	const byDepth = (a, b) => depth(a) - depth(b);
+	return {
+		middleware: route.category === "event" ? [] : applicable.filter((b) => b.kind === "middleware").sort(byDepth).map((b) => b.file),
+		errors: applicable.filter((b) => b.kind === "error").sort(byDepth).reverse().map((b) => b.file)
+	};
+}
+/** Root boundaries sit above the category directory, so they sort before category-level ones. */
+function depth(boundary) {
+	return boundary.category === null ? -1 : boundary.segments.length;
+}
+function isPrefix(prefix, segments) {
+	if (prefix.length > segments.length) return false;
+	return prefix.every((s, i) => s.type === segments[i]?.type && s.name === segments[i]?.name);
+}
+//#endregion
+//#region src/compiler/discover.ts
+const RESERVED = {
+	command: "command",
+	autocomplete: "autocomplete",
+	button: "button",
+	select: "select",
+	modal: "modal",
+	event: "event",
+	middleware: "middleware",
+	error: "error",
+	route: "route"
+};
+const EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".js",
+	".mts",
+	".mjs"
+]);
+/** The route file kind a filename denotes, or `undefined` for ordinary application code. */
+function reservedKind(fileName) {
+	const ext = path.extname(fileName);
+	if (!EXTENSIONS.has(ext)) return void 0;
+	const base = fileName.slice(0, -ext.length);
+	if (base.endsWith(".test") || base.endsWith(".spec")) return void 0;
+	return RESERVED[base];
+}
+/**
+* Walks the app directory and returns every reserved file, sorted by path.
+* Anything that is not a reserved filename is ordinary application code and is skipped.
+*/
+function discover(appDir) {
+	const files = [];
+	walk(path.resolve(appDir), [], files);
+	files.sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0);
+	return files;
+}
+function walk(dir, dirs, out) {
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			walk(full, [...dirs, entry.name], out);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		const kind = reservedKind(entry.name);
+		if (kind === void 0) continue;
+		out.push({
+			kind,
+			file: full,
+			dirs
+		});
+	}
+}
+//#endregion
+//#region src/compiler/identity.ts
+/**
+* Short, stable identifier used inside custom IDs.
+* First 6 base36 characters of the SHA-256 of the canonical route identity.
+*/
+function shortId(routeId) {
+	const hex = createHash("sha256").update(routeId).digest("hex").slice(0, 16);
+	return BigInt(`0x${hex}`).toString(36).padStart(6, "0").slice(0, 6);
+}
+//#endregion
+//#region src/compiler/routes.ts
+const CATEGORY_DIRS = {
+	commands: "command",
+	components: "component",
+	events: "event"
+};
+const HANDLER_KINDS = {
+	command: /* @__PURE__ */ new Set(["command", "autocomplete"]),
+	component: /* @__PURE__ */ new Set([
+		"button",
+		"select",
+		"modal"
+	]),
+	event: /* @__PURE__ */ new Set(["event"])
+};
+const BOUNDARY_KINDS = /* @__PURE__ */ new Set([
+	"middleware",
+	"error",
+	"route"
+]);
+/** Discovers the app directory and builds the route table. */
+function buildRouteTable(appDir) {
+	return buildRouteTableFromFiles(discover(appDir));
+}
+function buildRouteTableFromFiles(files) {
+	const diagnostics = new Diagnostics();
+	const routes = [];
+	const boundaries = [];
+	for (const source of files) {
+		const [categoryDir, ...rest] = source.dirs;
+		if (categoryDir === void 0) {
+			if (source.kind === "middleware" || source.kind === "error") boundaries.push({
+				kind: source.kind,
+				category: null,
+				segments: [],
+				file: source.file
+			});
+			else diagnostics.error("file-outside-category", `${path.basename(source.file)} must live under commands/, components/, or events/. Only middleware and error files may sit at the app root.`, { file: source.file });
+			continue;
+		}
+		const category = CATEGORY_DIRS[categoryDir];
+		if (category === void 0) {
+			diagnostics.error("unknown-category", `"${categoryDir}/" is not a route area. Reserved files must live under commands/, components/, or events/.`, { file: source.file });
+			continue;
+		}
+		const segments = parseSegments(rest, source, diagnostics);
+		if (segments === null) continue;
+		if (BOUNDARY_KINDS.has(source.kind)) {
+			boundaries.push({
+				kind: source.kind,
+				category,
+				segments,
+				file: source.file
+			});
+			continue;
+		}
+		if (!HANDLER_KINDS[category].has(source.kind)) {
+			diagnostics.error("file-in-wrong-category", `${path.basename(source.file)} does not belong under ${categoryDir}/. Expected one of: ${[...HANDLER_KINDS[category]].map((k) => `${k}.ts`).join(", ")}.`, { file: source.file });
+			continue;
+		}
+		const route = makeRoute(category, source.kind, segments, source.file, diagnostics);
+		if (route !== null) routes.push(route);
+	}
+	detectDuplicates(routes, diagnostics);
+	return {
+		routes,
+		boundaries,
+		diagnostics
+	};
+}
+function parseSegments(dirs, source, diagnostics) {
+	const segments = [];
+	for (const dir of dirs) {
+		const result = parseSegment(dir);
+		if (!result.ok) {
+			diagnostics.error("invalid-segment", result.reason, { file: source.file });
+			return null;
+		}
+		segments.push(result.segment);
+	}
+	return segments;
+}
+function makeRoute(category, kind, segments, file, diagnostics) {
+	if (segments.length === 0) {
+		diagnostics.error("route-without-path", `${path.basename(file)} needs a named directory. Files directly inside ${category}s/ have no route path.`, { file });
+		return null;
+	}
+	const params = [];
+	for (const [index, segment] of segments.entries()) if (segment.type === "dynamic" || segment.type === "catchAll") {
+		if (category !== "component") {
+			diagnostics.error("dynamic-segment-not-allowed", `${formatSegment(segment)} is a dynamic segment, but ${category} routes cannot carry parameters. Only component routes can.`, { file });
+			return null;
+		}
+		if (params.includes(segment.name)) {
+			diagnostics.error("duplicate-param", `Parameter "${segment.name}" appears twice in the same route.`, { file });
+			return null;
+		}
+		if (segment.type === "catchAll" && index !== segments.length - 1) {
+			diagnostics.error("catch-all-not-last", `${formatSegment(segment)} must be the last segment of the route.`, { file });
+			return null;
+		}
+		params.push(segment.name);
+	}
+	const routePath = segments.filter((segment) => segment.type !== "group" || category === "event").map(formatSegment).join("/");
+	if (routePath === "") {
+		diagnostics.error("route-without-path", `${path.basename(file)} sits only inside route groups. Groups do not contribute to the route, so this route has no path.`, { file });
+		return null;
+	}
+	const id = `${category}:${routePath}`;
+	return {
+		id,
+		shortId: shortId(id),
+		category,
+		kind,
+		path: routePath,
+		segments,
+		params,
+		file
+	};
+}
+/**
+* A command and its autocomplete share an ID. A component route has exactly one handler of any
+* kind, since the handler's types come from the path alone.
+*/
+function detectDuplicates(routes, diagnostics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const key = route.category === "component" ? route.id : `${route.id}#${route.kind}`;
+		const existing = seen.get(key);
+		if (existing === void 0) {
+			seen.set(key, route);
+			continue;
+		}
+		diagnostics.error("duplicate-route", existing.kind === route.kind ? `Route ${route.id} is defined twice: ${existing.file} and ${route.file}. Route groups do not make paths distinct.` : `Route ${route.id} has two handlers: ${existing.file} and ${route.file}. A component route takes one button.ts, select.ts, or modal.ts. Move one into its own directory.`, {
+			file: route.file,
+			route: route.id
+		});
+	}
+}
+//#endregion
+//#region src/compiler/graph.ts
+/** Runs the whole compiler pipeline on an app directory. */
+async function buildGraph(appDir) {
+	const absolute = path.resolve(appDir);
+	const table = buildRouteTable(absolute);
+	const diagnostics = new Diagnostics();
+	diagnostics.items.push(...table.diagnostics.items);
+	const [commands, components, events] = await Promise.all([
+		compileCommands(table),
+		compileComponents(table),
+		compileEvents(table)
+	]);
+	const autocomplete = await compileAutocomplete(table, commands.commands);
+	for (const stage of [
+		commands,
+		components,
+		events,
+		autocomplete
+	]) diagnostics.items.push(...stage.diagnostics.items);
+	const chains = /* @__PURE__ */ new Map();
+	for (const route of table.routes) chains.set(route.file, resolveChains(route, table.boundaries));
+	return {
+		appDir: absolute,
+		routes: table.routes,
+		boundaries: table.boundaries,
+		chains,
+		commands: commands.commands,
+		components: components.routes,
+		events: events.events,
+		autocomplete: autocomplete.autocomplete,
+		plugins: /* @__PURE__ */ new Map(),
+		diagnostics
+	};
+}
+//#endregion
+//#region src/cli/ui.ts
+/**
+* Terminal formatting for the CLI and dev server. Colors are off until the bin turns them on
+* for a TTY, so tests and piped output see plain text with the same glyphs.
+*/
+let colors = false;
+function setColors(enabled) {
+	colors = enabled;
+}
+const paint = (style) => (text) => colors ? styleText(style, text) : text;
+const c = {
+	bold: paint("bold"),
+	dim: paint("dim"),
+	red: paint("red"),
+	green: paint("green"),
+	yellow: paint("yellow"),
+	cyan: paint("cyan"),
+	magenta: paint("magenta"),
+	underline: paint("underline")
+};
+const ok = (text) => `${c.green("✔")} ${text}`;
+const fail = (text) => `${c.red("✖")} ${text}`;
+const warn = (text) => `${c.yellow("▲")} ${text}`;
+const info$1 = (text) => `${c.cyan("›")} ${text}`;
+const link = (url) => c.underline(c.cyan(url));
+const PORTAL_URL = "https://discord.com/developers/applications";
+function indent(lines, by = 2) {
+	return lines.map((line) => line === "" ? "" : `${" ".repeat(by)}${line}`);
+}
+/** A headline followed by indented detail lines, as one multi-line string. */
+function block(head, details = []) {
+	return details.length === 0 ? head : [
+		head,
+		"",
+		...indent(details)
+	].join("\n");
+}
+/** Two-column rows with dim keys, aligned on the widest key. */
+function table(rows) {
+	const width = Math.max(0, ...rows.map(([key]) => key.length));
+	return rows.map(([key, value]) => `${c.dim(key.padEnd(width))}  ${value}`);
+}
+/** `HH:MM:SS`, dimmed. Prefix for dev server lines that happen while it runs. */
+function stamp() {
+	return c.dim((/* @__PURE__ */ new Date()).toTimeString().slice(0, 8));
+}
+/** How to supply a credential, shared by every command that needs one. */
+function credentialHint(kind, configName) {
+	const variable = kind === "token" ? "DISCORD_TOKEN" : "DISCORD_APPLICATION_ID";
+	const where = kind === "token" ? "your application → Bot → Reset Token" : "your application → General Information → Application ID";
+	return [
+		`Put ${c.bold(`${variable}=...`)} in ${c.bold(".env")} next to ${configName}, or export it.`,
+		`The config reads it with ${c.bold(`${kind}: process.env.${variable}`)}; without that line the`,
+		"variable is used directly.",
+		`Get it from the Developer Portal under ${where}:`,
+		link(PORTAL_URL)
+	];
+}
+//#endregion
+//#region src/cli/compile.ts
+/**
+* Compiles the app, runs plugin transforms, and prints every diagnostic. Returns `null` when
+* any is an error.
+*/
+async function compileProject(project, io) {
+	const graph = await buildGraph(project.appDir);
+	graph.diagnostics.items.push(...checkIntents(graph.events, project.config.intents, path.basename(project.configFile)));
+	if (!graph.diagnostics.hasErrors) await applyPlugins(graph, project.config.plugins ?? []);
+	for (const diagnostic of graph.diagnostics.items) io.err(formatDiagnostic(diagnostic, project.root));
+	if (graph.diagnostics.hasErrors) {
+		const errors = graph.diagnostics.items.filter((d) => d.severity === "error").length;
+		io.err(fail(`${errors} error${errors === 1 ? "" : "s"}. Fix the files above and run again.`));
+		return null;
+	}
+	return graph;
+}
+/**
+* One diagnostic as a headline and an indented message:
+*
+*     ✖ error  invalid-name  app/commands/Bad Name/command.ts
+*       Command names must be lowercase ...
+*/
+function formatDiagnostic(diagnostic, root) {
+	const mark = diagnostic.severity === "error" ? fail(c.red("error")) : warn(c.yellow("warning"));
+	const where = diagnostic.file === void 0 ? "" : `  ${relative(root, diagnostic.file)}`;
+	return [`${mark}  ${c.dim(diagnostic.code)}${where}`, ...indent([diagnostic.message])].join("\n");
+}
+function relative(root, file) {
+	return path.relative(root, file).split(path.sep).join("/");
+}
+function summary(graph) {
+	const n = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+	return [
+		n(graph.commands.length, "command"),
+		n(graph.components.length, "component route"),
+		n(graph.events.length, "event")
+	].join(", ");
+}
+/**
+* A problem the user can fix. Printed without a stack trace: the message as the headline,
+* then `details` indented under it (what went wrong in full, and what to do about it).
+*/
+var CliError = class extends Error {
+	code;
+	details;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "CliError";
+		this.code = options.code ?? 1;
+		this.details = options.details ?? [];
+	}
+};
+//#endregion
+//#region src/cli/project.ts
+const CONFIG_FILES = ["nectar.config.ts", "nectar.config.js"];
+/** Finds and validates `nectar.config.ts` in `cwd`. */
+async function loadProject(cwd, env) {
+	const configFile = CONFIG_FILES.map((name) => path.join(cwd, name)).find((f) => existsSync(f));
+	if (configFile === void 0) throw new CliError(`No ${CONFIG_FILES[0]} in ${cwd}.`, { details: ["Run nectar from the directory that holds your config file.", `Starting fresh? ${c.bold("npm create @nectar-js")} sets up a project.`] });
+	const name = path.basename(configFile);
+	let loaded;
+	try {
+		const module = await loadModule(configFile);
+		loaded = validateConfig(module.default, name);
+	} catch (error) {
+		if (error instanceof ConfigError) throw new CliError(`${name} is not valid.`, { details: [error.detail] });
+		throw new CliError(`Could not load ${name}.`, { details: [describe(error)] });
+	}
+	const projectEnv = loaded.env ?? envFrom(env.NODE_ENV);
+	const config = configFor(loaded, projectEnv);
+	const root = path.dirname(configFile);
+	const appDir = path.resolve(root, config.appDir ?? "app");
+	if (!existsSync(appDir)) throw new CliError(`App directory ${path.relative(root, appDir) || "."}/ does not exist.`, { details: [`Create it, or point ${c.bold("appDir")} in ${name} at the right place.`] });
+	return {
+		root,
+		configFile,
+		config,
+		appDir,
+		outDir: path.resolve(root, config.outDir ?? ".nectar"),
+		env: projectEnv
+	};
+}
+function envFrom(value) {
+	return value === "production" || value === "test" ? value : "development";
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/cli/build.ts
+/** `.mjs` so it loads as ESM whatever the project's `package.json` says, and PM2 imports it. */
+const START_FILE = "start.mjs";
+/** `nectar build`: compile, then write the manifest, generated types, and `start.mjs` into `outDir`. */
+async function build(io) {
+	const project = await loadProject(io.cwd, io.env);
+	const graph = await compileProject(project, io);
+	if (graph === null) return 1;
+	const manifestFile = writeManifest(toManifest(graph, project.outDir), project.outDir);
+	const typesFile = writeTypes(graph, project.outDir, project.config.plugins);
+	const startFile = writeStart(project);
+	io.out(ok(`Built ${summary(graph)}.`));
+	for (const file of [
+		manifestFile,
+		typesFile,
+		startFile
+	]) io.out(`  ${c.dim(relative(project.root, file))}`);
+	return 0;
+}
+/**
+* `node .nectar/start.mjs` does what `nectar start` does, from any working directory. It is the
+* file to hand a ShardingManager or cluster manager: each shard loads the manifest itself and
+* none of them registers commands.
+*/
+function writeStart(project) {
+	const root = path.relative(project.outDir, project.root).split(path.sep).join("/");
+	const file = path.join(project.outDir, START_FILE);
+	writeFileSync(file, [
+		"// Written by nectar build. Runs the bot from this build, like `nectar start`.",
+		"import { start } from \"@nectar-js/nectar/start\";",
+		"",
+		`await start(new URL(${JSON.stringify(`${root || "."}/`)}, import.meta.url));`,
+		""
+	].join("\n"));
+	return file;
+}
+/** `nectar check`: compile and report, writing nothing. */
+async function check(io) {
+	const project = await loadProject(io.cwd, io.env);
+	const graph = await compileProject(project, io);
+	if (graph === null) return 1;
+	const warnings = graph.diagnostics.items.length;
+	io.out(warnings === 0 ? ok(`No problems. ${summary(graph)} in ${path.relative(project.root, project.appDir) || "."}/.`) : warn(`${warnings} warning${warnings === 1 ? "" : "s"}, no errors.`));
+	return 0;
+}
+//#endregion
+//#region src/cli/routes.ts
+/** `nectar routes`: print the app tree with what every file and directory means. */
+async function routes(io) {
+	const project = await loadProject(io.cwd, io.env);
+	const graph = await compileProject(project, io);
+	if (graph === null) return 1;
+	io.out(renderRoutes(graph, project.root));
+	return 0;
+}
+/**
+* A directory tree of the app. Handler files annotate their directory; middleware, error, and
+* route files appear as leaves so the scope of each is where it sits in the tree.
+*/
+function renderRoutes(graph, root) {
+	const tree = {
+		name: relative(root, graph.appDir) || ".",
+		notes: [],
+		children: /* @__PURE__ */ new Map(),
+		file: false
+	};
+	const nodeFor = (file, asFile) => {
+		const parts = relative(graph.appDir, asFile ? file : path.dirname(file)).split("/");
+		let node = tree;
+		for (const part of parts.filter((p) => p !== "" && p !== ".")) {
+			let child = node.children.get(part);
+			if (child === void 0) {
+				child = {
+					name: part,
+					notes: [],
+					children: /* @__PURE__ */ new Map(),
+					file: false
+				};
+				node.children.set(part, child);
+			}
+			node = child;
+		}
+		node.file = asFile;
+		return node;
+	};
+	const annotate = (route, note) => nodeFor(route.file, false).notes.push(note);
+	for (const command of graph.commands) for (const [position, route] of Object.entries(command.handlers)) annotate(route, commandLabel(command.type, command.name, position));
+	for (const entry of graph.autocomplete) annotate(entry.route, `autocomplete: ${entry.options.join(", ")}`);
+	for (const route of graph.components) annotate(route, componentLabel(route));
+	for (const event of graph.events) for (const handler of event.handlers) {
+		const flags = [handler.once ? "once" : null, event.handlers.length > 1 ? event.mode : null];
+		annotate(handler.route, `event ${event.name}${suffix(flags)}`);
+	}
+	for (const boundary of graph.boundaries) {
+		const node = nodeFor(boundary.file, true);
+		if (boundary.kind === "route") {
+			node.notes.push("command metadata");
+			continue;
+		}
+		const covered = graph.routes.filter((r) => {
+			const chain = graph.chains.get(r.file);
+			return (boundary.kind === "middleware" ? chain?.middleware : chain?.errors)?.includes(boundary.file);
+		}).length;
+		node.notes.push(`${boundary.kind === "middleware" ? "middleware" : "error boundary"} for ${covered} route${covered === 1 ? "" : "s"}`);
+	}
+	const lines = [];
+	print(tree, "", true, true, lines);
+	const width = Math.max(...lines.map(([left]) => left.length));
+	return lines.map(([left, right]) => right === "" ? left : `${left.padEnd(width)}  ${c.dim(right)}`).join("\n");
+}
+function print(node, prefix, last, isRoot, out) {
+	const branch = isRoot ? "" : last ? "└── " : "├── ";
+	out.push([`${prefix}${branch}${node.name}`, node.notes.join(" · ")]);
+	const children = [...node.children.values()].sort((a, b) => Number(b.file) - Number(a.file) || a.name.localeCompare(b.name));
+	const childPrefix = isRoot ? "" : `${prefix}${last ? "    " : "│   "}`;
+	children.forEach((child, i) => {
+		print(child, childPrefix, i === children.length - 1, false, out);
+	});
+}
+function commandLabel(type, name, position) {
+	if (type === ApplicationCommandType.User) return `user context menu "${name}"`;
+	if (type === ApplicationCommandType.Message) return `message context menu "${name}"`;
+	return `/${[name, ...position.split("/").filter((p) => p !== "")].join(" ")}`;
+}
+function componentLabel(route) {
+	return `${route.kind === "select" ? `select (${route.selectKind})` : route.kind} ${[`n:${route.shortId}`, ...route.params.map((p) => p === route.catchAll ? `<...${p}>` : `<${p}>`)].join(":")}`;
+}
+function suffix(flags) {
+	const present = flags.filter((f) => f !== null);
+	return present.length === 0 ? "" : ` (${present.join(", ")})`;
+}
+//#endregion
+//#region src/cli/sync.ts
+const TOKEN_VAR = "DISCORD_TOKEN";
+const APPLICATION_ID_VAR = "DISCORD_APPLICATION_ID";
+/** `nectar sync [--dry-run] [--force]`: register the compiled commands with Discord. */
+async function sync(io, dryRun, force) {
+	const project = await loadProject(io.cwd, io.env);
+	const graph = await compileProject(project, io);
+	if (graph === null) return 1;
+	if (registrationScopes(project.config, project.env).length === 0) throw new CliError(`No registration target for ${project.env}.`, { details: registrationHint(project) });
+	const result = await registerCommands(project, graph, io, {
+		dryRun,
+		force
+	});
+	for (const scope of result.scopes) io.out(describeScope(scope, dryRun));
+	if (result.unsafe.length > 0) {
+		io.err(warn(force ? "Forced past the safety guard:" : "The safety guard would refuse this:"));
+		for (const reason of result.unsafe) io.err(`  ${reason}`);
+	}
+	return 0;
+}
+/**
+* Registers a compiled graph's commands in this environment's scopes. Missing credentials,
+* the safety guard, and Discord validation failures all surface as `CliError`.
+*/
+async function registerCommands(project, graph, io, options = {}) {
+	const token = credential(project, io, "token");
+	const applicationId = credential(project, io, "applicationId");
+	const rest = await (io.rest ?? discordRest)(token);
+	try {
+		return await syncCommands({
+			rest,
+			applicationId,
+			commands: graph.commands.map((cmd) => cmd.payload),
+			scopes: registrationScopes(project.config, project.env),
+			cacheDir: project.outDir,
+			dryRun: options.dryRun ?? false,
+			force: options.force ?? false
+		});
+	} catch (error) {
+		if (error instanceof UnsafeSyncError) throw new CliError("Refusing to register commands: this looks destructive.", { details: [
+			...error.reasons,
+			"",
+			`If that is what you want, run again with ${c.bold("--force")}.`
+		] });
+		if (error instanceof RegistrationError) throw new CliError(`Discord rejected the ${scopeKey(error.scope)} command registration.`, { details: error.problems.map((p) => `${c.bold(p.command ?? "(request)")}${p.field === "" ? "" : ` ${c.dim(p.field)}`}: ${p.message}`) });
+		throw error;
+	}
+}
+/** One line per scope: what changed there and whether it was written. */
+function describeScope({ scope, diff, applied }, dryRun = false) {
+	const key = c.bold(scopeKey(scope));
+	if (diff === null) return ok(`${key}: unchanged since last sync.`);
+	if (!diff.hasChanges) return ok(`${key}: up to date, ${diff.unchanged.length} command(s).`);
+	const parts = [
+		...diff.added.map((n) => c.green(`+${n}`)),
+		...diff.changed.map((n) => c.yellow(`~${n}`)),
+		...diff.removed.map((n) => c.red(`-${n}`))
+	].join(" ");
+	if (dryRun) return info$1(`${key}: ${parts} ${c.dim("(would apply)")}`);
+	return applied ? ok(`${key}: ${parts} ${c.dim("(applied)")}`) : warn(`${key}: ${parts} ${c.dim("(not applied)")}`);
+}
+const CREDENTIAL_VARS = {
+	token: TOKEN_VAR,
+	applicationId: APPLICATION_ID_VAR
+};
+/** The config field wins; the env var is the fallback. Empty strings count as unset. */
+function findCredential(project, io, kind) {
+	const value = project.config[kind] || io.env[CREDENTIAL_VARS[kind]];
+	return value === void 0 || value === "" ? null : value;
+}
+function credential(project, io, kind) {
+	const value = findCredential(project, io, kind);
+	if (value === null) throw new CliError(`${CREDENTIAL_VARS[kind]} is not set.`, { details: credentialHint(kind, projectConfigName(project)) });
+	return value;
+}
+/** A failed login as something to fix: the token, or the connection to Discord. */
+function loginFailure(error, project) {
+	if (!error.invalidToken) return new CliError("Could not log in to Discord.", { details: [describe(error.cause)] });
+	return new CliError("Discord rejected the bot token.", { details: [
+		`The token from ${project.config.token ? `${c.bold("token")} in ${projectConfigName(project)}` : c.bold(TOKEN_VAR)} is wrong, or it was reset.`,
+		"Get a new one from the Developer Portal under your application → Bot → Reset Token:",
+		link(PORTAL_URL)
+	] });
+}
+function registrationHint(project) {
+	return [
+		`Add your test server's ID to ${c.bold("dev.guilds")} in ${projectConfigName(project)}.`,
+		"Find it in Discord: Server Settings → Widget → Server ID, or right-click the server",
+		"with Developer Mode on and choose Copy Server ID."
+	];
+}
+async function discordRest(token) {
+	const { REST } = await import("discord.js");
+	return new REST().setToken(token);
+}
+function projectConfigName(project) {
+	return project.configFile.split(/[\\/]/).at(-1) ?? "nectar.config.ts";
+}
+//#endregion
+//#region src/dev/classify.ts
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs",
+	".json"
+]);
+function classifyPath(file, project) {
+	const absolute = path.resolve(file);
+	if (absolute === path.resolve(project.configFile)) return "config";
+	const parts = absolute.split(path.sep);
+	if (parts.includes("node_modules") || parts.includes(".git") || within(project.outDir, absolute)) return "ignored";
+	const name = path.basename(absolute);
+	if (within(project.appDir, absolute)) {
+		if (path.extname(name) === "" || reservedKind(name) !== void 0) return "route";
+	}
+	if (!SOURCE_EXTENSIONS.has(path.extname(name))) return "ignored";
+	if (/\.(test|spec)\.[cm]?[jt]s$/.test(name)) return "ignored";
+	return "dependency";
+}
+function within(dir, file) {
+	const rel = path.relative(path.resolve(dir), file);
+	return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function diffManifests(before, after) {
+	const payloads = (m) => stableStringify(m.commands.map((c) => c.payload));
+	const shape = (m) => stableStringify({
+		routes: m.routes,
+		events: m.events,
+		commands: m.commands.map(({ payload: _payload, ...rest }) => rest)
+	});
+	return {
+		structure: shape(before) !== shape(after),
+		commands: payloads(before) !== payloads(after)
+	};
+}
+//#endregion
+//#region src/dev/server.ts
+/**
+* The state behind `nectar dev`: the compiled manifest and the runtime serving it. Changes are
+* handled in the smallest way that keeps the running bot correct, and the gateway connection
+* survives everything but a config change.
+*/
+function createDevServer(project, io, options = {}) {
+	const verbose = options.verbose ?? false;
+	let current = project;
+	let manifest = null;
+	let runtime = null;
+	let token = "";
+	let started = false;
+	const warned = /* @__PURE__ */ new Set();
+	/** Lines printed while the server is running carry a timestamp; startup lines do not. */
+	const say = (line) => io.out(started ? `${stamp()} ${line}` : line);
+	const complain = (line) => io.err(started ? `${stamp()} ${line}` : line);
+	/** Framework log records in the dev server's format. The default when the config has no sink. */
+	const print = ({ level, message, fields }) => {
+		if (level === "debug") {
+			const pairs = Object.entries(fields).filter(([key, value]) => key !== "error" && value !== void 0 && value !== null).map(([key, value]) => `${key}=${String(value)}`);
+			say(c.dim([message, ...pairs].join(" ")));
+		} else if (level === "info") say(info$1(message));
+		else if (level === "warn") complain(warn(message));
+		else {
+			const [head = "", ...rest] = message.split("\n");
+			const stack = fields.error === void 0 ? [] : describeError(fields.error);
+			complain(block(fail(c.bold(head)), [...rest.map((l) => l.replace(/^ {2}/, "")), ...stack]));
+		}
+	};
+	/** The config's `logger`, with `--verbose` lowering the level to debug. */
+	const loggerFor = ({ config }) => createLogger({
+		level: verbose ? "debug" : config.logger?.level ?? "info",
+		sink: config.logger?.sink ?? print
+	});
+	let logger = loggerFor(current);
+	let signals = createSignals(logger);
+	function warnOnce(head, details = []) {
+		if (warned.has(head)) return;
+		warned.add(head);
+		complain(block(warn(head), details));
+	}
+	function emit(graph) {
+		const next = toManifest(graph, current.outDir);
+		writeManifest(next, current.outDir);
+		writeTypes(graph, current.outDir, current.config.plugins);
+		return next;
+	}
+	async function register(graph) {
+		const scopes = registrationScopes(current.config, current.env);
+		if (scopes.length === 0) {
+			warnOnce("Commands are not registered anywhere yet.", registrationHint(current));
+			return;
+		}
+		if (findCredential(current, io, "applicationId") === null) {
+			warnOnce(`Commands are not registered: ${APPLICATION_ID_VAR} is not set.`, credentialHint("applicationId", projectConfigName(current)));
+			return;
+		}
+		signals.emit({
+			type: "registration:start",
+			scopes: scopes.map(scopeKey)
+		});
+		const startedAt = Date.now();
+		try {
+			const result = await registerCommands(current, graph, io);
+			signals.emit({
+				type: "registration:complete",
+				scopes: result.scopes.map((s) => ({
+					scope: scopeKey(s.scope),
+					applied: s.applied
+				})),
+				duration: Date.now() - startedAt
+			});
+			for (const scope of result.scopes) if (scope.diff !== null || verbose) say(describeScope(scope));
+		} catch (error) {
+			if (!(error instanceof CliError)) throw error;
+			complain(block(fail(error.message), error.details.map((line) => line.replace("run again with", "run nectar sync with"))));
+		}
+	}
+	async function launch() {
+		if (manifest === null) return;
+		const next = createRuntime({
+			manifest,
+			appDir: current.appDir,
+			config: current.config,
+			env: current.env,
+			logger,
+			signals,
+			...io.client === void 0 ? {} : { client: io.client(current.config) }
+		});
+		watchConnection(next.client);
+		runtime = next;
+		try {
+			await next.start({
+				token,
+				signals: false
+			});
+		} catch (error) {
+			throw error instanceof LoginError ? loginFailure(error, current) : error;
+		}
+	}
+	function watchConnection(client) {
+		client.once(Events.ClientReady, (ready) => say(ok(`Logged in as ${c.bold(ready.user.tag)}.`)));
+		client.on(Events.ShardDisconnect, (event) => {
+			complain(warn(`Disconnected from the gateway ${c.dim(`(code ${event.code})`)}.`));
+		});
+		client.on(Events.ShardReconnecting, () => say(info$1("Reconnecting to the gateway.")));
+		client.on(Events.ShardResume, () => say(ok("Gateway connection resumed.")));
+		client.on(Events.Error, (error) => complain(fail(`Gateway error: ${error.message}`)));
+		if (verbose) client.on(Events.Warn, (message) => complain(warn(`discord.js: ${message}`)));
+	}
+	/** Full start: compile, write output, print routes, register, run. */
+	async function boot() {
+		logger = loggerFor(current);
+		signals = createSignals(logger);
+		const graph = await compileProject(current, io);
+		if (graph === null) {
+			complain(warn("Waiting for changes."));
+			return;
+		}
+		manifest = emit(graph);
+		say(ok(`${summary(graph)} in ${c.bold(appLabel())}`));
+		if (verbose) for (const line of indent(renderRoutes(graph, current.root).split("\n"))) say(line);
+		await register(graph);
+		await launch();
+	}
+	async function stopRuntime() {
+		const running = runtime;
+		runtime = null;
+		manifest = null;
+		if (running !== null) await running.stop();
+	}
+	async function restart() {
+		await stopRuntime();
+		try {
+			current = await loadProject(io.cwd, io.env);
+		} catch (error) {
+			if (!(error instanceof CliError)) throw error;
+			complain(block(fail(error.message), error.details));
+			complain(warn("Waiting for changes."));
+			return;
+		}
+		say(info$1(`Restarting with the new ${c.bold(projectConfigName(current))}.`));
+		await boot();
+	}
+	/** Imports files now so a broken module shows up here, not on the next interaction. */
+	async function preload(files) {
+		if (runtime === null) return;
+		const results = await Promise.allSettled(files.map((file) => runtime?.modules.load(file)));
+		for (const result of results) {
+			if (result.status === "fulfilled") continue;
+			const error = result.reason;
+			complain(error instanceof HandlerLoadError ? block(fail(`${c.bold(relative(current.root, error.file))} failed to load.`), [error.detail]) : fail(String(error)));
+		}
+	}
+	function appLabel() {
+		return `${relative(current.root, current.appDir) || "."}/`;
+	}
+	return {
+		async start() {
+			token = credential(current, io, "token");
+			enableModuleReloading(current.root);
+			await boot();
+			started = true;
+		},
+		async apply(files) {
+			const kinds = new Map(files.map((file) => [file, classifyPath(file, current)]));
+			const changed = files.filter((file) => kinds.get(file) !== "ignored");
+			if (changed.length === 0) return;
+			for (const file of changed) {
+				const gone = !existsSync(file);
+				say(`${gone ? c.red("-") : c.yellow("~")} ${relative(current.root, file)}`);
+			}
+			if (changed.some((file) => kinds.get(file) === "config")) {
+				await restart();
+				return;
+			}
+			const dependency = changed.some((file) => kinds.get(file) === "dependency");
+			if (dependency) invalidateModuleGraph();
+			if (runtime === null || manifest === null) {
+				await boot();
+				return;
+			}
+			const graph = await compileProject(current, io);
+			if (graph === null) {
+				complain(warn("Keeping the previous routes until this is fixed."));
+				return;
+			}
+			const next = toManifest(graph, current.outDir);
+			const delta = diffManifests(manifest, next);
+			const done = [];
+			if (delta.structure || delta.commands) manifest = emit(graph);
+			if (delta.structure) {
+				runtime.update(manifest);
+				done.push(`routes rebuilt ${c.dim(`(${summary(graph)})`)}`);
+				if (verbose) for (const line of indent(renderRoutes(graph, current.root).split("\n"))) say(line);
+			}
+			if (delta.commands) await register(graph);
+			const all = manifestFiles(manifest, current.appDir);
+			const stale = dependency ? [...all] : changed.filter((file) => all.has(file));
+			runtime.modules.invalidate(dependency ? void 0 : stale);
+			await preload(stale);
+			if (dependency) done.push("every module reloaded");
+			else if (stale.length > 0) done.push(`${stale.length} handler module${stale.length === 1 ? "" : "s"} reloaded`);
+			say(done.length === 0 ? info$1("Nothing to reload.") : ok(`${capitalize(done.join(", "))}.`));
+		},
+		stop: stopRuntime
+	};
+}
+function capitalize(text) {
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function describeError(error) {
+	return (error instanceof Error ? error.stack ?? error.message : String(error)).split("\n").map((line) => c.dim(line));
+}
+//#endregion
+//#region src/dev/watch.ts
+/**
+* Watches a directory tree and reports changed paths in debounced batches. Editors write a
+* file in several steps and `fs.watch` reports each one, so a batch collapses them to one
+* change and lets several files saved together be handled together.
+*/
+function watchTree(root, onChange, options = {}) {
+	const { debounce = 80, onError } = options;
+	const pending = /* @__PURE__ */ new Set();
+	let timer = null;
+	const flush = () => {
+		timer = null;
+		const files = [...pending];
+		pending.clear();
+		onChange(files);
+	};
+	const watcher = watch(root, { recursive: true }, (_event, filename) => {
+		if (filename === null) return;
+		pending.add(path.join(root, filename.toString()));
+		if (timer !== null) clearTimeout(timer);
+		timer = setTimeout(flush, debounce);
+	});
+	if (onError !== void 0) watcher.on("error", onError);
+	return { close() {
+		if (timer !== null) clearTimeout(timer);
+		watcher.close();
+	} };
+}
+//#endregion
+//#region src/cli/dev.ts
+/** `nectar dev [--verbose]`: compile, register dev guild commands, run, and react to file changes. */
+async function dev(io, verbose) {
+	io.out(`${c.bold("nectar dev")} ${c.dim(`v${version}`)}`);
+	io.out("");
+	const project = await loadProject(io.cwd, io.env);
+	const server = createDevServer(project, io, { verbose });
+	await server.start();
+	io.out(info$1(`Watching ${c.bold(`${relative(project.root, project.appDir) || "."}/`)}, ${c.bold(relative(project.root, project.configFile))}, and the files they import. ${c.dim("Ctrl+C stops.")}`));
+	let queue = Promise.resolve();
+	const watcher = watchTree(project.root, (files) => {
+		queue = queue.then(() => server.apply(files)).catch((error) => {
+			io.err(`${stamp()} ${error instanceof CliError ? block(fail(error.message), error.details) : fail(describe(error))}`);
+		});
+	}, { onError: (error) => io.err(`${stamp()} ${fail(`Watcher error: ${error.message}`)}`) });
+	await new Promise((resolve) => {
+		process.once("SIGINT", () => resolve());
+		process.once("SIGTERM", () => resolve());
+	});
+	io.out("");
+	io.out(info$1("Stopping."));
+	watcher.close();
+	await queue;
+	await server.stop();
+	return 0;
+}
+//#endregion
+//#region src/cli/manifest.ts
+/** `nectar manifest [--route <id>]`: print the compiled manifest, or everything about one route. */
+async function manifest(io, route) {
+	const project = await loadProject(io.cwd, io.env);
+	const graph = await compileProject(project, io);
+	if (graph === null) return 1;
+	const compiled = toManifest(graph, project.outDir);
+	if (route === void 0) {
+		io.out(stableStringify(compiled));
+		return 0;
+	}
+	const matches = compiled.routes.filter((r) => r.id === route || r.path === route);
+	if (matches.length === 0) {
+		const known = [...new Set(compiled.routes.map((r) => r.id))].sort();
+		throw new CliError(`No route "${route}".`, { details: ["Known routes:", ...known.map((id) => `  ${id}`)] });
+	}
+	io.out(stableStringify(matches.map((r) => describeRoute(r, compiled))));
+	return 0;
+}
+/** The route record plus what the manifest links it to: its command payload, custom ID, or event. */
+function describeRoute(route, compiled) {
+	const detail = { ...route };
+	if (route.kind === "command" || route.kind === "autocomplete") for (const command of compiled.commands) {
+		const position = Object.entries(command.handlers).find(([, id]) => id === route.id)?.[0];
+		if (position === void 0) continue;
+		detail.command = {
+			name: command.name,
+			position,
+			payload: command.payload
+		};
+		if (route.kind === "autocomplete") detail.commandRoute = compiled.routes.find((r) => r.kind === "command" && r.id === route.id)?.file;
+	}
+	else if (route.kind === "event") {
+		const event = compiled.events.find((e) => e.name === route.event);
+		if (event !== void 0) detail.eventHandlers = {
+			mode: event.mode,
+			handlers: event.handlers
+		};
+	} else detail.customId = [`n:${route.shortId}`, ...route.params.map((p) => p === route.catchAll ? `<...${p}>` : `<${p}>`)].join(":");
+	return detail;
+}
+//#endregion
+//#region src/cli/misc.ts
+/** `nectar clean`: delete the build output directory. */
+async function clean(io) {
+	const project = await loadProject(io.cwd, io.env);
+	const label = `${relative(project.root, project.outDir)}/`;
+	if (!existsSync(project.outDir)) {
+		io.out(info$1(`Nothing to remove, ${c.bold(label)} does not exist.`));
+		return 0;
+	}
+	rmSync(project.outDir, {
+		recursive: true,
+		force: true
+	});
+	io.out(ok(`Removed ${c.bold(label)}`));
+	return 0;
+}
+/** `nectar info`: versions, environment, and the config values that decide runtime behaviour. */
+async function info(io) {
+	const rows = [
+		["nectar", version],
+		["node", process.version],
+		["discord.js", await discordVersion()],
+		["platform", `${process.platform} ${process.arch}`]
+	];
+	try {
+		const project = await loadProject(io.cwd, io.env);
+		const { config } = project;
+		const scopes = registrationScopes(config, project.env);
+		rows.push([TOKEN_VAR, present(findCredential(project, io, "token"))], [APPLICATION_ID_VAR, present(findCredential(project, io, "applicationId"))], ["config", relative(project.root, project.configFile)], ["env", project.env], ["appDir", relative(project.root, project.appDir) || "."], ["outDir", relative(project.root, project.outDir)], ["intents", describeBitfield(config.intents)], ["partials", config.partials === void 0 ? "none" : String(config.partials.length)], ["eager", String(config.eager ?? project.env === "production")], ["registration", scopes.length === 0 ? c.yellow("none") : scopes.map(scopeKey).join(", ")], ["plugins", (config.plugins ?? []).map((p) => p.name).join(", ") || "none"]);
+	} catch (error) {
+		if (!(error instanceof CliError)) throw error;
+		rows.push([TOKEN_VAR, present(io.env["DISCORD_TOKEN"] || null)], [APPLICATION_ID_VAR, present(io.env["DISCORD_APPLICATION_ID"] || null)], ["config", c.yellow(error.message)]);
+	}
+	for (const line of table(rows)) io.out(line);
+	return 0;
+}
+async function discordVersion() {
+	try {
+		const { version: v } = await import("discord.js");
+		return v;
+	} catch {
+		return c.yellow("not installed");
+	}
+}
+function present(value) {
+	return value === null || value === "" ? c.yellow("not set") : c.green("set");
+}
+function describeBitfield(value) {
+	if (Array.isArray(value)) return value.length === 0 ? "none" : value.map(String).join(", ");
+	return String(value);
+}
+//#endregion
+//#region src/cli/start.ts
+/** `nectar start`: run the bot from the last `nectar build`. No source discovery happens here. */
+async function start(io) {
+	const project = await loadProject(io.cwd, io.env);
+	const manifestFile = path.join(project.outDir, MANIFEST_FILE);
+	if (!existsSync(manifestFile)) throw new CliError(`${relative(project.root, manifestFile)} not found.`, { details: [`Run ${c.bold("nectar build")} first, then ${c.bold("nectar start")} again.`] });
+	const token = credential(project, io, "token");
+	const { manifest, appDir } = loadManifest(manifestFile);
+	const runtime = createRuntime({
+		manifest,
+		appDir,
+		config: project.config,
+		env: project.env,
+		...io.client === void 0 ? {} : { client: io.client(project.config) }
+	});
+	runtime.client.once("clientReady", (client) => {
+		io.out(ok(`Logged in as ${c.bold(client.user.tag)} (${project.env}${shards(client)}).`));
+	});
+	try {
+		await runtime.start({ token });
+	} catch (error) {
+		throw error instanceof LoginError ? loginFailure(error, project) : error;
+	}
+	return 0;
+}
+/** `, shard 2 of 4` when the bot is sharded, so each shard process's line says which it is. */
+function shards(client) {
+	const { shards: ids, shardCount } = client.options;
+	if (!Array.isArray(ids) || shardCount === void 0 || shardCount < 2) return "";
+	return `, shard${ids.length === 1 ? "" : "s"} ${ids.join(", ")} of ${shardCount}`;
+}
+//#endregion
+//#region src/cli/index.ts
+const COMMANDS = {
+	dev: {
+		usage: "dev [--verbose]",
+		description: "Compile, register dev guild commands, run the bot, and reload on changes.",
+		options: { verbose: {
+			type: "boolean",
+			description: "Print the route tree and discord.js warnings."
+		} },
+		run: (io, flags) => dev(io, flags.verbose === true)
+	},
+	build: {
+		usage: "build",
+		description: "Compile the app and write the manifest and types.",
+		run: (io) => build(io)
+	},
+	check: {
+		usage: "check",
+		description: "Compile and report problems without writing anything.",
+		run: (io) => check(io)
+	},
+	routes: {
+		usage: "routes",
+		description: "Show the app tree: commands, components, events, middleware, error boundaries.",
+		run: (io) => routes(io)
+	},
+	manifest: {
+		usage: "manifest [--route <id>]",
+		description: "Print the compiled manifest, or everything about one route.",
+		options: { route: {
+			type: "string",
+			description: "Route ID or path, e.g. command:moderation/ban."
+		} },
+		run: (io, flags) => manifest(io, flags.route)
+	},
+	sync: {
+		usage: "sync [--dry-run] [--force]",
+		description: "Register commands with Discord, writing only scopes that changed.",
+		options: {
+			"dry-run": {
+				type: "boolean",
+				description: "Show the diff without changing anything."
+			},
+			force: {
+				type: "boolean",
+				description: "Proceed even when the change looks destructive."
+			}
+		},
+		run: (io, flags) => sync(io, flags["dry-run"] === true, flags.force === true)
+	},
+	start: {
+		usage: "start",
+		description: "Run the bot from the last build.",
+		run: (io) => start(io)
+	},
+	clean: {
+		usage: "clean",
+		description: "Delete the build output directory.",
+		run: (io) => clean(io)
+	},
+	info: {
+		usage: "info",
+		description: "Show versions, environment, and the effective config.",
+		run: (io) => info(io)
+	}
+};
+/**
+* Commands contributed by the config's plugins. Loading the config can fail; for help that is
+* silent, for a command it is the error the user needs to see.
+*/
+async function pluginCommands(io, tolerant) {
+	if (!CONFIG_FILES.some((file) => existsSync(path.join(io.cwd, file)))) return {};
+	const commands = {};
+	try {
+		const project = await loadProject(io.cwd, io.env);
+		for (const plugin of project.config.plugins ?? []) for (const command of plugin.commands ?? []) {
+			const options = command.options ?? {};
+			const usage = [command.name, ...Object.entries(options).map(([key, opt]) => `[--${key}${opt.type === "string" ? " <value>" : ""}]`)].join(" ");
+			commands[command.name] = {
+				usage,
+				description: command.description,
+				options,
+				run: async (io, flags) => command.run({
+					project,
+					flags,
+					out: io.out,
+					err: io.err
+				})
+			};
+		}
+	} catch (error) {
+		if (!tolerant || !(error instanceof CliError)) throw error;
+	}
+	return commands;
+}
+/** Runs `run` for this process: loads `cwd/.env`, colors a TTY, prints to the console. */
+async function main(argv, cwd) {
+	const envFile = path.join(cwd, ".env");
+	if (existsSync(envFile)) process.loadEnvFile(envFile);
+	const wantsColor = process.env.NO_COLOR === void 0 || process.env.NO_COLOR === "";
+	setColors(process.env.FORCE_COLOR !== void 0 || wantsColor && process.stdout.isTTY === true);
+	return run(argv, {
+		cwd,
+		env: process.env,
+		out: (line) => console.log(line),
+		err: (line) => console.error(line)
+	});
+}
+/** Runs one CLI invocation. `argv` excludes the node and script entries. */
+async function run(argv, io) {
+	const [name, ...rest] = argv;
+	if (name === void 0 || name === "--help" || name === "-h" || name === "help") {
+		io.out(help(await pluginCommands(io, true)));
+		return name === void 0 ? 2 : 0;
+	}
+	if (name === "--version" || name === "-v") {
+		io.out(version);
+		return 0;
+	}
+	let command = COMMANDS[name];
+	if (command === void 0) try {
+		command = (await pluginCommands(io, false))[name];
+	} catch (error) {
+		if (!(error instanceof CliError)) throw error;
+		io.err(block(fail(error.message), error.details));
+		return error.code;
+	}
+	if (command === void 0) {
+		io.err(block(fail(`Unknown command ${c.bold(`"${name}"`)}.`), [`Run ${c.bold("nectar --help")} to see the commands.`]));
+		return 2;
+	}
+	let flags;
+	try {
+		flags = parseArgs({
+			args: rest,
+			options: {
+				...Object.fromEntries(Object.entries(command.options ?? {}).map(([key, opt]) => [key, { type: opt.type }])),
+				help: { type: "boolean" }
+			},
+			strict: true,
+			allowPositionals: false
+		}).values;
+	} catch (error) {
+		io.err(fail(describe(error)));
+		io.err("");
+		io.err(commandHelp(command));
+		return 2;
+	}
+	if (flags.help === true) {
+		io.out(commandHelp(command));
+		return 0;
+	}
+	try {
+		return await command.run(io, flags);
+	} catch (error) {
+		if (error instanceof CliError) {
+			io.err(block(fail(error.message), error.details));
+			return error.code;
+		}
+		if (error instanceof PluginError) {
+			io.err(block(fail(error.message), [`Fix or remove the plugin in your config.`]));
+			return 1;
+		}
+		io.err(block(fail("Something went wrong inside Nectar."), [
+			"This is a bug in Nectar, not in your app. The details:",
+			"",
+			...(error instanceof Error ? error.stack ?? error.message : String(error)).split("\n").map((line) => c.dim(line))
+		]));
+		return 1;
+	}
+}
+function help(plugins) {
+	const all = [...Object.values(COMMANDS), ...Object.values(plugins)];
+	const width = Math.max(...all.map((cmd) => cmd.usage.length));
+	const row = (cmd) => `  ${c.cyan(cmd.usage.padEnd(width))}  ${c.dim(cmd.description)}`;
+	return [
+		`${c.bold("nectar")} ${c.dim(`v${version}`)}  A filesystem-based meta-framework for discord.js.`,
+		"",
+		`${c.bold("Usage:")} nectar <command> [options]`,
+		"",
+		c.bold("Commands:"),
+		...Object.values(COMMANDS).map(row),
+		...Object.keys(plugins).length === 0 ? [] : [
+			"",
+			c.bold("Plugin commands:"),
+			...Object.values(plugins).map(row)
+		],
+		"",
+		c.bold("Options:"),
+		`  ${c.cyan("--help, -h".padEnd(width))}  ${c.dim("Show help for nectar or a command.")}`,
+		`  ${c.cyan("--version, -v".padEnd(width))}  ${c.dim("Print the version.")}`
+	].join("\n");
+}
+function commandHelp(command) {
+	const options = Object.entries(command.options ?? {});
+	const lines = [
+		`${c.bold("Usage:")} nectar ${command.usage}`,
+		"",
+		command.description
+	];
+	if (options.length > 0) {
+		const width = Math.max(...options.map(([key]) => key.length));
+		lines.push("", c.bold("Options:"), ...indent(options.map(([key, opt]) => `${c.cyan(`--${key.padEnd(width)}`)}  ${c.dim(opt.description)}`)));
+	}
+	return lines.join("\n");
+}
+//#endregion
+export { main as t };
+
+//# sourceMappingURL=cli-Ce-ZUj6M.js.map