@nectar-js/nectar 0.1.0

package/dist/runtime-CZJeZvSL.js

@@ -0,0 +1,891 @@
+import { b as loadModule, h as paramValidatorsOf, m as findInvalidParam, t as PluginError, u as registerComponentRoutes, w as decodeCustomId } from "./plugins-CGvM19v9.js";
+import path from "node:path";
+import { readFileSync } from "node:fs";
+import { Client, DiscordjsError, DiscordjsErrorCodes, Events } from "discord.js";
+import { ApplicationCommandType, MessageFlags } from "discord-api-types/v10";
+//#region src/components/matcher.ts
+/**
+* Resolves incoming custom IDs to routes.
+*
+* Custom IDs carry the route's short ID, so matching is a direct lookup rather than a pattern
+* scan. The interaction kind is part of the key, so a button's ID sent back as a modal
+* submission finds no route.
+*/
+function createMatcher(routes) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const route of routes) byId.set(`${route.kind}:${route.shortId}`, route);
+	return { match(kind, customId) {
+		const decoded = decodeCustomId(customId);
+		if (!decoded.ok) return decoded;
+		const route = byId.get(`${kind}:${decoded.shortId}`);
+		if (route === void 0) return {
+			ok: false,
+			reason: "unknown-route"
+		};
+		const fixed = route.catchAll === null ? route.params.length : route.params.length - 1;
+		if (route.catchAll === null ? decoded.values.length !== fixed : decoded.values.length < fixed) return {
+			ok: false,
+			reason: "param-count"
+		};
+		const params = {};
+		for (let i = 0; i < fixed; i++) params[route.params[i]] = decoded.values[i];
+		if (route.catchAll !== null) params[route.catchAll] = decoded.values.slice(fixed);
+		return {
+			ok: true,
+			route,
+			params
+		};
+	} };
+}
+//#endregion
+//#region src/manifest/load.ts
+var ManifestVersionError = class extends Error {
+	file;
+	found;
+	constructor(file, found) {
+		super(`${file} is manifest version ${String(found)}, this build of @nectar-js/nectar reads version 1. Run \`nectar build\` again.`);
+		this.file = file;
+		this.found = found;
+		this.name = "ManifestVersionError";
+	}
+};
+/** Reads a manifest from disk and checks its version. Does not validate the rest of the shape. */
+function loadManifest(file) {
+	const absolute = path.resolve(file);
+	const parsed = JSON.parse(readFileSync(absolute, "utf8"));
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError(`${absolute} is not a manifest object.`);
+	const manifest = parsed;
+	if (manifest.version !== 1) throw new ManifestVersionError(absolute, manifest.version);
+	if (typeof manifest.appDir !== "string") throw new TypeError(`${absolute} has no appDir.`);
+	return {
+		manifest,
+		appDir: path.resolve(path.dirname(absolute), manifest.appDir)
+	};
+}
+//#endregion
+//#region src/runtime/signals.ts
+/**
+* Fan-out for framework signals. Listeners run synchronously in subscription order; one that
+* throws is reported through the logger and does not affect the others or the interaction.
+*/
+function createSignals(logger) {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		on(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		emit(data) {
+			if (listeners.size === 0) return;
+			const signal = {
+				...data,
+				at: Date.now()
+			};
+			for (const listener of listeners) try {
+				listener(signal);
+			} catch (error) {
+				logger.error(`A signal listener threw on ${data.type}.`, { error });
+			}
+		}
+	};
+}
+/** Reads the fields spec 31 asks for off a discord.js interaction, tolerating stubs. */
+function interactionMeta(interaction) {
+	const i = interaction;
+	const guard = (name) => typeof i[name] === "function" && i[name]?.() === true;
+	const where = {
+		guildId: i.guildId ?? null,
+		channelId: i.channelId ?? null,
+		userId: i.user?.id ?? null
+	};
+	if (guard("isChatInputCommand") || guard("isAutocomplete")) return {
+		type: guard("isAutocomplete") ? "autocomplete" : "chatInput",
+		command: [
+			i.commandName,
+			i.options?.getSubcommandGroup(false) ?? null,
+			i.options?.getSubcommand(false) ?? null
+		].filter((p) => typeof p === "string").join(" "),
+		...where
+	};
+	if (guard("isContextMenuCommand")) return {
+		type: i.commandType === ApplicationCommandType.Message ? "messageContextMenu" : "userContextMenu",
+		command: i.commandName ?? "",
+		...where
+	};
+	const kind = guard("isButton") ? "button" : guard("isAnySelectMenu") ? "select" : guard("isModalSubmit") ? "modal" : null;
+	if (kind !== null) return {
+		type: kind,
+		customId: redactCustomId(i.customId ?? ""),
+		...where
+	};
+	return {
+		type: "unknown",
+		...where
+	};
+}
+/**
+* Keeps the route part of a Nectar custom ID and hides the parameter values, which may carry
+* anything the application put there. Other custom IDs are not ours and pass through.
+*/
+function redactCustomId(customId) {
+	if (!customId.startsWith("n:")) return customId;
+	const params = customId.indexOf(":", 2);
+	return params === -1 ? customId : `${customId.slice(0, params)}:*`;
+}
+//#endregion
+//#region src/runtime/errors.ts
+/** The reply the default boundary sends when an interaction is still unanswered. */
+const GENERIC_ERROR_REPLY = "Something went wrong while handling that.";
+/**
+* Passes an error through the route's boundaries, nearest first, then the default boundary.
+* A boundary handles the error by returning normally. Returning `"unhandled"` or throwing
+* hands it (or the newly thrown error) to the next one. Nothing is ever swallowed: the default
+* boundary always logs.
+*
+* `middleware` is the chain that ran before the handler; development output lists it.
+* Resolves to the boundary file that handled the error, or `null` for the default boundary.
+*/
+async function handleError(error, ctx, boundaries, modules, logger, middleware = []) {
+	let current = error;
+	for (const file of boundaries) try {
+		if (await (await modules.loadDefault(file, "An error boundary"))(current, ctx) !== "unhandled") return file;
+	} catch (thrown) {
+		current = thrown;
+	}
+	await defaultBoundary(current, ctx, logger, middleware);
+	return null;
+}
+/** The structured metadata every framework log line about a route carries. */
+function logFields(ctx, meta) {
+	const fields = { route: ctx.route.id };
+	if (!("interaction" in ctx)) {
+		fields.event = ctx.route.path.split("/")[0];
+		return fields;
+	}
+	const i = meta ?? interactionMeta(ctx.interaction);
+	fields.trace = ctx.trace.id;
+	fields.interaction = i.type;
+	if (i.command !== void 0) fields.command = i.command;
+	if (i.customId !== void 0) fields.customId = i.customId;
+	fields.guild = i.guildId;
+	fields.channel = i.channelId;
+	fields.user = i.userId;
+	return fields;
+}
+async function defaultBoundary(error, ctx, logger, middleware) {
+	logger.error(ctx.env === "development" ? developmentReport(ctx, middleware) : `Unhandled error in ${ctx.route.id} (${ctx.route.file})`, {
+		...logFields(ctx),
+		error
+	});
+	if (!("interaction" in ctx)) return;
+	const interaction = ctx.interaction;
+	if (typeof interaction.isRepliable !== "function" || !interaction.isRepliable()) return;
+	if (interaction.replied || interaction.deferred) return;
+	try {
+		await interaction.reply({
+			content: GENERIC_ERROR_REPLY,
+			flags: MessageFlags.Ephemeral
+		});
+	} catch (replyError) {
+		logger.error(`Could not send the error reply for ${ctx.route.id}`, {
+			...logFields(ctx),
+			error: replyError
+		});
+	}
+}
+/** Where the failure sits in the app, so the developer can go straight to the boundary. */
+function developmentReport(ctx, middleware) {
+	const rows = [["file", ctx.route.file]];
+	if ("interaction" in ctx) {
+		rows.push(["interaction", describeInteraction(ctx.interaction)]);
+		rows.push(["elapsed", `${ctx.trace.elapsed()}ms since Discord created it`]);
+		rows.push(["middleware", middleware.length === 0 ? "none" : middleware.join(`\n${" ".repeat(15)}`)]);
+	}
+	const width = Math.max(...rows.map(([key]) => key.length));
+	return [`Unhandled error in ${ctx.route.id}`, ...rows.map(([key, value]) => `  ${key.padEnd(width)}  ${value}`)].join("\n");
+}
+function describeInteraction(interaction) {
+	const meta = interactionMeta(interaction);
+	let what;
+	switch (meta.type) {
+		case "chatInput":
+			what = `/${meta.command}`;
+			break;
+		case "autocomplete":
+			what = `autocomplete for /${meta.command}`;
+			break;
+		case "userContextMenu":
+		case "messageContextMenu":
+			what = `context menu "${meta.command}"`;
+			break;
+		case "unknown":
+			what = "unknown interaction";
+			break;
+		default: what = `${meta.type} "${meta.customId}"`;
+	}
+	const where = [
+		meta.guildId === null ? "direct message" : `guild ${meta.guildId}`,
+		meta.channelId === null ? null : `channel ${meta.channelId}`,
+		meta.userId === null ? null : `user ${meta.userId}`
+	].filter((p) => p !== null);
+	return `${what} (${where.join(", ")})`;
+}
+//#endregion
+//#region src/runtime/middleware.ts
+/**
+* Runs middleware outer to inner, then the handler.
+*
+* `next()` continues unchanged; `next({ member })` puts `member` on every downstream context.
+* Returning without calling `next` stops the chain. Throwing anywhere unwinds to the caller,
+* which hands it to the error boundaries. Code after `await next()` runs after the handler.
+*/
+async function runChain(middleware, ctx, handler, hooks = {}) {
+	await step(0);
+	async function step(index, current = ctx) {
+		const layer = middleware[index];
+		if (layer === void 0) {
+			hooks.handler?.();
+			return handler(current);
+		}
+		hooks.middleware?.(index);
+		let called = false;
+		const next = (extension) => {
+			if (called) throw new Error("next() was called twice in the same middleware.");
+			called = true;
+			const downstream = extension === void 0 ? current : {
+				...current,
+				...extension
+			};
+			return step(index + 1, downstream);
+		};
+		return layer(current, next);
+	}
+}
+//#endregion
+//#region src/runtime/modules.ts
+var HandlerLoadError = class extends Error {
+	file;
+	detail;
+	constructor(file, detail) {
+		super(`${file}: ${detail}`);
+		this.file = file;
+		this.detail = detail;
+		this.name = "HandlerLoadError";
+	}
+};
+/**
+* Imports handler modules once and caches them. Files are absolute paths taken from the
+* manifest, so nothing here touches the filesystem beyond `import()`.
+*/
+var ModuleRegistry = class {
+	cache = /* @__PURE__ */ new Map();
+	load(file) {
+		let pending = this.cache.get(file);
+		if (pending === void 0) {
+			pending = loadModule(file).catch((error) => {
+				this.cache.delete(file);
+				throw new HandlerLoadError(file, error instanceof Error ? error.message : String(error));
+			});
+			this.cache.set(file, pending);
+		}
+		return pending;
+	}
+	/**
+	* Forgets cached modules so the next load imports them again. With no argument, forgets
+	* everything. Only useful together with `enableModuleReloading`; otherwise `import()` hands
+	* back the same instance.
+	*/
+	invalidate(files) {
+		if (files === void 0) {
+			this.cache.clear();
+			return;
+		}
+		for (const file of files) this.cache.delete(file);
+	}
+	/** Imports every file up front so a bad module fails startup instead of the first interaction. */
+	async preload(files) {
+		await Promise.all([...new Set(files)].map((file) => this.load(file)));
+	}
+	/** The default export of a file, checked to be a function. */
+	async loadDefault(file, what) {
+		const value = (await this.load(file)).default;
+		if (typeof value !== "function") throw new HandlerLoadError(file, `${what} must be the default export and a function, got ${describe$1(value)}.`);
+		return value;
+	}
+	/** A named export of a file, checked to be a function. */
+	async loadNamed(file, name, what) {
+		const value = (await this.load(file))[name];
+		if (typeof value !== "function") throw new HandlerLoadError(file, `${what} must be exported as "${name}" and be a function, got ${describe$1(value)}.`);
+		return value;
+	}
+};
+function describe$1(value) {
+	return value === void 0 ? "no export" : typeof value;
+}
+//#endregion
+//#region src/runtime/state.ts
+function absolute(state, file) {
+	return path.join(state.appDir, ...file.split("/"));
+}
+function routeInfo(state, route) {
+	return {
+		id: route.id,
+		category: route.category,
+		path: route.path,
+		file: absolute(state, route.file)
+	};
+}
+function chains(state, route) {
+	return {
+		middleware: route.middleware.map((f) => absolute(state, f)),
+		errors: route.errors.map((f) => absolute(state, f))
+	};
+}
+//#endregion
+//#region src/runtime/dispatch.ts
+function createInteractionDispatcher(state) {
+	const tables = buildTables(state.manifest.routes, state.manifest.commands);
+	return async (interaction) => {
+		const receivedAt = Date.now();
+		const meta = interactionMeta(interaction);
+		state.signals.emit({
+			type: "interaction:start",
+			trace: interaction.id,
+			interaction: meta
+		});
+		if (interaction.isChatInputCommand()) {
+			const key = [interaction.options.getSubcommandGroup(false), interaction.options.getSubcommand(false)].filter((p) => p !== null).join("/");
+			const route = tables.commands.get(commandKey(ApplicationCommandType.ChatInput, interaction.commandName, key));
+			if (route === void 0) return unknown(state, interaction, meta, `chat input command /${meta.command}`);
+			return run(state, route, interaction, meta, {}, receivedAt);
+		}
+		if (interaction.isContextMenuCommand()) {
+			const route = tables.commands.get(commandKey(interaction.commandType, interaction.commandName, ""));
+			if (route === void 0) return unknown(state, interaction, meta, `context menu command "${meta.command}"`);
+			return run(state, route, interaction, meta, {}, receivedAt);
+		}
+		if (interaction.isAutocomplete()) {
+			const key = [interaction.options.getSubcommandGroup(false), interaction.options.getSubcommand(false)].filter((p) => p !== null).join("/");
+			const command = tables.commands.get(commandKey(ApplicationCommandType.ChatInput, interaction.commandName, key));
+			const route = command === void 0 ? void 0 : tables.autocomplete.get(command.id);
+			const option = interaction.options.getFocused(true).name;
+			if (route === void 0 || !route.options.includes(option)) return unknown(state, interaction, meta, `autocomplete for /${meta.command} "${option}"`);
+			return run(state, route, interaction, meta, {}, receivedAt, option);
+		}
+		const component = interaction.isButton() ? ["button", interaction.customId] : interaction.isAnySelectMenu() ? ["select", interaction.customId] : interaction.isModalSubmit() ? ["modal", interaction.customId] : null;
+		if (component === null) {
+			state.signals.emit({
+				type: "interaction:reject",
+				trace: interaction.id,
+				interaction: meta,
+				reason: "unknown-interaction"
+			});
+			return;
+		}
+		const [kind, customId] = component;
+		const match = tables.matcher.match(kind, customId);
+		if (!match.ok) {
+			if (match.reason === "not-nectar") return;
+			state.logger.warn(`Ignoring ${kind} with custom ID "${meta.customId}": ${match.reason}.`, {
+				trace: interaction.id,
+				interaction: kind,
+				customId: meta.customId
+			});
+			state.signals.emit({
+				type: "interaction:reject",
+				trace: interaction.id,
+				interaction: meta,
+				reason: match.reason
+			});
+			return;
+		}
+		return run(state, match.route, interaction, meta, match.params, receivedAt);
+	};
+}
+async function run(state, route, interaction, meta, params, receivedAt, autocompleteOption) {
+	const ctx = {
+		interaction,
+		client: state.client,
+		route: routeInfo(state, route),
+		params,
+		env: state.env,
+		trace: {
+			id: interaction.id,
+			receivedAt,
+			elapsed: () => Date.now() - interaction.createdTimestamp
+		},
+		services: state.services
+	};
+	const files = chains(state, route);
+	const tag = {
+		trace: interaction.id,
+		interaction: meta,
+		route: ctx.route
+	};
+	state.signals.emit({
+		type: "route:match",
+		...tag
+	});
+	let handlerStart = 0;
+	try {
+		const middleware = await Promise.all(files.middleware.map((file) => state.modules.loadDefault(file, "Middleware")));
+		const handler = autocompleteOption === void 0 ? await state.modules.loadDefault(ctx.route.file, "The handler") : await state.modules.loadNamed(ctx.route.file, autocompleteOption, "The autocomplete handler");
+		if (route.kind === "button" || route.kind === "select" || route.kind === "modal") {
+			const invalid = await findInvalidParam(validators(ctx.route.file, handler, route), params);
+			if (invalid !== null) {
+				state.logger.warn(`Rejected ${route.kind} for ${ctx.route.id}: "${invalid}" failed validation.`, {
+					...logFields(ctx, meta),
+					param: invalid
+				});
+				state.signals.emit({
+					type: "interaction:reject",
+					trace: interaction.id,
+					interaction: meta,
+					reason: "invalid-param",
+					route: ctx.route,
+					param: invalid
+				});
+				return;
+			}
+		}
+		await runChain(middleware, ctx, handler, {
+			middleware: (index) => state.signals.emit({
+				type: "middleware:enter",
+				...tag,
+				file: files.middleware[index] ?? ""
+			}),
+			handler: () => {
+				handlerStart = Date.now();
+				state.signals.emit({
+					type: "handler:enter",
+					...tag
+				});
+			}
+		});
+		const handled = handlerStart !== 0;
+		if (handled) state.signals.emit({
+			type: "handler:complete",
+			...tag,
+			duration: Date.now() - handlerStart
+		});
+		const duration = Date.now() - receivedAt;
+		state.signals.emit({
+			type: "interaction:complete",
+			...tag,
+			duration,
+			handled
+		});
+		state.logger.debug(handled ? `Handled ${ctx.route.id} in ${duration}ms.` : `Middleware stopped ${ctx.route.id}.`, logFields(ctx, meta));
+	} catch (error) {
+		const boundary = await handleError(error, ctx, files.errors, state.modules, state.logger, files.middleware);
+		state.signals.emit({
+			type: "interaction:fail",
+			...tag,
+			error,
+			boundary
+		});
+		if (boundary !== null) state.logger.debug(`${ctx.route.id} failed, handled by ${boundary}.`, {
+			...logFields(ctx, meta),
+			boundary,
+			error
+		});
+		if (autocompleteOption !== void 0) await closeAutocomplete(interaction);
+	}
+}
+/** Discord shows a spinner until autocomplete answers, so a failed handler answers with nothing. */
+async function closeAutocomplete(interaction) {
+	if (interaction.responded) return;
+	try {
+		await interaction.respond([]);
+	} catch {}
+}
+function unknown(state, interaction, meta, what) {
+	state.logger.warn(`No route for ${what}. Run \`nectar sync\` if commands changed.`, {
+		trace: interaction.id,
+		interaction: meta.type,
+		command: meta.command
+	});
+	state.signals.emit({
+		type: "interaction:reject",
+		trace: interaction.id,
+		interaction: meta,
+		reason: "no-route"
+	});
+}
+/**
+* The route's parameter validators, checked once per handler instance. The compiler checked
+* the shape at build time; this repeats it so a JavaScript project or a hot-reloaded file
+* fails the same way instead of at the first click.
+*/
+function validators(file, handler, route) {
+	const cached = validatorCache.get(handler);
+	if (cached !== void 0) return cached;
+	let result;
+	try {
+		result = paramValidatorsOf(handler, route);
+	} catch (error) {
+		throw new HandlerLoadError(file, error instanceof Error ? error.message : String(error));
+	}
+	validatorCache.set(handler, result);
+	return result;
+}
+const validatorCache = /* @__PURE__ */ new WeakMap();
+function buildTables(routes, commands) {
+	const commandRoutes = /* @__PURE__ */ new Map();
+	const autocomplete = /* @__PURE__ */ new Map();
+	const components = [];
+	for (const route of routes) if (route.kind === "command") commandRoutes.set(route.id, route);
+	else if (route.kind === "autocomplete") autocomplete.set(route.id, route);
+	else if (route.kind !== "event") components.push(route);
+	const table = /* @__PURE__ */ new Map();
+	for (const command of commands) for (const [key, id] of Object.entries(command.handlers)) {
+		const route = commandRoutes.get(id);
+		if (route !== void 0) table.set(commandKey(command.type, command.name, key), route);
+	}
+	return {
+		commands: table,
+		autocomplete,
+		matcher: createMatcher(components)
+	};
+}
+function commandKey(type, name, handlerKey) {
+	return `${type}:${name}:${handlerKey}`;
+}
+//#endregion
+//#region src/runtime/events.ts
+/**
+* One discord.js listener per event. It fans out to the compiled handlers in manifest order,
+* sequentially or concurrently as the event's mode says. A `once` handler runs on the first
+* emission only; when every handler of an event is spent, the listener is removed.
+*
+* Handler errors go to the route's boundaries and never reach the client's `error` event.
+* Returns the bindings so the runtime can remove them on shutdown.
+*/
+function bindEvents(state) {
+	const routes = /* @__PURE__ */ new Map();
+	for (const route of state.manifest.routes) if (route.kind === "event") routes.set(route.id, route);
+	const bindings = [];
+	for (const event of state.manifest.events) {
+		const handlers = event.handlers.map((id) => routes.get(id)).filter((r) => r !== void 0);
+		if (handlers.length === 0) continue;
+		const spent = /* @__PURE__ */ new Set();
+		const listener = (...args) => {
+			const live = handlers.filter((h) => !spent.has(h.id));
+			for (const h of live) if (h.once) spent.add(h.id);
+			if (spent.size === handlers.length) state.client.off(event.name, listener);
+			return fanOut(state, event, live, args);
+		};
+		state.client.on(event.name, listener);
+		bindings.push({
+			name: event.name,
+			listener
+		});
+	}
+	return bindings;
+}
+async function fanOut(state, event, handlers, args) {
+	if (event.mode === "concurrent") {
+		await Promise.all(handlers.map((route) => invoke(state, event, route, args)));
+		return;
+	}
+	for (const route of handlers) await invoke(state, event, route, args);
+}
+async function invoke(state, event, route, args) {
+	const ctx = {
+		client: state.client,
+		route: routeInfo(state, route),
+		env: state.env,
+		services: state.services
+	};
+	try {
+		await (await state.modules.loadDefault(ctx.route.file, "The handler"))(...args, ctx);
+	} catch (error) {
+		const boundary = await handleError(error, ctx, chains(state, route).errors, state.modules, state.logger);
+		state.signals.emit({
+			type: "event:fail",
+			event: event.name,
+			route: ctx.route,
+			error,
+			boundary
+		});
+	}
+}
+//#endregion
+//#region src/runtime/logger.ts
+const ORDER = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+function createLogger(options = {}) {
+	const threshold = ORDER[options.level ?? "info"];
+	const sink = options.sink ?? consoleSink;
+	const log = (level, message, fields = {}) => {
+		if (ORDER[level] < threshold) return;
+		sink({
+			level,
+			message,
+			at: Date.now(),
+			fields
+		});
+	};
+	return {
+		debug: (message, fields) => log("debug", message, fields),
+		info: (message, fields) => log("info", message, fields),
+		warn: (message, fields) => log("warn", message, fields),
+		error: (message, fields) => log("error", message, fields)
+	};
+}
+/** `[nectar] message key=value ...` on the matching console method, then the error if any. */
+const consoleSink = ({ level, message, fields }) => {
+	const { error, ...rest } = fields;
+	const pairs = Object.entries(rest).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`);
+	const line = [`[nectar] ${message}`, ...pairs].join(" ");
+	if (error === void 0) console[level](line);
+	else console[level](line, error);
+};
+//#endregion
+//#region src/runtime/runtime.ts
+/** `client.login` failed: Discord refused the token, or could not be reached. */
+var LoginError = class extends Error {
+	invalidToken;
+	constructor(cause) {
+		const invalidToken = cause instanceof DiscordjsError && cause.code === DiscordjsErrorCodes.TokenInvalid;
+		super(invalidToken ? "Discord rejected the bot token." : `Could not log in: ${describe(cause)}`, { cause });
+		this.name = "LoginError";
+		this.invalidToken = invalidToken;
+	}
+};
+function createRuntime(options) {
+	const env = options.env ?? envFromProcess();
+	const logger = options.logger ?? createLogger(options.config.logger);
+	const signals = options.signals ?? createSignals(logger);
+	if (options.config.observe !== void 0) signals.on(options.config.observe);
+	const client = options.client ?? new Client({
+		...options.config.client,
+		intents: options.config.intents,
+		...options.config.partials === void 0 ? {} : { partials: options.config.partials }
+	});
+	const state = {
+		manifest: options.manifest,
+		appDir: path.resolve(options.appDir),
+		client,
+		modules: new ModuleRegistry(),
+		env,
+		logger,
+		signals,
+		services: {}
+	};
+	const plugins = options.config.plugins ?? [];
+	const app = {
+		client,
+		env,
+		logger,
+		signals,
+		get manifest() {
+			return state.manifest;
+		}
+	};
+	registerComponentRoutes(componentRoutes(state.manifest));
+	let dispatch = createInteractionDispatcher(state);
+	const inFlight = /* @__PURE__ */ new Set();
+	let bindings = [];
+	let started = false;
+	let globalStarted = false;
+	let drainTimeout = 1e4;
+	let stopping = null;
+	let onSignal = null;
+	const onInteraction = (interaction) => {
+		const task = dispatch(interaction).finally(() => inFlight.delete(task));
+		inFlight.add(task);
+	};
+	const onDisconnect = () => void runtime.stop();
+	const gateway = {
+		[Events.ShardReady]: (shard) => signals.emit({
+			type: "gateway:connect",
+			shard,
+			resumed: false
+		}),
+		[Events.ShardResume]: (shard) => signals.emit({
+			type: "gateway:connect",
+			shard,
+			resumed: true
+		}),
+		[Events.ShardDisconnect]: (event, shard) => signals.emit({
+			type: "gateway:disconnect",
+			shard,
+			code: event.code
+		})
+	};
+	const runtime = {
+		client,
+		env,
+		modules: state.modules,
+		signals,
+		async start({ token, signals: osSignals = true, drainTimeout: timeout = 1e4 }) {
+			drainTimeout = timeout;
+			await startPlugins(plugins, app, state.services);
+			if (runsShardZero(client.options.shards)) {
+				await startGlobal(plugins, app);
+				globalStarted = true;
+			}
+			if (options.config.eager ?? env === "production") await state.modules.preload(manifestFiles(state.manifest, state.appDir));
+			bindings = bindEvents(state);
+			started = true;
+			client.on(Events.InteractionCreate, onInteraction);
+			client.on(Events.ShardReady, gateway[Events.ShardReady]);
+			client.on(Events.ShardResume, gateway[Events.ShardResume]);
+			client.on(Events.ShardDisconnect, gateway[Events.ShardDisconnect]);
+			if (osSignals) {
+				onSignal = () => {
+					if (stopping !== null) {
+						logger.warn("Second signal received, exiting now.");
+						process.exit(1);
+					}
+					this.stop();
+				};
+				process.once("SIGINT", onSignal);
+				process.once("SIGTERM", onSignal);
+				if (process.connected) process.once("disconnect", onDisconnect);
+			}
+			try {
+				await client.login(token);
+			} catch (error) {
+				await this.stop();
+				throw new LoginError(error);
+			}
+		},
+		stop() {
+			if (stopping !== null) return stopping;
+			stopping = (async () => {
+				signals.emit({ type: "shutdown" });
+				client.off(Events.InteractionCreate, onInteraction);
+				client.off(Events.ShardReady, gateway[Events.ShardReady]);
+				client.off(Events.ShardResume, gateway[Events.ShardResume]);
+				client.off(Events.ShardDisconnect, gateway[Events.ShardDisconnect]);
+				for (const { name, listener } of bindings) client.off(name, listener);
+				bindings = [];
+				if (onSignal !== null) {
+					process.off("SIGINT", onSignal);
+					process.off("SIGTERM", onSignal);
+					onSignal = null;
+				}
+				process.off("disconnect", onDisconnect);
+				await drain(inFlight, drainTimeout, logger);
+				if (globalStarted) await stopPlugins(plugins, app, logger, "stopGlobal");
+				await stopPlugins(plugins, app, logger, "stop");
+				if (process.send !== void 0) ignoreClosedChannel();
+				await client.destroy();
+			})();
+			return stopping;
+		},
+		update(manifest) {
+			state.manifest = manifest;
+			registerComponentRoutes(componentRoutes(manifest));
+			dispatch = createInteractionDispatcher(state);
+			if (started && stopping === null) {
+				for (const { name, listener } of bindings) client.off(name, listener);
+				bindings = bindEvents(state);
+			}
+		}
+	};
+	return runtime;
+}
+/** Runs `start` hooks in config order. Two plugins offering the same service is a startup failure. */
+async function startPlugins(plugins, app, services) {
+	const providers = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) {
+		let provided;
+		try {
+			provided = await plugin.start?.(app);
+		} catch (error) {
+			throw new PluginError(plugin.name, `start failed: ${describe(error)}`);
+		}
+		if (provided === void 0 || provided === null) continue;
+		if (typeof provided !== "object") throw new PluginError(plugin.name, `start must return an object of services or nothing.`);
+		for (const [name, service] of Object.entries(provided)) {
+			const owner = providers.get(name);
+			if (owner !== void 0) throw new PluginError(plugin.name, `provides service "${name}", which plugin "${owner}" already provides.`);
+			providers.set(name, plugin.name);
+			services[name] = service;
+		}
+	}
+}
+let ignoringClosedChannel = false;
+/**
+* discord.js's shard client reports gateway events to the manager with `process.send`, and
+* destroying the client produces some. If the manager has gone, each report fails with an
+* `error` event on `process` that would crash it. Only that failure is dropped; the listener
+* stays, since the failures arrive on a later tick.
+*/
+function ignoreClosedChannel() {
+	if (ignoringClosedChannel) return;
+	ignoringClosedChannel = true;
+	process.on("error", (error) => {
+		if (error.code !== "ERR_IPC_CHANNEL_CLOSED") throw error;
+	});
+}
+/** Runs `startGlobal` hooks in config order. */
+async function startGlobal(plugins, app) {
+	for (const plugin of plugins) try {
+		await plugin.startGlobal?.(app);
+	} catch (error) {
+		throw new PluginError(plugin.name, `startGlobal failed: ${describe(error)}`);
+	}
+}
+/** Runs `stopGlobal` or `stop` hooks in reverse order. A failing hook is logged; shutdown continues. */
+async function stopPlugins(plugins, app, logger, hook) {
+	for (const plugin of [...plugins].reverse()) try {
+		await plugin[hook]?.(app);
+	} catch (error) {
+		logger.error(`Plugin "${plugin.name}": ${hook} failed.`, {
+			plugin: plugin.name,
+			error
+		});
+	}
+}
+/**
+* Whether this process runs shard 0. Application-global hooks run there, so they run once
+* however the shards are spread over processes. `auto` means this process runs them all.
+*/
+function runsShardZero(shards) {
+	if (shards === void 0 || shards === "auto") return true;
+	return typeof shards === "number" ? shards === 0 : shards.includes(0);
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function drain(inFlight, timeout, logger) {
+	if (inFlight.size === 0) return;
+	let timer;
+	const expired = new Promise((resolve) => {
+		timer = setTimeout(() => resolve("timeout"), timeout);
+	});
+	const result = await Promise.race([Promise.allSettled([...inFlight]), expired]);
+	clearTimeout(timer);
+	if (result === "timeout") logger.warn(`${inFlight.size} interaction(s) still running after ${timeout}ms, shutting down anyway.`);
+}
+function componentRoutes(manifest) {
+	return manifest.routes.filter((r) => r.kind === "button" || r.kind === "select" || r.kind === "modal");
+}
+/** Absolute paths of every handler, middleware, and error boundary file a manifest refers to. */
+function manifestFiles(manifest, appDir) {
+	const files = /* @__PURE__ */ new Set();
+	for (const route of manifest.routes) {
+		files.add(route.file);
+		for (const file of route.middleware) files.add(file);
+		for (const file of route.errors) files.add(file);
+	}
+	return new Set([...files].map((file) => path.join(appDir, ...file.split("/"))));
+}
+function envFromProcess() {
+	const value = process.env.NODE_ENV;
+	return value === "production" || value === "test" ? value : "development";
+}
+//#endregion
+export { bindEvents as a, ModuleRegistry as c, createLogger as i, createSignals as l, createRuntime as n, createInteractionDispatcher as o, manifestFiles as r, HandlerLoadError as s, LoginError as t, loadManifest as u };
+
+//# sourceMappingURL=runtime-CZJeZvSL.js.map