@openclaw/discord 2026.7.2-beta.7 → 2026.7.33

package/dist/chunk-DX4jpFQP.js

@@ -1,3227 +0,0 @@
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-DdLPmPoa.js";
-import "node:module";
-import { ApplicationCommandOptionType, ApplicationCommandType, ButtonStyle, ComponentType, GatewayDispatchEvents, InteractionContextType, InteractionResponseType, InteractionType, MessageFlags, Routes, TextInputStyle } from "discord-api-types/v10";
-import { createHash } from "node:crypto";
-import { asDateTimestampMs, clampTimerTimeoutMs, parseFiniteNumber, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveIntegerOption, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { Type } from "typebox";
-import { Check } from "typebox/value";
-import { inspect } from "node:util";
-import { gunzipSync } from "node:zlib";
-import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { parseRetryAfterHeaderSeconds } from "openclaw/plugin-sdk/retry-runtime";
-import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
-import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
-import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
-import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-//#endregion
-//#region extensions/discord/src/internal/api.commands.ts
-async function listApplicationCommands(rest, clientId) {
-	return await rest.get(Routes.applicationCommands(clientId));
-}
-async function createApplicationCommand(rest, clientId, body) {
-	return await rest.post(Routes.applicationCommands(clientId), { body });
-}
-async function editApplicationCommand(rest, clientId, commandId, body) {
-	return await rest.patch(Routes.applicationCommand(clientId, commandId), { body });
-}
-async function deleteApplicationCommand(rest, clientId, commandId) {
-	await rest.delete(Routes.applicationCommand(clientId, commandId));
-}
-async function overwriteApplicationCommands(rest, clientId, body) {
-	await rest.put(Routes.applicationCommands(clientId), { body });
-}
-async function overwriteGuildApplicationCommands(rest, clientId, guildId, body) {
-	await rest.put(Routes.applicationGuildCommands(clientId, guildId), { body });
-}
-//#endregion
-//#region extensions/discord/src/internal/api.guild.ts
-async function getGuild(rest, guildId) {
-	return await rest.get(Routes.guild(guildId));
-}
-async function createGuildChannel(rest, guildId, data) {
-	return await rest.post(Routes.guildChannels(guildId), data);
-}
-async function moveGuildChannels(rest, guildId, data) {
-	await rest.patch(Routes.guildChannels(guildId), data);
-}
-async function getGuildMember(rest, guildId, userId) {
-	return await rest.get(Routes.guildMember(guildId, userId));
-}
-async function listGuildRoles(rest, guildId) {
-	return await rest.get(Routes.guildRoles(guildId));
-}
-async function listGuildChannels(rest, guildId) {
-	return await rest.get(Routes.guildChannels(guildId));
-}
-async function putChannelPermission(rest, channelId, targetId, data) {
-	await rest.put(Routes.channelPermission(channelId, targetId), data);
-}
-async function deleteChannelPermission(rest, channelId, targetId) {
-	await rest.delete(Routes.channelPermission(channelId, targetId));
-}
-async function listGuildActiveThreads(rest, guildId) {
-	return await rest.get(Routes.guildActiveThreads(guildId));
-}
-async function getGuildVoiceState(rest, guildId, userId) {
-	return await rest.get(Routes.guildVoiceState(guildId, userId));
-}
-async function listGuildScheduledEvents(rest, guildId) {
-	return await rest.get(Routes.guildScheduledEvents(guildId));
-}
-async function createGuildScheduledEvent(rest, guildId, body) {
-	return await rest.post(Routes.guildScheduledEvents(guildId), { body });
-}
-async function timeoutGuildMember(rest, guildId, userId, data) {
-	return await rest.patch(Routes.guildMember(guildId, userId), data);
-}
-async function addGuildMemberRole(rest, guildId, userId, roleId) {
-	await rest.put(Routes.guildMemberRole(guildId, userId, roleId));
-}
-async function removeGuildMemberRole(rest, guildId, userId, roleId) {
-	await rest.delete(Routes.guildMemberRole(guildId, userId, roleId));
-}
-async function removeGuildMember(rest, guildId, userId, data) {
-	await rest.delete(Routes.guildMember(guildId, userId), data);
-}
-async function createGuildBan(rest, guildId, userId, data) {
-	await rest.put(Routes.guildBan(guildId, userId), data);
-}
-async function listGuildEmojis(rest, guildId) {
-	return await rest.get(Routes.guildEmojis(guildId));
-}
-async function createGuildEmoji(rest, guildId, data) {
-	return await rest.post(Routes.guildEmojis(guildId), data);
-}
-async function createGuildSticker(rest, guildId, data) {
-	return await rest.post(Routes.guildStickers(guildId), data);
-}
-//#endregion
-//#region extensions/discord/src/internal/api.interactions.ts
-async function createInteractionCallback(rest, interactionId, token, body) {
-	return await rest.post(Routes.interactionCallback(interactionId, token), { body });
-}
-async function editWebhookMessage(rest, applicationId, token, messageId, data, query) {
-	return query ? await rest.patch(Routes.webhookMessage(applicationId, token, messageId), data, query) : await rest.patch(Routes.webhookMessage(applicationId, token, messageId), data);
-}
-async function deleteWebhookMessage(rest, applicationId, token, messageId) {
-	return await rest.delete(Routes.webhookMessage(applicationId, token, messageId));
-}
-async function getWebhookMessage(rest, applicationId, token, messageId) {
-	return await rest.get(Routes.webhookMessage(applicationId, token, messageId));
-}
-async function createWebhookMessage(rest, applicationId, token, data, query) {
-	return await rest.post(Routes.webhook(applicationId, token), data, query);
-}
-//#endregion
-//#region extensions/discord/src/internal/api.messages.ts
-async function getChannel(rest, channelId) {
-	return await rest.get(Routes.channel(channelId));
-}
-async function getThreadMember(rest, threadId, userId) {
-	return await rest.get(Routes.threadMembers(threadId, userId));
-}
-async function editChannel(rest, channelId, data) {
-	return await rest.patch(Routes.channel(channelId), data);
-}
-async function deleteChannel(rest, channelId) {
-	await rest.delete(Routes.channel(channelId));
-}
-async function listChannelMessages(rest, channelId, query) {
-	return await rest.get(Routes.channelMessages(channelId), query);
-}
-async function getChannelMessage(rest, channelId, messageId) {
-	return await rest.get(Routes.channelMessage(channelId, messageId));
-}
-async function createChannelMessage(rest, channelId, data) {
-	return await rest.post(Routes.channelMessages(channelId), data);
-}
-async function editChannelMessage(rest, channelId, messageId, data) {
-	return await rest.patch(Routes.channelMessage(channelId, messageId), data);
-}
-async function deleteChannelMessage(rest, channelId, messageId) {
-	await rest.delete(Routes.channelMessage(channelId, messageId));
-}
-async function pinChannelMessage(rest, channelId, messageId) {
-	await rest.put(Routes.channelPin(channelId, messageId));
-}
-async function unpinChannelMessage(rest, channelId, messageId) {
-	await rest.delete(Routes.channelPin(channelId, messageId));
-}
-async function listChannelPins(rest, channelId) {
-	return await rest.get(Routes.channelPins(channelId));
-}
-async function sendChannelTyping(rest, channelId) {
-	await rest.post(Routes.channelTyping(channelId));
-}
-async function createThread(rest, channelId, data, messageId) {
-	const route = messageId ? Routes.threads(channelId, messageId) : Routes.threads(channelId);
-	return await rest.post(route, data);
-}
-async function listChannelArchivedThreads(rest, channelId, query) {
-	return await rest.get(Routes.channelThreads(channelId, "public"), query);
-}
-async function searchGuildMessages(rest, guildId, params) {
-	return await rest.get(`/guilds/${guildId}/messages/search?${params.toString()}`);
-}
-//#endregion
-//#region extensions/discord/src/internal/api.reactions.ts
-async function createOwnMessageReaction(rest, channelId, messageId, encodedEmoji) {
-	await rest.put(Routes.channelMessageOwnReaction(channelId, messageId, encodedEmoji));
-}
-async function deleteOwnMessageReaction(rest, channelId, messageId, encodedEmoji) {
-	await rest.delete(Routes.channelMessageOwnReaction(channelId, messageId, encodedEmoji));
-}
-async function listMessageReactionUsers(rest, channelId, messageId, encodedEmoji, query) {
-	return await rest.get(Routes.channelMessageReaction(channelId, messageId, encodedEmoji), query);
-}
-//#endregion
-//#region extensions/discord/src/internal/api.users.ts
-async function getCurrentUser(rest) {
-	return await rest.get(Routes.user("@me"));
-}
-async function getUser(rest, userId) {
-	return await rest.get(Routes.user(userId));
-}
-async function createUserDmChannel(rest, recipientId) {
-	return await rest.post(Routes.userChannels(), { body: { recipient_id: recipientId } });
-}
-//#endregion
-//#region extensions/discord/src/internal/api.webhooks.ts
-async function createChannelWebhook(rest, channelId, data) {
-	return await rest.post(Routes.channelWebhooks(channelId), data);
-}
-//#endregion
-//#region extensions/discord/src/internal/command-comparison.ts
-const unorderedCommandArrayFields = /* @__PURE__ */ new Set([
-	"channel_types",
-	"contexts",
-	"integration_types"
-]);
-const optionComparisonOmittedFields = /* @__PURE__ */ new Set([
-	"contexts",
-	"default_member_permissions",
-	"description_localized",
-	"integration_types",
-	"name_localized"
-]);
-const nullableLocalizationFields = /* @__PURE__ */ new Set(["description_localizations", "name_localizations"]);
-function comparableCommand(value) {
-	if (!value || typeof value !== "object") return value;
-	const omit = /* @__PURE__ */ new Set([
-		"application_id",
-		"description_localized",
-		"dm_permission",
-		"guild_id",
-		"id",
-		"name_localized",
-		"nsfw",
-		"version",
-		"default_permission"
-	]);
-	return stableComparableObject(Object.fromEntries(Object.entries(value).filter(([key, entry]) => !omit.has(key) && entry !== void 0)));
-}
-function stableComparableObject(value, pathValue = []) {
-	if (Array.isArray(value)) {
-		const normalized = value.map((entry) => stableComparableObject(entry, pathValue));
-		const key = pathValue.at(-1);
-		if (key && unorderedCommandArrayFields.has(key) && normalized.every((entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean")) return normalized.toSorted((left, right) => String(left).localeCompare(String(right)));
-		return normalized;
-	}
-	if (!value || typeof value !== "object") return value;
-	return Object.fromEntries(Object.entries(value).filter(([key, entry]) => {
-		if (entry === void 0) return false;
-		if (entry === null && nullableLocalizationFields.has(key)) return false;
-		if (pathValue.includes("options") && optionComparisonOmittedFields.has(key)) return false;
-		if ((key === "required" || key === "autocomplete") && entry === false) return false;
-		return true;
-	}).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, shouldNormalizeDescriptionValue(pathValue, key, entry) ? normalizeDescriptionForComparison(entry) : stableComparableObject(entry, [...pathValue, key])]));
-}
-function shouldNormalizeDescriptionValue(pathLocal, key, entry) {
-	return typeof entry === "string" && (key === "description" || pathLocal.at(-1) === "description_localizations");
-}
-/**
-* Normalize descriptions to match Discord's server-side storage semantics.
-* Discord collapses whitespace and removes whitespace between CJK characters.
-*/
-function normalizeDescriptionForComparison(description) {
-	const collapsed = description.replace(/\s+/g, " ");
-	const cjkBoundaryWhitespace = /([\u3000-\u303F\u4E00-\u9FFF\uFF00-\uFFEF])\s+([\u3000-\u303F\u4E00-\u9FFF\uFF00-\uFFEF])/g;
-	return collapsed.replace(cjkBoundaryWhitespace, "$1$2").replace(cjkBoundaryWhitespace, "$1$2").trim();
-}
-function commandsEqual(a, b) {
-	return JSON.stringify(comparableCommand(a)) === JSON.stringify(comparableCommand(b));
-}
-//#endregion
-//#region extensions/discord/src/internal/command-deploy.ts
-const DISCORD_APPLICATION_COMMAND_LIMIT_REACHED = 30032;
-var DiscordCommandDeployer = class {
-	constructor(params) {
-		this.params = params;
-		this.hashes = /* @__PURE__ */ new Map();
-		this.loadedKeys = /* @__PURE__ */ new Set();
-	}
-	async getCommands() {
-		return await listApplicationCommands(this.rest, this.params.clientId);
-	}
-	async deploy(options = {}) {
-		const commands = this.params.commands.filter((command) => command.name !== "*");
-		const serializedGlobal = commands.filter((command) => !command.guildIds).map((command) => command.serialize());
-		for (const [guildId, entries] of groupGuildCommands(commands)) await this.putCommandSetIfChanged(this.scopedCacheKey(`guild:${guildId}`), entries, async () => {
-			await overwriteGuildApplicationCommands(this.rest, this.params.clientId, guildId, entries);
-		}, options);
-		if (this.params.devGuilds?.length) {
-			for (const guildId of this.params.devGuilds) {
-				const entries = commands.map((command) => command.serialize());
-				await this.putCommandSetIfChanged(this.scopedCacheKey(`dev-guild:${guildId}`), entries, async () => {
-					await overwriteGuildApplicationCommands(this.rest, this.params.clientId, guildId, entries);
-				}, options);
-			}
-			return {
-				mode: options.mode ?? "reconcile",
-				usedDevGuilds: true
-			};
-		}
-		if (options.mode !== "overwrite") {
-			await this.putCommandSetIfChanged(this.scopedCacheKey("global:reconcile"), serializedGlobal, async () => {
-				await this.reconcileGlobalCommands(serializedGlobal);
-			}, options);
-			return {
-				mode: "reconcile",
-				usedDevGuilds: false
-			};
-		}
-		await this.putCommandSetIfChanged(this.scopedCacheKey("global:overwrite"), serializedGlobal, async () => {
-			await overwriteApplicationCommands(this.rest, this.params.clientId, serializedGlobal);
-		}, options);
-		return {
-			mode: "overwrite",
-			usedDevGuilds: false
-		};
-	}
-	/**
-	* Scope cache keys by Discord application id so multi-bot setups that share a
-	* single command-deploy store still reconcile each application separately. The
-	* prior unscoped `global:reconcile` / `guild:<id>` keys let a later account
-	* with an identical command set reuse the first account's hash and skip its
-	* own application's reconcile entirely (#77359).
-	*/
-	scopedCacheKey(suffix) {
-		return `app:${this.params.clientId}:${suffix}`;
-	}
-	async reconcileGlobalCommands(desired) {
-		const existing = await this.getCommands();
-		const existingByKey = new Map(existing.map((command) => [stableCommandKey(command), command]));
-		const desiredCommands = desired.map((command) => ({
-			command,
-			key: stableCommandKey(command)
-		}));
-		const desiredKeys = new Set(desiredCommands.map(({ key }) => key));
-		for (const { command, key } of desiredCommands) {
-			const current = existingByKey.get(key);
-			if (current && !commandsEqual(current, command)) await editApplicationCommand(this.rest, this.params.clientId, current.id, command);
-		}
-		for (const { command, key } of desiredCommands) {
-			if (existingByKey.has(key)) continue;
-			try {
-				await createApplicationCommand(this.rest, this.params.clientId, command);
-			} catch (error) {
-				if (!isApplicationCommandLimitError(error)) throw error;
-				await overwriteApplicationCommands(this.rest, this.params.clientId, desired);
-				return;
-			}
-		}
-		for (const command of existing) if (!desiredKeys.has(stableCommandKey(command))) await deleteApplicationCommand(this.rest, this.params.clientId, command.id);
-	}
-	async putCommandSetIfChanged(key, commands, deploy, options) {
-		const hash = stableCommandSetHash(commands);
-		await this.loadPersistedHash(key);
-		if (!options.force && this.hashes.get(key) === hash) return;
-		await deploy();
-		this.hashes.set(key, hash);
-		try {
-			await this.params.hashStore?.register(key, hash);
-		} catch {}
-	}
-	async loadPersistedHash(key) {
-		if (this.loadedKeys.has(key)) return;
-		this.loadedKeys.add(key);
-		try {
-			const hash = await this.params.hashStore?.lookup(key);
-			if (typeof hash === "string" && hash.trim()) this.hashes.set(key, hash);
-		} catch {}
-	}
-	get rest() {
-		return this.params.rest();
-	}
-};
-function groupGuildCommands(commands) {
-	const guildCommands = /* @__PURE__ */ new Map();
-	for (const command of commands.filter((entry) => entry.guildIds)) for (const guildId of command.guildIds ?? []) {
-		const entries = guildCommands.get(guildId) ?? [];
-		entries.push(command.serialize());
-		guildCommands.set(guildId, entries);
-	}
-	return guildCommands;
-}
-function stableCommandKey(command) {
-	return `${command.type ?? ApplicationCommandType.ChatInput}:${command.name}`;
-}
-function isApplicationCommandLimitError(error) {
-	return error !== null && typeof error === "object" && "discordCode" in error && error.discordCode === DISCORD_APPLICATION_COMMAND_LIMIT_REACHED;
-}
-function stableCommandSetHash(commands) {
-	const stable = commands.map((command) => stableComparableObject(command)).toSorted((a, b) => stableCommandKey(a).localeCompare(stableCommandKey(b)));
-	return createHash("sha256").update(JSON.stringify(stable)).digest("hex");
-}
-//#endregion
-//#region extensions/discord/src/internal/components.base.ts
-function parseCustomId(id) {
-	const [rawKeyValue, ...parts] = id.split(";");
-	const rawKey = expectDefined(rawKeyValue, "custom id split first segment");
-	const [keyPart, firstValue] = rawKey.split("=");
-	const definedKeyPart = expectDefined(keyPart, "custom id key segment");
-	const key = definedKeyPart.includes(":") ? expectDefined(definedKeyPart.split(":").at(0), "namespaced custom id key") : definedKeyPart;
-	const data = {};
-	const entries = firstValue === void 0 ? parts : [rawKey.slice(key.length + 1), ...parts];
-	for (const entry of entries) {
-		const index = entry.indexOf("=");
-		if (index < 0) continue;
-		const name = entry.slice(0, index).replace(/^[^:]+:/, "");
-		const raw = entry.slice(index + 1);
-		data[name] = raw === "true" ? true : raw === "false" ? false : raw;
-	}
-	return {
-		key,
-		data
-	};
-}
-function clean$3(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-function colorToNumber(value) {
-	if (typeof value === "number") return Number.isInteger(value) && value >= 0 && value <= 16777215 ? value : void 0;
-	if (typeof value === "string" && /^#?[0-9a-f]{6}$/i.test(value)) return Number.parseInt(value.replace(/^#/, ""), 16);
-}
-var BaseComponent = class {
-	constructor() {
-		this.isV2 = false;
-	}
-};
-var BaseMessageInteractiveComponent = class extends BaseComponent {
-	constructor(..._args) {
-		super(..._args);
-		this.isV2 = false;
-		this.defer = false;
-		this.ephemeral = false;
-		this.customIdParser = parseCustomId;
-	}
-	run(_interaction, _data) {}
-};
-var BaseModalComponent = class extends BaseComponent {};
-//#endregion
-//#region extensions/discord/src/internal/components.message.ts
-var BaseButton = class extends BaseMessageInteractiveComponent {
-	constructor(..._args) {
-		super(..._args);
-		this.type = ComponentType.Button;
-		this.style = ButtonStyle.Primary;
-		this.disabled = false;
-	}
-};
-var Button = class extends BaseButton {
-	serialize() {
-		return clean$3({
-			type: this.type,
-			style: this.style,
-			custom_id: this.customId,
-			label: this.label,
-			emoji: this.emoji,
-			disabled: this.disabled || void 0
-		});
-	}
-};
-var LinkButton = class extends BaseButton {
-	constructor(..._args2) {
-		super(..._args2);
-		this.customId = "";
-		this.style = ButtonStyle.Link;
-	}
-	async run() {
-		throw new Error("Link buttons do not run handlers");
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			style: this.style,
-			label: this.label,
-			emoji: this.emoji,
-			disabled: this.disabled || void 0,
-			url: this.url
-		});
-	}
-};
-var AnySelectMenu = class extends BaseMessageInteractiveComponent {
-	constructor(..._args3) {
-		super(..._args3);
-		this.disabled = false;
-	}
-	serialize() {
-		return clean$3({
-			...this.serializeOptions(),
-			custom_id: this.customId,
-			placeholder: this.placeholder,
-			min_values: this.minValues,
-			max_values: this.maxValues,
-			disabled: this.disabled || void 0,
-			required: this.required
-		});
-	}
-};
-var StringSelectMenu = class extends AnySelectMenu {
-	constructor(..._args4) {
-		super(..._args4);
-		this.type = ComponentType.StringSelect;
-	}
-	serializeOptions() {
-		return {
-			type: this.type,
-			options: this.options
-		};
-	}
-};
-var UserSelectMenu = class extends AnySelectMenu {
-	constructor(..._args5) {
-		super(..._args5);
-		this.type = ComponentType.UserSelect;
-	}
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues
-		};
-	}
-};
-var RoleSelectMenu = class extends AnySelectMenu {
-	constructor(..._args6) {
-		super(..._args6);
-		this.type = ComponentType.RoleSelect;
-	}
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues
-		};
-	}
-};
-var MentionableSelectMenu = class extends AnySelectMenu {
-	constructor(..._args7) {
-		super(..._args7);
-		this.type = ComponentType.MentionableSelect;
-	}
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues
-		};
-	}
-};
-var ChannelSelectMenu = class extends AnySelectMenu {
-	constructor(..._args8) {
-		super(..._args8);
-		this.type = ComponentType.ChannelSelect;
-	}
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues,
-			channel_types: this.channelTypes
-		};
-	}
-};
-var Row = class extends BaseComponent {
-	constructor(components = []) {
-		super();
-		this.type = ComponentType.ActionRow;
-		this.isV2 = false;
-		this.components = components;
-	}
-	addComponent(component) {
-		this.components.push(component);
-	}
-	serialize() {
-		return {
-			type: this.type,
-			components: this.components.map((entry) => entry.serialize())
-		};
-	}
-};
-var TextDisplay = class extends BaseComponent {
-	constructor(content) {
-		super();
-		this.content = content;
-		this.type = ComponentType.TextDisplay;
-		this.isV2 = true;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			content: this.content
-		});
-	}
-};
-var Separator = class extends BaseComponent {
-	constructor(options) {
-		super();
-		this.type = ComponentType.Separator;
-		this.isV2 = true;
-		this.divider = true;
-		this.spacing = "small";
-		this.spacing = options?.spacing ?? this.spacing;
-		this.divider = options?.divider ?? this.divider;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			divider: this.divider,
-			spacing: this.spacing === "large" ? 2 : this.spacing === "small" ? 1 : this.spacing
-		});
-	}
-};
-var Thumbnail = class extends BaseComponent {
-	constructor(url) {
-		super();
-		this.url = url;
-		this.type = ComponentType.Thumbnail;
-		this.isV2 = true;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			media: this.url ? { url: this.url } : void 0
-		});
-	}
-};
-var Section = class extends BaseComponent {
-	constructor(components = [], accessory) {
-		super();
-		this.components = components;
-		this.accessory = accessory;
-		this.type = ComponentType.Section;
-		this.isV2 = true;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			components: this.components.map((entry) => entry.serialize()),
-			accessory: this.accessory?.serialize()
-		});
-	}
-};
-var MediaGallery = class extends BaseComponent {
-	constructor(items = []) {
-		super();
-		this.items = items;
-		this.type = ComponentType.MediaGallery;
-		this.isV2 = true;
-	}
-	serialize() {
-		return {
-			type: this.type,
-			items: this.items.map((entry) => ({
-				media: { url: entry.url },
-				description: entry.description,
-				spoiler: entry.spoiler
-			}))
-		};
-	}
-};
-var File = class extends BaseComponent {
-	constructor(file, spoiler = false) {
-		super();
-		this.file = file;
-		this.spoiler = spoiler;
-		this.type = ComponentType.File;
-		this.isV2 = true;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			file: this.file ? { url: this.file } : void 0,
-			spoiler: this.spoiler || void 0
-		});
-	}
-};
-var Container = class extends BaseComponent {
-	constructor(components = [], options) {
-		super();
-		this.type = ComponentType.Container;
-		this.isV2 = true;
-		this.spoiler = false;
-		this.components = components;
-		this.accentColor = options?.accentColor;
-		this.spoiler = options?.spoiler ?? false;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			components: this.components.map((entry) => entry.serialize()),
-			accent_color: colorToNumber(this.accentColor),
-			spoiler: this.spoiler || void 0
-		});
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/components.modal.ts
-var TextInput = class extends BaseModalComponent {
-	constructor(..._args) {
-		super(..._args);
-		this.type = ComponentType.TextInput;
-		this.customIdParser = parseCustomId;
-		this.style = TextInputStyle.Short;
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			custom_id: this.customId,
-			style: this.style,
-			min_length: this.minLength,
-			max_length: this.maxLength,
-			required: this.required,
-			value: this.value,
-			placeholder: this.placeholder
-		});
-	}
-};
-var CheckboxGroup = class extends BaseModalComponent {
-	constructor(..._args2) {
-		super(..._args2);
-		this.type = 22;
-		this.options = [];
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			custom_id: this.customId,
-			options: this.options,
-			required: this.required,
-			min_values: this.minValues,
-			max_values: this.maxValues
-		});
-	}
-};
-var RadioGroup = class extends BaseModalComponent {
-	constructor(..._args3) {
-		super(..._args3);
-		this.type = 21;
-		this.options = [];
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			custom_id: this.customId,
-			options: this.options,
-			required: this.required,
-			min_values: this.minValues,
-			max_values: this.maxValues
-		});
-	}
-};
-var Label = class extends BaseModalComponent {
-	constructor(component) {
-		super();
-		this.component = component;
-		this.type = ComponentType.Label;
-		this.customId = "";
-	}
-	serialize() {
-		return clean$3({
-			type: this.type,
-			label: this.label,
-			description: this.description,
-			component: this.component?.serialize()
-		});
-	}
-};
-var Modal = class {
-	constructor() {
-		this.components = [];
-		this.customIdParser = parseCustomId;
-	}
-	serialize() {
-		return {
-			title: this.title,
-			custom_id: this.customId,
-			components: this.components.map((entry) => entry.serialize())
-		};
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/embeds.ts
-function clean$2(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-var Embed = class {
-	constructor(embed) {
-		Object.assign(this, embed);
-	}
-	serialize() {
-		return clean$2({
-			title: this.title,
-			description: this.description,
-			url: this.url,
-			timestamp: this.timestamp,
-			color: this.color,
-			footer: this.footer,
-			image: typeof this.image === "string" ? { url: this.image } : this.image,
-			thumbnail: typeof this.thumbnail === "string" ? { url: this.thumbnail } : this.thumbnail,
-			author: this.author,
-			fields: this.fields
-		});
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/payload.ts
-function clean$1(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-function serializeAnyComponent(component) {
-	return component.serialize();
-}
-function payloadHasV2Components(payload) {
-	return Boolean(payload.components?.some((component) => component.isV2));
-}
-function normalizePayloadFlags(payload) {
-	const flags = payload.ephemeral ? (payload.flags ?? 0) | MessageFlags.Ephemeral : payload.flags;
-	if (!payloadHasV2Components(payload)) return flags;
-	if (payload.content || payload.embeds?.length) throw new Error("Discord Components V2 payloads cannot include content or embeds");
-	return (flags ?? 0) | MessageFlags.IsComponentsV2;
-}
-function serializePayload(payload) {
-	if (typeof payload === "string") return { content: payload };
-	const flags = normalizePayloadFlags(payload);
-	return clean$1({
-		content: payload.content,
-		embeds: payload.embeds?.map((entry) => "serialize" in entry ? entry.serialize() : entry),
-		components: payload.components?.map((entry) => serializeAnyComponent(entry)),
-		allowed_mentions: payload.allowed_mentions ?? payload.allowedMentions,
-		flags,
-		tts: payload.tts,
-		files: payload.files,
-		poll: payload.poll,
-		sticker_ids: payload.stickers
-	});
-}
-//#endregion
-//#region extensions/discord/src/internal/component-registry.ts
-var ComponentRegistry = class {
-	constructor() {
-		this.entries = /* @__PURE__ */ new Map();
-		this.oneOffComponents = /* @__PURE__ */ new Map();
-		this.wildcardEntries = [];
-	}
-	register(entry) {
-		const key = parseRegistryKey(entry.customId, entry.customIdParser);
-		if (key === "*") {
-			if (!this.wildcardEntries.includes(entry)) this.wildcardEntries.push(entry);
-			return;
-		}
-		const entries = this.entries.get(key) ?? [];
-		if (!entries.includes(entry)) {
-			entries.push(entry);
-			this.entries.set(key, entries);
-		}
-	}
-	resolve(customId, options) {
-		for (const entries of this.entries.values()) {
-			const match = entries.find((entry) => {
-				if (options?.componentType !== void 0 && entry.type !== options.componentType) return false;
-				const parser = entry.customIdParser ?? parseCustomId;
-				return parseRegistryKey(entry.customId, parser) === parseRegistryKey(customId, parser);
-			});
-			if (match) return match;
-		}
-		return this.wildcardEntries.find((entry) => {
-			if (options?.componentType !== void 0 && entry.type !== options.componentType) return false;
-			return true;
-		});
-	}
-	waitForMessageComponent(message, timeoutMs) {
-		const key = createOneOffComponentKey(message.id, message.channelId);
-		return new Promise((resolve) => {
-			const existing = this.oneOffComponents.get(key);
-			if (existing) {
-				clearTimeout(existing.timer);
-				existing.resolve({
-					success: false,
-					message,
-					reason: "timed out"
-				});
-			}
-			const timer = setTimeout(() => {
-				this.oneOffComponents.delete(key);
-				resolve({
-					success: false,
-					message,
-					reason: "timed out"
-				});
-			}, resolveTimerTimeoutMs(timeoutMs, 0, 0));
-			timer.unref?.();
-			this.oneOffComponents.set(key, {
-				message,
-				timer,
-				resolve
-			});
-		});
-	}
-	resolveOneOffComponent(params) {
-		if (!params.messageId || !params.channelId) return false;
-		const key = createOneOffComponentKey(params.messageId, params.channelId);
-		const entry = this.oneOffComponents.get(key);
-		if (!entry) return false;
-		clearTimeout(entry.timer);
-		this.oneOffComponents.delete(key);
-		entry.resolve({
-			success: true,
-			customId: params.customId,
-			message: entry.message,
-			values: params.values
-		});
-		return true;
-	}
-};
-function parseRegistryKey(customId, parser = parseCustomId) {
-	return parser(customId).key;
-}
-function createOneOffComponentKey(messageId, channelId) {
-	return `${messageId}:${channelId}`;
-}
-//#endregion
-//#region extensions/discord/src/internal/structures.ts
-var Base = class {
-	constructor(client) {
-		this.client = client;
-	}
-};
-var User = class extends Base {
-	constructor(client, rawDataOrId) {
-		super(client);
-		this.rawDataValue = typeof rawDataOrId === "string" ? null : rawDataOrId;
-		this.id = typeof rawDataOrId === "string" ? rawDataOrId : rawDataOrId.id;
-	}
-	get rawData() {
-		if (!this.rawDataValue) throw new Error("Partial Discord user has no raw data");
-		return this.rawDataValue;
-	}
-	get partial() {
-		return this.rawDataValue === null;
-	}
-	get username() {
-		return this.rawDataValue?.username ?? "";
-	}
-	get globalName() {
-		return this.rawDataValue?.global_name;
-	}
-	get discriminator() {
-		return this.rawDataValue?.discriminator;
-	}
-	get bot() {
-		return this.rawDataValue?.bot;
-	}
-	get avatar() {
-		return this.rawDataValue?.avatar;
-	}
-	get avatarUrl() {
-		return this.avatar ? `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.png` : null;
-	}
-	toString() {
-		return `<@${this.id}>`;
-	}
-	async fetch() {
-		return this.client.fetchUser(this.id);
-	}
-	async createDm() {
-		return await createUserDmChannel(this.client.rest, this.id);
-	}
-	async send(data) {
-		const dm = await this.createDm();
-		const message = await createChannelMessage(this.client.rest, dm.id, { body: serializePayload(data) });
-		return new Message(this.client, message);
-	}
-};
-var Role = class extends Base {
-	constructor(client, rawDataOrId) {
-		super(client);
-		this.rawDataValue = typeof rawDataOrId === "string" ? null : rawDataOrId;
-		this.id = typeof rawDataOrId === "string" ? rawDataOrId : rawDataOrId.id;
-	}
-	get name() {
-		return this.rawDataValue?.name ?? "";
-	}
-};
-var Guild = class extends Base {
-	constructor(client, rawDataOrId) {
-		super(client);
-		this.rawDataValue = typeof rawDataOrId === "string" ? null : rawDataOrId;
-		this.id = typeof rawDataOrId === "string" ? rawDataOrId : rawDataOrId.id;
-	}
-	get name() {
-		return this.rawDataValue?.name ?? "";
-	}
-};
-var GuildMember = class extends Base {
-	constructor(client, rawData) {
-		super(client);
-		this.rawData = rawData;
-	}
-	get user() {
-		return this.rawData.user ? new User(this.client, this.rawData.user) : null;
-	}
-	get roles() {
-		return this.rawData.roles ?? [];
-	}
-	get nickname() {
-		return this.rawData.nick ?? void 0;
-	}
-};
-var Message = class Message extends Base {
-	constructor(client, rawDataOrIds) {
-		super(client);
-		this.rawDataValue = typeof rawDataOrIds === "string" || !("author" in rawDataOrIds) ? null : rawDataOrIds;
-		this.id = typeof rawDataOrIds === "string" ? rawDataOrIds : rawDataOrIds.id;
-		this.channelId = typeof rawDataOrIds === "string" ? "" : "channel_id" in rawDataOrIds ? rawDataOrIds.channel_id : rawDataOrIds.channelId ?? "";
-	}
-	get rawData() {
-		if (!this.rawDataValue) throw new Error("Partial Discord message has no raw data");
-		return this.rawDataValue;
-	}
-	get partial() {
-		return this.rawDataValue === null;
-	}
-	get message() {
-		return this;
-	}
-	get channel_id() {
-		return this.channelId;
-	}
-	get guild_id() {
-		return this.rawDataValue?.guild_id;
-	}
-	get guild() {
-		return this.guild_id ? new Guild(this.client, this.guild_id) : null;
-	}
-	get webhookId() {
-		return this.webhook_id;
-	}
-	get webhook_id() {
-		return this.rawDataValue?.webhook_id ?? null;
-	}
-	get member() {
-		const member = this.rawDataValue?.member;
-		return member ? new GuildMember(this.client, member) : null;
-	}
-	get rawMember() {
-		return this.rawDataValue?.member;
-	}
-	get content() {
-		return this.rawDataValue?.content ?? "";
-	}
-	get author() {
-		return this.rawDataValue?.author ? new User(this.client, this.rawDataValue.author) : null;
-	}
-	get embeds() {
-		return this.rawDataValue?.embeds ?? [];
-	}
-	get attachments() {
-		return this.rawDataValue?.attachments ?? [];
-	}
-	get stickers() {
-		return this.rawDataValue?.sticker_items ?? [];
-	}
-	get mentionedUsers() {
-		return (this.rawDataValue?.mentions ?? []).map((user) => new User(this.client, user));
-	}
-	get mentionedRoles() {
-		return this.rawDataValue?.mention_roles ?? [];
-	}
-	get mentionedEveryone() {
-		return this.rawDataValue?.mention_everyone ?? false;
-	}
-	get timestamp() {
-		return this.rawDataValue?.timestamp;
-	}
-	get type() {
-		return this.rawDataValue?.type;
-	}
-	get messageReference() {
-		return this.rawDataValue?.message_reference;
-	}
-	get referencedMessage() {
-		return this.rawDataValue?.referenced_message ? new Message(this.client, this.rawDataValue.referenced_message) : null;
-	}
-	get thread() {
-		return this.rawDataValue?.thread ? channelFactory(this.client, this.rawDataValue.thread) : null;
-	}
-	async fetch() {
-		const raw = await getChannelMessage(this.client.rest, this.channelId, this.id);
-		return new Message(this.client, raw);
-	}
-	async delete() {
-		await deleteChannelMessage(this.client.rest, this.channelId, this.id);
-	}
-	async edit(data) {
-		const raw = await editChannelMessage(this.client.rest, this.channelId, this.id, { body: serializePayload(data) });
-		return new Message(this.client, raw);
-	}
-	async reply(data) {
-		const raw = await createChannelMessage(this.client.rest, this.channelId, { body: {
-			...serializePayload(data),
-			message_reference: {
-				message_id: this.id,
-				fail_if_not_exists: false
-			}
-		} });
-		return new Message(this.client, raw);
-	}
-	async pin() {
-		await pinChannelMessage(this.client.rest, this.channelId, this.id);
-	}
-	async unpin() {
-		await unpinChannelMessage(this.client.rest, this.channelId, this.id);
-	}
-};
-function channelFactory(clientForTest, channelData, _partial) {
-	return {
-		...channelData,
-		rawData: channelData,
-		guildId: "guild_id" in channelData ? channelData.guild_id : void 0,
-		guild: "guild_id" in channelData && typeof channelData.guild_id === "string" ? new Guild(clientForTest, channelData.guild_id) : void 0,
-		parentId: "parent_id" in channelData ? channelData.parent_id : void 0,
-		ownerId: "owner_id" in channelData ? channelData.owner_id : void 0
-	};
-}
-//#endregion
-//#region extensions/discord/src/internal/entity-cache.ts
-const DEFAULT_REST_CACHE_TTL_MS = 3e4;
-const DEFAULT_MAX_ENTRIES = 5e3;
-const DEFAULT_SWEEP_INTERVAL_MS = 3e4;
-var DiscordEntityCache = class {
-	constructor(params) {
-		this.params = params;
-		this.entries = /* @__PURE__ */ new Map();
-		this.lastSweepAt = 0;
-	}
-	get size() {
-		return this.entries.size;
-	}
-	async fetchUser(id) {
-		return await this.fetchCached(`user:${id}`, async () => {
-			const raw = await getUser(this.rest, id);
-			return new User(this.params.client, raw);
-		});
-	}
-	async fetchChannel(id) {
-		return await this.fetchCached(`channel:${id}`, async () => {
-			const raw = await getChannel(this.rest, id);
-			return channelFactory(this.params.client, raw);
-		});
-	}
-	async fetchGuild(id) {
-		return await this.fetchCached(`guild:${id}`, async () => {
-			const raw = await getGuild(this.rest, id);
-			return new Guild(this.params.client, raw);
-		});
-	}
-	async fetchMember(guildId, userId) {
-		return await this.fetchCached(`member:${guildId}:${userId}`, async () => {
-			const raw = await getGuildMember(this.rest, guildId, userId);
-			return new GuildMember(this.params.client, raw);
-		});
-	}
-	invalidateForGatewayEvent(type, data) {
-		const raw = data && typeof data === "object" ? data : {};
-		const channelUpdate = GatewayDispatchEvents.ChannelUpdate;
-		const channelDelete = GatewayDispatchEvents.ChannelDelete;
-		const guildUpdate = GatewayDispatchEvents.GuildUpdate;
-		const guildMemberUpdate = GatewayDispatchEvents.GuildMemberUpdate;
-		if (type === channelUpdate || type === channelDelete) this.deleteId("channel", raw.id);
-		if (type === guildUpdate) this.deleteId("guild", raw.id);
-		if (type === guildMemberUpdate) {
-			const guildId = raw.guild_id;
-			const user = raw.user && typeof raw.user === "object" ? raw.user : {};
-			if (typeof guildId === "string" && typeof user.id === "string") {
-				this.entries.delete(`member:${guildId}:${user.id}`);
-				this.entries.delete(`user:${user.id}`);
-			}
-		}
-	}
-	deleteId(prefix, id) {
-		if (typeof id === "string") this.entries.delete(`${prefix}:${id}`);
-	}
-	async fetchCached(key, fetcher) {
-		const ttl = this.params.ttlMs ?? DEFAULT_REST_CACHE_TTL_MS;
-		const rawNow = Date.now();
-		const now = asDateTimestampMs(rawNow);
-		if (ttl > 0) {
-			const cached = this.entries.get(key);
-			if (cached && now !== void 0 && cached.expiresAt > now) return cached.value;
-			if (cached) this.entries.delete(key);
-		}
-		const value = await fetcher();
-		if (ttl > 0) {
-			const expiresAt = resolveExpiresAtMsFromDurationMs(ttl, { nowMs: rawNow });
-			if (expiresAt !== void 0) {
-				if (now !== void 0) this.maybeSweepExpired(now);
-				this.entries.set(key, {
-					expiresAt,
-					value
-				});
-				this.enforceMaxEntries();
-			}
-		}
-		return value;
-	}
-	maybeSweepExpired(now) {
-		const interval = this.params.sweepIntervalMs ?? DEFAULT_SWEEP_INTERVAL_MS;
-		if (now - this.lastSweepAt < interval) return;
-		this.lastSweepAt = now;
-		for (const [key, entry] of this.entries) if (entry.expiresAt <= now) this.entries.delete(key);
-	}
-	enforceMaxEntries() {
-		const max = this.params.maxEntries ?? DEFAULT_MAX_ENTRIES;
-		if (this.entries.size <= max) return;
-		const toRemove = this.entries.size - max;
-		let removed = 0;
-		for (const key of this.entries.keys()) {
-			if (removed >= toRemove) break;
-			this.entries.delete(key);
-			removed += 1;
-		}
-	}
-	get rest() {
-		return typeof this.params.rest === "function" ? this.params.rest() : this.params.rest;
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/event-queue.ts
-const DEFAULT_MAX_QUEUE_SIZE = 1e4;
-const DEFAULT_MAX_CONCURRENCY = 50;
-const DEFAULT_LISTENER_TIMEOUT_MS = 12e4;
-const DEFAULT_SLOW_LISTENER_THRESHOLD_MS = 3e4;
-var DiscordEventQueue = class {
-	constructor(options = {}) {
-		this.queue = [];
-		this.queueHead = 0;
-		this.processing = 0;
-		this.processedCount = 0;
-		this.droppedCount = 0;
-		this.timeoutCount = 0;
-		this.options = {
-			maxQueueSize: normalizePositiveInteger(options.maxQueueSize, DEFAULT_MAX_QUEUE_SIZE),
-			maxConcurrency: normalizePositiveInteger(options.maxConcurrency, DEFAULT_MAX_CONCURRENCY),
-			listenerTimeout: normalizePositiveInteger(options.listenerTimeout, DEFAULT_LISTENER_TIMEOUT_MS),
-			slowListenerThreshold: normalizePositiveInteger(options.slowListenerThreshold, DEFAULT_SLOW_LISTENER_THRESHOLD_MS)
-		};
-	}
-	enqueue(params) {
-		if (this.pendingQueueSize >= this.options.maxQueueSize) {
-			this.droppedCount += 1;
-			return Promise.reject(/* @__PURE__ */ new Error(`Discord event queue is full for ${params.eventType}; maxQueueSize=${this.options.maxQueueSize}`));
-		}
-		return new Promise((resolve, reject) => {
-			this.queue.push({
-				...params,
-				resolve,
-				reject
-			});
-			this.processNext();
-		});
-	}
-	getMetrics() {
-		return {
-			queueSize: this.pendingQueueSize,
-			processing: this.processing,
-			processed: this.processedCount,
-			dropped: this.droppedCount,
-			timeouts: this.timeoutCount,
-			maxQueueSize: this.options.maxQueueSize,
-			maxConcurrency: this.options.maxConcurrency
-		};
-	}
-	get pendingQueueSize() {
-		return Math.max(0, this.queue.length - this.queueHead);
-	}
-	takeNextJob() {
-		if (this.queueHead >= this.queue.length) {
-			this.queue.length = 0;
-			this.queueHead = 0;
-			return;
-		}
-		const job = this.queue[this.queueHead];
-		this.queueHead += 1;
-		if (this.queueHead >= this.queue.length) {
-			this.queue.length = 0;
-			this.queueHead = 0;
-		} else if (this.queueHead > 256 && this.queueHead * 2 > this.queue.length) {
-			this.queue.splice(0, this.queueHead);
-			this.queueHead = 0;
-		}
-		return job;
-	}
-	processNext() {
-		while (this.processing < this.options.maxConcurrency && this.pendingQueueSize > 0) {
-			const job = this.takeNextJob();
-			if (!job) return;
-			this.processing += 1;
-			const listenerPromise = Promise.resolve().then(() => job.run());
-			const runJobPromise = this.runJob(job, listenerPromise);
-			runJobPromise.then(job.resolve, job.reject).finally(() => {
-				this.processedCount += 1;
-			});
-			Promise.allSettled([runJobPromise, listenerPromise]).then(([dispatchResult, listenerResult]) => {
-				if (dispatchResult.status === "fulfilled" && dispatchResult.value === "timed-out" && listenerResult.status === "rejected") console.error(`[EventQueue] Listener ${job.listenerName} failed after timeout for event ${job.eventType}:`, listenerResult.reason);
-				this.processing -= 1;
-				this.processNext();
-			});
-		}
-	}
-	async runJob(job, listenerPromise) {
-		const startedAt = Date.now();
-		try {
-			await this.runWithTimeout(listenerPromise);
-			this.logSlowListener(job, Date.now() - startedAt);
-			return "completed";
-		} catch (error) {
-			if (isListenerTimeoutError(error)) {
-				this.timeoutCount += 1;
-				console.error(`[EventQueue] Listener ${job.listenerName} timed out after ${this.options.listenerTimeout}ms for event ${job.eventType}`);
-				return "timed-out";
-			}
-			console.error(`[EventQueue] Listener ${job.listenerName} failed for event ${job.eventType}:`, error);
-			return "failed";
-		}
-	}
-	async runWithTimeout(listenerPromise) {
-		let timeout;
-		try {
-			await Promise.race([listenerPromise, new Promise((_, reject) => {
-				timeout = setTimeout(() => {
-					reject(createListenerTimeoutError(this.options.listenerTimeout));
-				}, this.options.listenerTimeout);
-				timeout.unref?.();
-			})]);
-		} finally {
-			if (timeout) clearTimeout(timeout);
-		}
-	}
-	logSlowListener(job, durationMs) {
-		if (durationMs < this.options.slowListenerThreshold) return;
-		console.warn(`[EventQueue] Slow listener detected: ${job.listenerName} took ${durationMs}ms for event ${job.eventType}`);
-	}
-};
-function normalizePositiveInteger(value, fallback) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallback;
-	return Math.max(1, Math.floor(value));
-}
-function createListenerTimeoutError(timeoutMs) {
-	const error = /* @__PURE__ */ new Error(`Listener timeout after ${timeoutMs}ms`);
-	error.name = "DiscordEventQueueListenerTimeoutError";
-	return error;
-}
-function isListenerTimeoutError(error) {
-	return error instanceof Error && error.name === "DiscordEventQueueListenerTimeoutError";
-}
-//#endregion
-//#region extensions/discord/src/internal/commands.ts
-function clean(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-function resolveConditionalCommandOption(value, interaction) {
-	return typeof value === "function" ? value(interaction) : value;
-}
-async function deferCommandInteractionIfNeeded(command, interaction) {
-	if (!resolveConditionalCommandOption(command.defer, interaction)) return;
-	await interaction.defer({ ephemeral: resolveConditionalCommandOption(command.ephemeral, interaction) });
-}
-function readRawCommandOptions(interaction) {
-	const options = interaction.rawData.data?.options;
-	return Array.isArray(options) ? options : [];
-}
-function findSelectedSubcommand(subcommands, interaction) {
-	const subcommandName = readRawCommandOptions(interaction).find((option) => option.type === ApplicationCommandOptionType.Subcommand)?.name;
-	return typeof subcommandName === "string" ? subcommands.find((command) => command.name === subcommandName) : void 0;
-}
-function findCommandOption(options, name) {
-	if (!name) return;
-	return options?.find((option) => option.name === name);
-}
-function hasCommandOptions(command) {
-	return "options" in command;
-}
-function resolveFocusedCommandOptionAutocompleteHandler(command, interaction) {
-	const focusedName = interaction.options.getFocused()?.name;
-	const autocomplete = findCommandOption("subcommands" in command && Array.isArray(command.subcommands) ? findSelectedSubcommand(command.subcommands, interaction)?.options : hasCommandOptions(command) ? command.options : void 0, focusedName)?.autocomplete;
-	return typeof autocomplete === "function" ? autocomplete : void 0;
-}
-var BaseCommand = class {
-	constructor() {
-		this.defer = false;
-		this.ephemeral = false;
-		this.integrationTypes = [0, 1];
-		this.contexts = [
-			InteractionContextType.Guild,
-			InteractionContextType.BotDM,
-			InteractionContextType.PrivateChannel
-		];
-	}
-	serialize() {
-		return clean({
-			name: this.name,
-			name_localizations: this.nameLocalizations,
-			description: this.type === ApplicationCommandType.ChatInput ? this.description ?? "" : void 0,
-			description_localizations: this.descriptionLocalizations,
-			type: this.type,
-			options: this.serializeOptions(),
-			integration_types: this.integrationTypes,
-			contexts: this.contexts,
-			default_member_permissions: Array.isArray(this.permission) ? this.permission.reduce((sum, entry) => sum | entry, 0n).toString() : this.permission ? this.permission.toString() : null
-		});
-	}
-};
-var Command = class extends BaseCommand {
-	constructor(..._args) {
-		super(..._args);
-		this.type = ApplicationCommandType.ChatInput;
-	}
-	async autocomplete(interaction) {
-		throw new Error(`The ${interaction.rawData?.data?.name ?? this.name} command does not support autocomplete`);
-	}
-	serializeOptions() {
-		return this.options?.map((option) => {
-			if (typeof option.autocomplete === "function") {
-				const { autocomplete: _autocomplete, ...rest } = option;
-				return {
-					...rest,
-					autocomplete: true
-				};
-			}
-			return option;
-		});
-	}
-};
-var CommandWithSubcommands = class extends BaseCommand {
-	constructor(..._args2) {
-		super(..._args2);
-		this.type = ApplicationCommandType.ChatInput;
-	}
-	async run(interaction) {
-		const subcommand = findSelectedSubcommand(this.subcommands, interaction);
-		if (!subcommand) {
-			const subcommandName = readRawCommandOptions(interaction).find((option) => option.type === ApplicationCommandOptionType.Subcommand)?.name;
-			throw new Error(`Unknown Discord subcommand: ${typeof subcommandName === "string" ? subcommandName : "<missing>"}`);
-		}
-		await deferCommandInteractionIfNeeded(subcommand, interaction);
-		return await subcommand.run(interaction);
-	}
-	serializeOptions() {
-		return this.subcommands.map((command) => clean({
-			name: command.name,
-			name_localizations: command.nameLocalizations,
-			description: command.description ?? "",
-			description_localizations: command.descriptionLocalizations,
-			type: ApplicationCommandOptionType.Subcommand,
-			options: command.serializeOptions()
-		}));
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/interaction-options.ts
-function readFocusedOption(options) {
-	for (const option of options ?? []) {
-		if ("focused" in option && option.focused) return option;
-		const child = readFocusedOption(readChildOptions(option));
-		if (child) return child;
-	}
-}
-function findOption(options, name) {
-	for (const option of options ?? []) {
-		if (option.name === name) return option;
-		const child = findOption(readChildOptions(option), name);
-		if (child) return child;
-	}
-}
-function readChildOptions(option) {
-	if (!("options" in option) || !Array.isArray(option.options)) return;
-	return option.options;
-}
-var OptionsHandler = class {
-	constructor(rawOptions, client, resolvedChannels) {
-		this.rawOptions = rawOptions;
-		this.client = client;
-		this.resolvedChannels = resolvedChannels;
-	}
-	getString(name) {
-		const option = findOption(this.rawOptions, name);
-		const value = option && "value" in option ? option.value : void 0;
-		return typeof value === "string" ? value : null;
-	}
-	getNumber(name) {
-		const option = findOption(this.rawOptions, name);
-		const value = option && "value" in option ? option.value : void 0;
-		return typeof value === "number" ? value : null;
-	}
-	getBoolean(name) {
-		const option = findOption(this.rawOptions, name);
-		const value = option && "value" in option ? option.value : void 0;
-		return typeof value === "boolean" ? value : null;
-	}
-	async getChannel(name, required = false) {
-		const option = findOption(this.rawOptions, name);
-		const value = option && "value" in option ? option.value : void 0;
-		const id = typeof value === "string" ? value : void 0;
-		const resolved = id ? this.resolvedChannels?.[id] : void 0;
-		if (resolved) return channelFactory(this.client, resolved);
-		if (id) return await this.client.fetchChannel(id);
-		if (required) throw new Error(`Missing required channel option ${name}`);
-		return null;
-	}
-	getFocused() {
-		return readFocusedOption(this.rawOptions);
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/interaction-response.ts
-var InteractionResponseController = class {
-	constructor() {
-		this.state = "unacknowledged";
-	}
-	get acknowledged() {
-		return this.state !== "unacknowledged";
-	}
-	recordCallback(type) {
-		if (type === InteractionResponseType.DeferredChannelMessageWithSource) {
-			this.state = "deferred";
-			return;
-		}
-		if (type === InteractionResponseType.DeferredMessageUpdate) {
-			this.state = "deferred-update";
-			return;
-		}
-		this.state = "replied";
-	}
-	nextReplyAction() {
-		if (this.state === "deferred" || this.state === "deferred-update") return "edit";
-		if (this.state === "unacknowledged") return "initial";
-		return "follow-up";
-	}
-	recordReplyEdit() {
-		this.state = "replied";
-	}
-	recordReplyDelete() {
-		this.state = "replied";
-	}
-};
-function needsComponentsV2Query(body) {
-	return body !== null && typeof body === "object" && "flags" in body && typeof body.flags === "number" && (body.flags & MessageFlags.IsComponentsV2) !== 0;
-}
-//#endregion
-//#region extensions/discord/src/internal/modal-fields.ts
-function extractModalFields(components) {
-	const out = {};
-	for (const component of flattenModalComponents(components)) {
-		const raw = component;
-		if (typeof raw.custom_id !== "string") continue;
-		if (Array.isArray(raw.values)) out[raw.custom_id] = raw.values.map(String);
-		else if (typeof raw.value === "string" || typeof raw.value === "number" || typeof raw.value === "boolean") out[raw.custom_id] = String(raw.value);
-	}
-	return out;
-}
-function flattenModalComponents(components) {
-	const out = [];
-	for (const entry of components) {
-		if (!entry || typeof entry !== "object") continue;
-		const component = entry;
-		if (component.component && typeof component.component === "object") out.push(component.component);
-		if (Array.isArray(component.components)) out.push(...flattenModalComponents(component.components));
-		out.push(entry);
-	}
-	return out;
-}
-var ModalFields = class {
-	constructor(values, resolved, client) {
-		this.values = values;
-		this.resolved = resolved;
-		this.client = client;
-	}
-	value(id, required) {
-		const value = this.values[id];
-		if (required && (value === void 0 || Array.isArray(value) && value.length === 0)) throw new Error(`Missing required modal field ${id}`);
-		return value;
-	}
-	getText(id, required = false) {
-		const value = this.value(id, required);
-		return typeof value === "string" ? value : null;
-	}
-	getStringSelect(id, required = false) {
-		const value = this.value(id, required);
-		if (Array.isArray(value)) return value;
-		return typeof value === "string" ? [value] : [];
-	}
-	getRoleSelect(id, required = false) {
-		return this.getStringSelect(id, required).map((roleId) => {
-			const raw = this.resolved?.roles?.[roleId];
-			return raw ? new Role(this.client, {
-				id: roleId,
-				name: raw.name ?? ""
-			}) : new Role(this.client, roleId);
-		});
-	}
-	getUserSelect(id, required = false) {
-		return this.getStringSelect(id, required).map((userId) => {
-			const raw = this.resolved?.users?.[userId];
-			return new User(this.client, {
-				id: userId,
-				username: raw?.username ?? ""
-			});
-		});
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/schemas.ts
-const discordInteractionPayloadSchema = Type.Object({
-	id: Type.String({ minLength: 1 }),
-	token: Type.String({ minLength: 1 }),
-	type: Type.Number()
-}, { additionalProperties: true });
-const discordRateLimitBodySchema = Type.Object({
-	message: Type.Optional(Type.String()),
-	retry_after: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-	global: Type.Optional(Type.Boolean()),
-	code: Type.Optional(Type.Union([Type.Number(), Type.String()]))
-}, { additionalProperties: true });
-function assertDiscordInteractionPayload(value) {
-	if (!Check(discordInteractionPayloadSchema, value)) throw new Error("Invalid Discord interaction payload");
-}
-function isDiscordRateLimitBody(value) {
-	return Check(discordRateLimitBodySchema, value);
-}
-//#endregion
-//#region extensions/discord/src/internal/interactions.ts
-function toCommandRawInteraction(rawData) {
-	return rawData;
-}
-function toMessageComponentRawInteraction(rawData) {
-	return rawData;
-}
-function toModalSubmitRawInteraction(rawData) {
-	return rawData;
-}
-function readInteractionUser(rawData, client) {
-	const directUser = "user" in rawData ? rawData.user : void 0;
-	if (directUser && typeof directUser === "object" && "id" in directUser) return new User(client, directUser);
-	const memberUser = rawData.member?.user;
-	if (memberUser && typeof memberUser === "object" && typeof memberUser.id === "string") {
-		const user = { ...memberUser };
-		if (typeof user.username !== "string") user.username = "";
-		return new User(client, user);
-	}
-	return null;
-}
-var BaseInteraction = class {
-	constructor(client, rawData) {
-		this.client = client;
-		this.rawData = rawData;
-		this.message = null;
-		this.response = new InteractionResponseController();
-		this.id = rawData.id;
-		this.token = rawData.token;
-		this.user = readInteractionUser(rawData, client);
-		this.userId = this.user?.id ?? "";
-		this.guild = rawData.guild_id ? new Guild(client, rawData.guild_id) : null;
-		this.channel = "channel" in rawData && rawData.channel ? channelFactory(client, rawData.channel) : null;
-	}
-	get acknowledged() {
-		return this.response.acknowledged;
-	}
-	get responseState() {
-		return this.response.state;
-	}
-	set responseState(nextState) {
-		this.response.state = nextState;
-	}
-	async callback(type, data) {
-		this.response.recordCallback(type);
-		return await createInteractionCallback(this.client.rest, this.id, this.token, data === void 0 ? { type } : {
-			type,
-			data
-		});
-	}
-	async reply(payload) {
-		const action = this.response.nextReplyAction();
-		if (action === "edit") return await this.editReply(payload);
-		if (action === "follow-up") return await this.followUp(payload);
-		return await this.callback(InteractionResponseType.ChannelMessageWithSource, serializePayload(payload));
-	}
-	async defer(options) {
-		return await this.callback(InteractionResponseType.DeferredChannelMessageWithSource, options?.ephemeral ? { flags: 64 } : void 0);
-	}
-	async acknowledge() {
-		return await this.defer();
-	}
-	async editReply(payload) {
-		const body = serializePayload(payload);
-		const query = needsComponentsV2Query(body) ? { with_components: true } : void 0;
-		const result = query ? await editWebhookMessage(this.client.rest, this.client.options.clientId, this.token, "@original", { body }, query) : await editWebhookMessage(this.client.rest, this.client.options.clientId, this.token, "@original", { body });
-		this.response.recordReplyEdit();
-		return result;
-	}
-	async deleteReply() {
-		const result = await deleteWebhookMessage(this.client.rest, this.client.options.clientId, this.token, "@original");
-		this.response.recordReplyDelete();
-		return result;
-	}
-	async fetchReply() {
-		return await getWebhookMessage(this.client.rest, this.client.options.clientId, this.token, "@original");
-	}
-	async replyAndWaitForComponent(payload, timeoutMs = 3e5) {
-		const result = await this.reply(payload);
-		const rawMessage = isRawMessage(result) ? result : await this.fetchReply();
-		if (!isRawMessage(rawMessage)) throw new Error("Discord interaction reply did not return a message");
-		const message = new Message(this.client, rawMessage);
-		return await this.client.componentHandler.waitForMessageComponent(message, timeoutMs);
-	}
-	async followUp(payload) {
-		const body = serializePayload(payload);
-		return await createWebhookMessage(this.client.rest, this.client.options.clientId, this.token, { body }, needsComponentsV2Query(body) ? { with_components: true } : void 0);
-	}
-};
-var CommandInteraction = class extends BaseInteraction {
-	constructor(client, rawData) {
-		super(client, rawData);
-		this.options = new OptionsHandler(rawData.data.options, client, rawData.data.resolved?.channels);
-	}
-};
-var AutocompleteInteraction = class extends CommandInteraction {
-	async respond(choices) {
-		return await this.callback(InteractionResponseType.ApplicationCommandAutocompleteResult, { choices });
-	}
-};
-var BaseComponentInteraction = class extends BaseInteraction {
-	constructor(client, rawData) {
-		super(client, rawData);
-		this.message = rawData.message && typeof rawData.message === "object" ? new Message(client, rawData.message) : null;
-		this.values = Array.isArray(rawData.data.values) ? rawData.data.values.map(String) : [];
-	}
-	async update(payload) {
-		return await this.callback(InteractionResponseType.UpdateMessage, serializePayload(payload));
-	}
-	async acknowledge() {
-		return await this.callback(InteractionResponseType.DeferredMessageUpdate);
-	}
-	async showModal(modal) {
-		return await this.callback(InteractionResponseType.Modal, modal.serialize());
-	}
-	async launchActivity() {
-		return await this.callback(InteractionResponseType.LaunchActivity);
-	}
-};
-var ButtonInteraction = class extends BaseComponentInteraction {};
-var StringSelectMenuInteraction = class extends BaseComponentInteraction {};
-var UserSelectMenuInteraction = class extends BaseComponentInteraction {};
-var RoleSelectMenuInteraction = class extends BaseComponentInteraction {};
-var MentionableSelectMenuInteraction = class extends BaseComponentInteraction {};
-var ChannelSelectMenuInteraction = class extends BaseComponentInteraction {};
-var ModalInteraction = class extends BaseInteraction {
-	constructor(client, rawData) {
-		super(client, rawData);
-		this.fields = new ModalFields(extractModalFields(rawData.data.components ?? []), rawData.data.resolved, client);
-	}
-	async acknowledge() {
-		return await this.callback(InteractionResponseType.DeferredMessageUpdate);
-	}
-};
-function createInteraction(client, rawData) {
-	assertDiscordInteractionPayload(rawData);
-	if (rawData.type === InteractionType.ApplicationCommandAutocomplete) return new AutocompleteInteraction(client, toCommandRawInteraction(rawData));
-	if (rawData.type === InteractionType.ApplicationCommand) return new CommandInteraction(client, toCommandRawInteraction(rawData));
-	if (rawData.type === InteractionType.ModalSubmit) return new ModalInteraction(client, toModalSubmitRawInteraction(rawData));
-	if (rawData.type === InteractionType.MessageComponent) {
-		const componentRawData = toMessageComponentRawInteraction(rawData);
-		switch (rawData.data?.component_type) {
-			case ComponentType.Button: return new ButtonInteraction(client, componentRawData);
-			case ComponentType.StringSelect: return new StringSelectMenuInteraction(client, componentRawData);
-			case ComponentType.UserSelect: return new UserSelectMenuInteraction(client, componentRawData);
-			case ComponentType.RoleSelect: return new RoleSelectMenuInteraction(client, componentRawData);
-			case ComponentType.MentionableSelect: return new MentionableSelectMenuInteraction(client, componentRawData);
-			case ComponentType.ChannelSelect: return new ChannelSelectMenuInteraction(client, componentRawData);
-			default: return new BaseComponentInteraction(client, componentRawData);
-		}
-	}
-	return new BaseInteraction(client, rawData);
-}
-function parseComponentInteractionData(component, customId) {
-	return component.customIdParser(customId).data;
-}
-function isRawMessage(value) {
-	return Boolean(value) && typeof value === "object" && typeof value.id === "string" && typeof value.channel_id === "string";
-}
-//#endregion
-//#region extensions/discord/src/internal/interaction-dispatch.ts
-async function dispatchInteraction(client, rawData) {
-	const interaction = createInteraction(client, rawData);
-	if (rawData.type === InteractionType.ApplicationCommandAutocomplete) {
-		const command = client.commands.find((entry) => entry.name === readInteractionName(rawData));
-		if (!command) return;
-		const autocompleteInteraction = interaction;
-		const optionAutocomplete = resolveFocusedCommandOptionAutocompleteHandler(command, autocompleteInteraction);
-		if (optionAutocomplete) {
-			await optionAutocomplete(autocompleteInteraction);
-			return;
-		}
-		if ("autocomplete" in command) await command.autocomplete(autocompleteInteraction);
-		return;
-	}
-	if (rawData.type === InteractionType.ApplicationCommand) {
-		const command = client.commands.find((entry) => entry.name === readInteractionName(rawData));
-		if (command && "run" in command) {
-			await deferCommandInteractionIfNeeded(command, interaction);
-			await command.run(interaction);
-		}
-		return;
-	}
-	if (rawData.type === InteractionType.MessageComponent) {
-		const customId = readCustomId(rawData);
-		if (!customId) return;
-		const componentInteraction = interaction;
-		if (client.componentHandler.resolveOneOffComponent({
-			channelId: readMessageChannelId(rawData),
-			customId,
-			messageId: readMessageId(rawData),
-			values: readComponentValues(rawData)
-		})) {
-			await componentInteraction.acknowledge();
-			return;
-		}
-		const component = client.componentHandler.resolve(customId, { componentType: rawData.data?.component_type });
-		if (component) {
-			await deferComponentInteractionIfNeeded(component, componentInteraction);
-			await component.run(componentInteraction, parseComponentInteractionData(component, customId));
-		}
-		return;
-	}
-	if (rawData.type === InteractionType.ModalSubmit) {
-		const customId = readCustomId(rawData);
-		if (!customId) return;
-		const modal = client.modalHandler.resolve(customId);
-		if (modal) await modal.run(interaction, modal.customIdParser(customId).data);
-	}
-}
-function resolveConditionalComponentOption(value, interaction) {
-	return typeof value === "function" ? value(interaction) : value;
-}
-async function deferComponentInteractionIfNeeded(component, interaction) {
-	if (!resolveConditionalComponentOption(component.defer, interaction)) return;
-	if (resolveConditionalComponentOption(component.ephemeral, interaction)) {
-		await interaction.defer({ ephemeral: true });
-		return;
-	}
-	await interaction.acknowledge();
-}
-function readInteractionName(rawData) {
-	return rawData.data?.name;
-}
-function readCustomId(rawData) {
-	return rawData.data?.custom_id;
-}
-function readComponentValues(rawData) {
-	const values = rawData.data?.values;
-	return Array.isArray(values) ? values.map(String) : void 0;
-}
-function readMessageId(rawData) {
-	const messageId = rawData.message?.id;
-	return typeof messageId === "string" ? messageId : void 0;
-}
-function readMessageChannelId(rawData) {
-	const channelId = rawData.message?.channel_id;
-	return typeof channelId === "string" ? channelId : void 0;
-}
-//#endregion
-//#region extensions/discord/src/internal/rest-body.ts
-function serializeRequestBody(data, headers) {
-	if (data?.headers) for (const [key, value] of Object.entries(data.headers)) headers.set(key, value);
-	if (data?.body == null) return;
-	if (typeof data.body === "object") {
-		const bodyObject = data.body;
-		const topLevelFiles = Array.isArray(bodyObject.files) ? bodyObject.files : void 0;
-		const nestedData = bodyObject.data && typeof bodyObject.data === "object" ? bodyObject.data : void 0;
-		const nestedFiles = nestedData && Array.isArray(nestedData.files) ? nestedData.files : void 0;
-		const files = topLevelFiles ?? nestedFiles;
-		const filesContainer = topLevelFiles ? bodyObject : nestedFiles ? nestedData : void 0;
-		if (files?.length && filesContainer) {
-			if (data.multipartStyle === "form") {
-				const formData = new FormData();
-				for (const [key, value] of Object.entries(filesContainer)) {
-					if (key === "files" || value === void 0 || value === null) continue;
-					formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
-				}
-				for (const file of files) {
-					const item = file;
-					const name = typeof item.name === "string" && item.name ? item.name : "file";
-					const blob = item.data instanceof Blob ? item.data : new Blob([item.data], { type: typeof item.contentType === "string" ? item.contentType : void 0 });
-					formData.append(typeof item.fieldName === "string" && item.fieldName ? item.fieldName : "file", blob, name);
-				}
-				return formData;
-			}
-			const payloadJson = topLevelFiles ? { ...bodyObject } : {
-				...bodyObject,
-				data: { ...nestedData }
-			};
-			const payloadFilesContainer = topLevelFiles ? payloadJson : payloadJson.data ?? {};
-			const formData = new FormData();
-			const existingAttachments = Array.isArray(payloadFilesContainer.attachments) ? [...payloadFilesContainer.attachments] : [];
-			const uploaded = files.map((file, index) => {
-				const item = file;
-				const name = typeof item.name === "string" && item.name ? item.name : `file-${index}`;
-				const blob = item.data instanceof Blob ? item.data : new Blob([item.data], { type: typeof item.contentType === "string" ? item.contentType : void 0 });
-				const id = existingAttachments.length + index;
-				formData.append(`files[${id}]`, blob, name);
-				const attachment = {
-					id,
-					filename: name
-				};
-				if (typeof item.description === "string") attachment.description = item.description;
-				if (typeof item.duration_secs === "number") attachment.duration_secs = item.duration_secs;
-				if (typeof item.waveform === "string") attachment.waveform = item.waveform;
-				return attachment;
-			});
-			payloadFilesContainer.attachments = [...existingAttachments, ...uploaded];
-			delete payloadFilesContainer.files;
-			formData.append("payload_json", JSON.stringify(payloadJson));
-			return formData;
-		}
-	}
-	if (!data.rawBody) headers.set("Content-Type", "application/json");
-	return data.rawBody ? data.body : JSON.stringify(data.body);
-}
-//#endregion
-//#region extensions/discord/src/internal/rest-errors.ts
-const DISCORD_UNKNOWN_VOICE_STATE = 10065;
-function readDiscordCode(body) {
-	return parseStrictNonNegativeInteger(body && typeof body === "object" && "code" in body ? body.code : void 0);
-}
-function readDiscordMessage(body, fallback) {
-	const value = body && typeof body === "object" && "message" in body ? body.message : void 0;
-	return typeof value === "string" && value.trim() ? value : fallback;
-}
-function isUnknownDiscordVoiceStateError(err) {
-	return (err && typeof err === "object" && "discordCode" in err ? parseStrictNonNegativeInteger(err.discordCode) : void 0) === DISCORD_UNKNOWN_VOICE_STATE || /unknown voice state/i.test(formatErrorMessage(err));
-}
-function readRetryAfter(body, response, fallbackSeconds = 0) {
-	return parseDiscordRetryAfterBodySeconds(body && typeof body === "object" && "retry_after" in body ? body.retry_after : void 0) ?? parseRetryAfterHeaderSeconds(response.headers.get("Retry-After")) ?? fallbackSeconds;
-}
-var DiscordError = class extends Error {
-	constructor(response, body) {
-		super(readDiscordMessage(body, `Discord API request failed (${response.status})`));
-		this.name = "DiscordError";
-		this.status = response.status;
-		this.statusCode = response.status;
-		this.rawBody = body;
-		this.rawError = body;
-		this.discordCode = readDiscordCode(body);
-	}
-};
-var RateLimitError = class extends DiscordError {
-	constructor(response, body) {
-		super(response, body);
-		this.name = "RateLimitError";
-		this.retryAfter = readRetryAfter(body, response, 1);
-		this.scope = body.global ? "global" : response.headers.get("X-RateLimit-Scope");
-		this.bucket = response.headers.get("X-RateLimit-Bucket");
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/rest-routes.ts
-const RATE_LIMIT_HEADER_NUMBER_RE = /^\d+(?:\.\d+)?$/;
-function createRouteKey(method, path) {
-	return `${method.toUpperCase()} ${path.split("?")[0] ?? path}`;
-}
-function readTopLevelRouteKey(path) {
-	const [pathname = path] = path.split("?");
-	const [first, id, token] = pathname.replace(/^\/+/, "").split("/");
-	if (!first || !id) return pathname;
-	if (first === "channels" || first === "guilds" || first === "webhooks") return first === "webhooks" && token ? `${first}/${id}/${token}` : `${first}/${id}`;
-	return first;
-}
-function createBucketKey(bucket, path) {
-	return `${bucket}:${readTopLevelRouteKey(path)}`;
-}
-function readHeaderNumber(headers, name) {
-	const value = headers.get(name);
-	if (!value) return;
-	const trimmed = value.trim();
-	if (!RATE_LIMIT_HEADER_NUMBER_RE.test(trimmed)) return;
-	const parsed = Number(trimmed);
-	return Number.isFinite(parsed) && Math.abs(parsed) <= Number.MAX_SAFE_INTEGER ? parsed : void 0;
-}
-function resolveRateLimitResetAt(delayMs) {
-	const clampedDelayMs = Math.ceil(Math.max(0, delayMs));
-	if (!Number.isSafeInteger(clampedDelayMs)) return;
-	if (clampedDelayMs === 0) return asDateTimestampMs(Date.now());
-	return resolveExpiresAtMsFromDurationMs(clampedDelayMs);
-}
-function readResetAt(response) {
-	const resetAfter = readHeaderNumber(response.headers, "X-RateLimit-Reset-After");
-	if (resetAfter !== void 0) return resolveRateLimitResetAt(resetAfter * 1e3);
-	const reset = readHeaderNumber(response.headers, "X-RateLimit-Reset");
-	return reset !== void 0 ? asDateTimestampMs(reset * 1e3) : void 0;
-}
-function appendQuery(path, query) {
-	if (!query || Object.keys(query).length === 0) return path;
-	const search = new URLSearchParams();
-	for (const [key, value] of Object.entries(query)) search.set(key, String(value));
-	return `${path}?${search.toString()}`;
-}
-//#endregion
-//#region extensions/discord/src/internal/rest-scheduler.ts
-const INVALID_REQUEST_WINDOW_MS = 10 * 6e4;
-const requestPriorities = [
-	"critical",
-	"standard",
-	"background"
-];
-function normalizeRestSchedulerOptions(options) {
-	return {
-		lanes: {
-			critical: normalizeLaneOptions(options.lanes.critical),
-			standard: normalizeLaneOptions(options.lanes.standard),
-			background: normalizeLaneOptions(options.lanes.background)
-		},
-		maxConcurrency: resolveIntegerOption(options.maxConcurrency, 1, { min: 1 }),
-		maxQueueSize: resolveIntegerOption(options.maxQueueSize, 1, { min: 1 }),
-		maxRateLimitRetries: resolveIntegerOption(options.maxRateLimitRetries, 0, { min: 0 })
-	};
-}
-function normalizeLaneOptions(options) {
-	return {
-		maxQueueSize: resolveIntegerOption(options.maxQueueSize, 1, { min: 1 }),
-		...options.staleAfterMs === void 0 ? {} : { staleAfterMs: resolveIntegerOption(options.staleAfterMs, 0, { min: 0 }) },
-		weight: resolveIntegerOption(options.weight, 1, { min: 1 })
-	};
-}
-function createLaneQueues() {
-	return {
-		critical: [],
-		standard: [],
-		background: []
-	};
-}
-function countPending(bucket) {
-	return requestPriorities.reduce((count, lane) => count + bucket.pending[lane].length, 0);
-}
-var RestScheduler = class {
-	constructor(options, executor) {
-		this.executor = executor;
-		this.activeWorkers = 0;
-		this.buckets = /* @__PURE__ */ new Map();
-		this.globalRateLimitUntil = 0;
-		this.invalidRequestTimestamps = [];
-		this.laneCursor = 0;
-		this.laneDropped = {
-			critical: 0,
-			standard: 0,
-			background: 0
-		};
-		this.queuedByLane = {
-			critical: 0,
-			standard: 0,
-			background: 0
-		};
-		this.queueGeneration = 0;
-		this.queuedRequests = 0;
-		this.routeBuckets = /* @__PURE__ */ new Map();
-		this.options = normalizeRestSchedulerOptions(options);
-		this.laneSchedule = this.buildLaneSchedule(this.options.lanes);
-	}
-	enqueue(params) {
-		if (this.queuedRequests >= this.options.maxQueueSize) throw new Error("Discord request queue is full");
-		const laneOptions = this.options.lanes[params.priority];
-		if (this.queuedByLane[params.priority] >= laneOptions.maxQueueSize) {
-			this.laneDropped[params.priority] += 1;
-			throw new Error(`Discord ${params.priority} request queue is full (${this.queuedByLane[params.priority]} / ${laneOptions.maxQueueSize})`);
-		}
-		const routeKey = createRouteKey(params.method, params.path);
-		const bucket = this.getBucket(this.routeBuckets.get(routeKey) ?? routeKey);
-		return new Promise((resolve, reject) => {
-			this.queuedRequests += 1;
-			this.queuedByLane[params.priority] += 1;
-			bucket.pending[params.priority].push({
-				...params,
-				enqueuedAt: Date.now(),
-				generation: this.queueGeneration,
-				routeKey,
-				retryCount: 0,
-				resolve,
-				reject
-			});
-			this.drainQueues();
-		});
-	}
-	recordResponse(routeKey, path, response, parsed) {
-		this.updateRateLimitState(routeKey, path, response, parsed);
-		this.recordInvalidRequest(routeKey, path, response);
-	}
-	clearQueue() {
-		this.queueGeneration += 1;
-		if (this.drainTimer) {
-			clearTimeout(this.drainTimer);
-			this.drainTimer = void 0;
-		}
-		this.rejectPending(/* @__PURE__ */ new Error("Discord request queue cleared"));
-	}
-	abortPending() {
-		this.queueGeneration += 1;
-		this.rejectPending(new DOMException("Aborted", "AbortError"));
-	}
-	get queueSize() {
-		return this.queuedRequests;
-	}
-	getMetrics() {
-		this.pruneInvalidRequests();
-		return {
-			globalRateLimitUntil: this.globalRateLimitUntil,
-			activeBuckets: this.buckets.size,
-			routeBucketMappings: this.routeBuckets.size,
-			buckets: Array.from(this.buckets.entries()).map(([key, bucket]) => ({
-				key,
-				active: bucket.active,
-				bucket: bucket.bucket,
-				invalidRequests: bucket.invalidRequests,
-				pending: countPending(bucket),
-				pendingByLane: Object.fromEntries(requestPriorities.map((lane) => [lane, bucket.pending[lane].length])),
-				rateLimitHits: bucket.rateLimitHits,
-				remaining: bucket.remaining,
-				resetAt: bucket.resetAt,
-				routeKeyCount: bucket.routeKeys.size
-			})),
-			invalidRequestCount: this.invalidRequestTimestamps.length,
-			invalidRequestCountByStatus: this.invalidRequestTimestamps.reduce((counts, entry) => {
-				counts[entry.status] = (counts[entry.status] ?? 0) + 1;
-				return counts;
-			}, {}),
-			queueSize: this.queueSize,
-			queueSizeByLane: { ...this.queuedByLane },
-			droppedByLane: { ...this.laneDropped },
-			oldestQueuedByLane: Object.fromEntries(requestPriorities.map((lane) => [lane, this.getOldestQueuedAge(lane)])),
-			activeWorkers: this.activeWorkers,
-			maxConcurrentWorkers: this.maxConcurrentWorkers
-		};
-	}
-	get maxConcurrentWorkers() {
-		return this.options.maxConcurrency;
-	}
-	get maxRateLimitRetries() {
-		return this.options.maxRateLimitRetries;
-	}
-	getBucket(key) {
-		const existing = this.buckets.get(key);
-		if (existing) return existing;
-		const bucket = {
-			active: 0,
-			invalidRequests: 0,
-			pending: createLaneQueues(),
-			rateLimitHits: 0,
-			resetAt: 0,
-			routeKeys: /* @__PURE__ */ new Set([key])
-		};
-		this.buckets.set(key, bucket);
-		return bucket;
-	}
-	hasBucketReference(key) {
-		for (const bucketKey of this.routeBuckets.values()) if (bucketKey === key) return true;
-		return false;
-	}
-	isBucketRateLimited(bucket, now = Date.now()) {
-		return bucket.remaining === 0 && bucket.resetAt > now;
-	}
-	pruneRouteMapping(routeKey) {
-		const bucketKey = this.routeBuckets.get(routeKey);
-		if (!bucketKey) return;
-		this.routeBuckets.delete(routeKey);
-		this.buckets.get(bucketKey)?.routeKeys.delete(routeKey);
-	}
-	pruneIdleRouteMappings(bucketKey, bucket, now = Date.now()) {
-		if (bucket.active > 0 || countPending(bucket) > 0 || this.isBucketRateLimited(bucket, now)) return;
-		for (const routeKey of Array.from(bucket.routeKeys)) if (this.routeBuckets.get(routeKey) === bucketKey) this.pruneRouteMapping(routeKey);
-	}
-	shouldPruneIdleBucket(key) {
-		return this.routeBuckets.get(key) !== key && !this.hasBucketReference(key);
-	}
-	bindRouteToBucket(routeKey, bucketKey) {
-		const target = this.getBucket(bucketKey);
-		target.routeKeys.add(routeKey);
-		this.routeBuckets.set(routeKey, bucketKey);
-		const routeBucket = this.buckets.get(routeKey);
-		if (routeBucket && routeBucket !== target) {
-			for (const lane of requestPriorities) {
-				target.pending[lane].push(...routeBucket.pending[lane]);
-				routeBucket.pending[lane] = [];
-			}
-			if (routeBucket.active === 0) this.buckets.delete(routeKey);
-		}
-		return target;
-	}
-	updateRateLimitState(routeKey, path, response, parsed) {
-		const bucketHeader = response.headers.get("X-RateLimit-Bucket");
-		const bucket = bucketHeader ? this.bindRouteToBucket(routeKey, createBucketKey(bucketHeader, path)) : this.getBucket(this.routeBuckets.get(routeKey) ?? routeKey);
-		bucket.bucket = bucketHeader ?? bucket.bucket;
-		const limit = readHeaderNumber(response.headers, "X-RateLimit-Limit");
-		if (limit !== void 0) bucket.limit = limit;
-		const remaining = readHeaderNumber(response.headers, "X-RateLimit-Remaining");
-		if (remaining !== void 0) bucket.remaining = remaining;
-		const resetAt = readResetAt(response);
-		if (resetAt !== void 0) bucket.resetAt = resetAt;
-		if (response.status !== 429) return;
-		bucket.rateLimitHits += 1;
-		const retryAt = resolveRateLimitResetAt(Math.max(0, readRetryAfter(parsed, response, 1) * 1e3));
-		if (retryAt === void 0) return;
-		if (response.headers.get("X-RateLimit-Global") === "true" || isGlobalRateLimit(parsed)) {
-			this.globalRateLimitUntil = Math.max(this.globalRateLimitUntil, retryAt);
-			return;
-		}
-		bucket.remaining = 0;
-		bucket.resetAt = Math.max(bucket.resetAt, retryAt);
-	}
-	recordInvalidRequest(routeKey, path, response) {
-		if (response.status !== 401 && response.status !== 403 && response.status !== 429) return;
-		if (response.status === 429 && response.headers.get("X-RateLimit-Scope") === "shared") return;
-		const now = Date.now();
-		this.invalidRequestTimestamps.push({
-			at: now,
-			status: response.status
-		});
-		this.pruneInvalidRequests(now);
-		const bucketHeader = response.headers.get("X-RateLimit-Bucket");
-		const bucketKey = bucketHeader ? createBucketKey(bucketHeader, path) : this.routeBuckets.get(routeKey) ?? routeKey;
-		const bucket = this.buckets.get(bucketKey);
-		if (bucket) bucket.invalidRequests += 1;
-	}
-	pruneInvalidRequests(now = Date.now()) {
-		const cutoff = now - INVALID_REQUEST_WINDOW_MS;
-		while (this.invalidRequestTimestamps.length > 0 && (this.invalidRequestTimestamps[0]?.at ?? 0) <= cutoff) this.invalidRequestTimestamps.shift();
-	}
-	getBucketWaitMs(bucket, now) {
-		if (bucket.remaining === 0 && bucket.resetAt > now) return bucket.resetAt - now;
-		if (bucket.remaining === 0 && bucket.resetAt <= now) bucket.remaining = bucket.limit;
-		return 0;
-	}
-	scheduleDrain(delayMs = 0) {
-		if (this.drainTimer) return;
-		this.drainTimer = setTimeout(() => {
-			this.drainTimer = void 0;
-			this.drainQueues();
-		}, resolveTimerTimeoutMs(delayMs, 0, 0));
-		this.drainTimer.unref?.();
-	}
-	drainQueues() {
-		let nextDelayMs = Number.POSITIVE_INFINITY;
-		while (this.activeWorkers < this.maxConcurrentWorkers) {
-			const next = this.takeNextQueuedRequest();
-			if (!next.queued) {
-				if (next.waitMs !== void 0) nextDelayMs = Math.min(nextDelayMs, next.waitMs);
-				break;
-			}
-			const { bucket, queued } = next;
-			if (bucket.remaining !== void 0 && bucket.remaining > 0) bucket.remaining -= 1;
-			bucket.active += 1;
-			this.activeWorkers += 1;
-			this.runQueuedRequest(queued, bucket);
-		}
-		if (Number.isFinite(nextDelayMs)) this.scheduleDrain(nextDelayMs);
-	}
-	takeNextQueuedRequest() {
-		const now = Date.now();
-		if (this.globalRateLimitUntil > now) return { waitMs: this.globalRateLimitUntil - now };
-		this.pruneIdleBuckets(now);
-		let nextDelayMs;
-		const buckets = Array.from(this.buckets.values()).filter((bucket) => countPending(bucket) > 0);
-		if (buckets.length === 0) return {};
-		for (let laneOffset = 0; laneOffset < this.laneSchedule.length; laneOffset += 1) {
-			const lane = this.laneSchedule[(this.laneCursor + laneOffset) % this.laneSchedule.length];
-			if (!lane || this.queuedByLane[lane] <= 0) continue;
-			for (const bucket of buckets) {
-				const queue = bucket.pending[lane];
-				this.dropStaleHeadRequests(queue, lane, now);
-				if (queue.length === 0) continue;
-				if (bucket.active > 0) continue;
-				const waitMs = this.getBucketWaitMs(bucket, now);
-				if (waitMs > 0) {
-					nextDelayMs = Math.min(nextDelayMs ?? waitMs, waitMs);
-					continue;
-				}
-				const queued = queue.shift();
-				if (!queued) continue;
-				this.queuedByLane[lane] = Math.max(0, this.queuedByLane[lane] - 1);
-				this.laneCursor = (this.laneCursor + laneOffset + 1) % this.laneSchedule.length;
-				return {
-					bucket,
-					queued
-				};
-			}
-		}
-		return { waitMs: nextDelayMs };
-	}
-	dropStaleHeadRequests(queue, lane, now) {
-		if (lane !== "background") return;
-		const staleAfterMs = this.options.lanes[lane].staleAfterMs;
-		if (!staleAfterMs || staleAfterMs <= 0) return;
-		while (queue.length > 0 && now - (queue[0]?.enqueuedAt ?? now) > staleAfterMs) {
-			const stale = queue.shift();
-			if (!stale) continue;
-			this.queuedRequests = Math.max(0, this.queuedRequests - 1);
-			this.queuedByLane[lane] = Math.max(0, this.queuedByLane[lane] - 1);
-			this.laneDropped[lane] += 1;
-			stale.reject(/* @__PURE__ */ new Error(`Dropped stale ${lane} request after ${now - stale.enqueuedAt}ms`));
-		}
-	}
-	pruneIdleBuckets(now = Date.now()) {
-		for (const [key, bucket] of this.buckets) {
-			if (bucket.active !== 0 || countPending(bucket) > 0) continue;
-			if (this.isBucketRateLimited(bucket, now)) continue;
-			this.pruneIdleRouteMappings(key, bucket, now);
-			if (this.shouldPruneIdleBucket(key)) this.buckets.delete(key);
-		}
-	}
-	async runQueuedRequest(queued, bucket) {
-		let requeued = false;
-		try {
-			queued.resolve(await this.executor(queued));
-		} catch (error) {
-			if (error instanceof RateLimitError && this.requeueRateLimitedRequest(queued)) {
-				requeued = true;
-				return;
-			}
-			queued.reject(error);
-		} finally {
-			bucket.active = Math.max(0, bucket.active - 1);
-			this.activeWorkers = Math.max(0, this.activeWorkers - 1);
-			if (!requeued) this.queuedRequests = Math.max(0, this.queuedRequests - 1);
-			if (bucket.active === 0 && countPending(bucket) === 0) {
-				for (const routeKey of bucket.routeKeys) if (this.routeBuckets.get(routeKey) === routeKey) this.routeBuckets.delete(routeKey);
-			}
-			this.drainQueues();
-		}
-	}
-	requeueRateLimitedRequest(queued) {
-		if (queued.generation !== this.queueGeneration || queued.retryCount >= this.maxRateLimitRetries) return false;
-		const bucketKey = this.routeBuckets.get(queued.routeKey) ?? queued.routeKey;
-		this.getBucket(bucketKey).pending[queued.priority].push({
-			...queued,
-			enqueuedAt: Date.now(),
-			retryCount: queued.retryCount + 1
-		});
-		this.queuedByLane[queued.priority] += 1;
-		return true;
-	}
-	rejectPending(error) {
-		for (const bucket of this.buckets.values()) for (const lane of requestPriorities) for (const queued of bucket.pending[lane].splice(0)) {
-			queued.reject(error);
-			this.queuedRequests = Math.max(0, this.queuedRequests - 1);
-			this.queuedByLane[lane] = Math.max(0, this.queuedByLane[lane] - 1);
-		}
-	}
-	buildLaneSchedule(lanes) {
-		const schedule = [];
-		for (const lane of requestPriorities) {
-			const weight = lanes[lane].weight;
-			for (let i = 0; i < weight; i += 1) schedule.push(lane);
-		}
-		return schedule.length > 0 ? schedule : [...requestPriorities];
-	}
-	getOldestQueuedAge(lane) {
-		const now = Date.now();
-		let oldest = 0;
-		for (const bucket of this.buckets.values()) {
-			const queued = bucket.pending[lane][0];
-			if (!queued) continue;
-			oldest = Math.max(oldest, now - queued.enqueuedAt);
-		}
-		return oldest;
-	}
-};
-function isGlobalRateLimit(parsed) {
-	return parsed && typeof parsed === "object" && "global" in parsed ? Boolean(parsed.global) : false;
-}
-//#endregion
-//#region extensions/discord/src/internal/rest.ts
-const defaultOptions = {
-	tokenHeader: "Bot",
-	baseUrl: "https://discord.com/api",
-	apiVersion: 10,
-	userAgent: "OpenClaw Discord",
-	timeout: 15e3,
-	queueRequests: true,
-	maxQueueSize: 1e3,
-	runtimeProfile: "persistent"
-};
-const DEFAULT_MAX_CONCURRENT_WORKERS = 4;
-const defaultLaneOptions = {
-	critical: { weight: 6 },
-	standard: { weight: 3 },
-	background: {
-		staleAfterMs: 2e4,
-		weight: 1
-	}
-};
-const DISCORD_REST_RESPONSE_BODY_MAX_BYTES = 8 * 1024 * 1024;
-const GZIP_MAGIC = [31, 139];
-function createResponseBodyOverflowError(size) {
-	return /* @__PURE__ */ new Error(`Discord REST response body exceeds ${DISCORD_REST_RESPONSE_BODY_MAX_BYTES} bytes (received ${size})`);
-}
-async function readResponseBodyText(response, idleTimeoutMs) {
-	return decodeResponseBody(await readResponseWithLimit(response, DISCORD_REST_RESPONSE_BODY_MAX_BYTES, {
-		chunkTimeoutMs: idleTimeoutMs,
-		onOverflow: ({ size }) => createResponseBodyOverflowError(size),
-		onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Discord REST response stalled: no data received for ${chunkTimeoutMs}ms`)
-	}));
-}
-function coerceResponseBody(raw) {
-	if (!raw) return;
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return raw;
-	}
-}
-function decodeResponseBody(buffer) {
-	if (!buffer.byteLength) return "";
-	if (buffer[0] === GZIP_MAGIC[0] && buffer[1] === GZIP_MAGIC[1]) try {
-		return gunzipSync(buffer, { maxOutputLength: DISCORD_REST_RESPONSE_BODY_MAX_BYTES }).toString("utf8");
-	} catch (err) {
-		if (isZlibMaxOutputLengthError(err)) throw createResponseBodyOverflowError("decompressed output");
-		throw err;
-	}
-	return buffer.toString("utf8");
-}
-function isZlibMaxOutputLengthError(err) {
-	return err instanceof RangeError && "code" in err && err.code === "ERR_BUFFER_TOO_LARGE";
-}
-var RequestClient = class {
-	constructor(token, options) {
-		this.requestControllers = /* @__PURE__ */ new Set();
-		this.token = token.replace(/^Bot\s+/i, "");
-		this.customFetch = options?.fetch;
-		this.options = normalizeRequestClientOptions(options);
-		this.scheduler = new RestScheduler({
-			lanes: normalizeSchedulerLanes(this.options.maxQueueSize, this.options.scheduler?.lanes),
-			maxConcurrency: normalizeIntegerOption(this.options.scheduler?.maxConcurrency, DEFAULT_MAX_CONCURRENT_WORKERS, { min: 1 }),
-			maxQueueSize: this.options.maxQueueSize,
-			maxRateLimitRetries: normalizeIntegerOption(this.options.scheduler?.maxRateLimitRetries, 3, { min: 0 })
-		}, async (request) => await this.executeRequest(request.method, request.path, {
-			data: request.data,
-			query: request.query
-		}, request.routeKey));
-	}
-	async get(path, query) {
-		return await this.request("GET", path, { query });
-	}
-	async post(path, data, query) {
-		return await this.request("POST", path, {
-			data,
-			query
-		});
-	}
-	async patch(path, data, query) {
-		return await this.request("PATCH", path, {
-			data,
-			query
-		});
-	}
-	async put(path, data, query) {
-		return await this.request("PUT", path, {
-			data,
-			query
-		});
-	}
-	async delete(path, data, query) {
-		return await this.request("DELETE", path, {
-			data,
-			query
-		});
-	}
-	async request(method, path, params) {
-		const routeKey = createRouteKey(method, path);
-		if (!this.options.queueRequests) return await this.executeRequest(method, path, params, routeKey);
-		return await this.scheduler.enqueue({
-			method,
-			path,
-			priority: getRequestPriority(method, path),
-			...params
-		});
-	}
-	async executeRequest(method, path, params, routeKey = createRouteKey(method, path)) {
-		const url = `${this.options.baseUrl}/v${this.options.apiVersion}${appendQuery(path, params.query)}`;
-		const headers = new Headers({ "User-Agent": this.options.userAgent ?? defaultOptions.userAgent });
-		if (this.token !== "webhook") headers.set("Authorization", `${this.options.tokenHeader ?? "Bot"} ${this.token}`);
-		const body = serializeRequestBody(params.data, headers);
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), this.options.timeout ?? 15e3);
-		timeout.unref?.();
-		const signal = this.options.signal ? AbortSignal.any([this.options.signal, controller.signal]) : controller.signal;
-		this.requestControllers.add(controller);
-		try {
-			const response = await (this.customFetch ?? fetch)(url, {
-				method,
-				headers,
-				body,
-				signal
-			});
-			const parsed = coerceResponseBody(await readResponseBodyText(response, this.options.timeout ?? 15e3));
-			this.scheduler.recordResponse(routeKey, path, response, parsed);
-			if (response.status === 204) return;
-			if (response.status === 429) {
-				const rateLimitBody = isDiscordRateLimitBody(parsed) ? parsed : void 0;
-				throw new RateLimitError(response, {
-					message: readDiscordMessage(rateLimitBody, "Rate limited"),
-					retry_after: readRetryAfter(rateLimitBody, response, 1),
-					code: readDiscordCode(rateLimitBody),
-					global: Boolean(rateLimitBody?.global)
-				});
-			}
-			if (!response.ok) throw new DiscordError(response, parsed);
-			return parsed;
-		} catch (error) {
-			if (error instanceof DOMException && error.name === "AbortError") throw error;
-			if (error instanceof Error) throw error;
-			throw new Error(`Discord request failed: ${inspect(error)}`, { cause: error });
-		} finally {
-			clearTimeout(timeout);
-			this.requestControllers.delete(controller);
-		}
-	}
-	clearQueue() {
-		this.scheduler.clearQueue();
-	}
-	get queueSize() {
-		return this.scheduler.queueSize;
-	}
-	getSchedulerMetrics() {
-		return this.scheduler.getMetrics();
-	}
-	abortAllRequests() {
-		this.scheduler.abortPending();
-		for (const controller of this.requestControllers) controller.abort();
-		this.requestControllers.clear();
-	}
-};
-function normalizeIntegerOption(value, fallback, params) {
-	const candidate = parseFiniteNumber(value) ?? fallback;
-	return Math.max(params.min, Math.floor(candidate));
-}
-function normalizeRequestClientOptions(options) {
-	const merged = {
-		...defaultOptions,
-		...options
-	};
-	return {
-		...merged,
-		apiVersion: normalizeIntegerOption(merged.apiVersion, defaultOptions.apiVersion, { min: 1 }),
-		timeout: clampTimerTimeoutMs(merged.timeout, 1) ?? resolveTimerTimeoutMs(defaultOptions.timeout, 1),
-		maxQueueSize: normalizeIntegerOption(merged.maxQueueSize, defaultOptions.maxQueueSize, { min: 1 })
-	};
-}
-function normalizeSchedulerLanes(maxQueueSize, lanes) {
-	const fallbackMaxQueueSize = normalizeIntegerOption(maxQueueSize, defaultOptions.maxQueueSize, { min: 1 });
-	return {
-		critical: normalizeSchedulerLane("critical", fallbackMaxQueueSize, lanes?.critical),
-		standard: normalizeSchedulerLane("standard", fallbackMaxQueueSize, lanes?.standard),
-		background: normalizeSchedulerLane("background", fallbackMaxQueueSize, lanes?.background)
-	};
-}
-function normalizeSchedulerLane(lane, maxQueueSize, options) {
-	const defaults = defaultLaneOptions[lane];
-	const staleAfterMs = options?.staleAfterMs !== void 0 ? normalizeIntegerOption(options.staleAfterMs, defaults.staleAfterMs ?? 0, { min: 0 }) : defaults.staleAfterMs;
-	return {
-		maxQueueSize: options?.maxQueueSize !== void 0 ? normalizeIntegerOption(options.maxQueueSize, maxQueueSize, { min: 1 }) : maxQueueSize,
-		...staleAfterMs !== void 0 ? { staleAfterMs } : {},
-		weight: options?.weight !== void 0 ? normalizeIntegerOption(options.weight, defaults.weight, { min: 1 }) : defaults.weight
-	};
-}
-function getRequestPriority(method, path) {
-	const normalizedMethod = method.toUpperCase();
-	const normalizedPath = path.toLowerCase();
-	if (/^\/interactions\/\d+\/[^/]+\/callback$/.test(normalizedPath)) return "critical";
-	return normalizedMethod === "GET" ? "background" : "standard";
-}
-//#endregion
-//#region extensions/discord/src/internal/client.ts
-var Plugin = class {};
-var Client = class {
-	constructor(options, handlers, plugins = []) {
-		this.routes = [];
-		this.plugins = [];
-		this.componentHandler = new ComponentRegistry();
-		this.modalHandler = new ComponentRegistry();
-		if (!options.clientId) throw new Error("Missing Discord application ID");
-		if (!options.token) throw new Error("Missing Discord bot token");
-		this.options = {
-			...options,
-			baseUrl: options.baseUrl.replace(/\/+$/, "")
-		};
-		this.commands = handlers.commands ?? [];
-		this.listeners = handlers.listeners ?? [];
-		this.rest = new RequestClient(options.token, options.requestOptions);
-		this.eventQueue = this.options.eventQueue ? new DiscordEventQueue(this.options.eventQueue) : void 0;
-		this.entityCache = new DiscordEntityCache({
-			client: this,
-			rest: () => this.rest,
-			ttlMs: this.options.restCacheTtlMs
-		});
-		this.commandDeployer = new DiscordCommandDeployer({
-			clientId: this.options.clientId,
-			commands: this.commands,
-			devGuilds: this.options.devGuilds,
-			hashStore: this.options.commandDeployHashStore,
-			rest: () => this.rest
-		});
-		for (const component of handlers.components ?? []) this.componentHandler.register(component);
-		for (const command of this.commands) for (const component of command.components ?? []) this.componentHandler.register(component);
-		for (const modal of handlers.modals ?? []) this.modalHandler.register(modal);
-		for (const plugin of plugins) {
-			plugin.registerClient?.(this);
-			plugin.registerRoutes?.(this);
-			this.plugins.push({
-				id: plugin.id,
-				plugin
-			});
-		}
-	}
-	getPlugin(id) {
-		return this.plugins.find((entry) => entry.id === id)?.plugin;
-	}
-	registerListener(listener) {
-		if (!this.listeners.includes(listener)) this.listeners.push(listener);
-		return listener;
-	}
-	unregisterListener(listener) {
-		const index = this.listeners.indexOf(listener);
-		if (index < 0) return false;
-		this.listeners.splice(index, 1);
-		return true;
-	}
-	getRuntimeMetrics() {
-		return {
-			request: this.rest.getSchedulerMetrics(),
-			eventQueue: this.eventQueue?.getMetrics()
-		};
-	}
-	async fetchUser(id) {
-		return await this.entityCache.fetchUser(id);
-	}
-	async fetchChannel(id) {
-		return await this.entityCache.fetchChannel(id);
-	}
-	async fetchGuild(id) {
-		return await this.entityCache.fetchGuild(id);
-	}
-	async fetchMember(guildId, userId) {
-		return await this.entityCache.fetchMember(guildId, userId);
-	}
-	async deployCommands(options = {}) {
-		return await this.commandDeployer.deploy(options);
-	}
-	async handleInteraction(rawData, _ctx) {
-		await dispatchInteraction(this, rawData);
-	}
-	async dispatchGatewayEvent(type, data) {
-		this.entityCache.invalidateForGatewayEvent(type, data);
-		const listeners = this.listeners.filter((entry) => entry.type === type);
-		if (!this.eventQueue) {
-			for (const listener of listeners) await listener.handle(data, this);
-			return;
-		}
-		await Promise.all(listeners.map((listener) => this.eventQueue.enqueue({
-			eventType: type,
-			listenerName: listener.constructor.name || "AnonymousListener",
-			run: async () => {
-				await listener.handle(data, this);
-			}
-		})));
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/listeners.ts
-var BaseListener = class {};
-var ReadyListener = class extends BaseListener {
-	constructor(..._args) {
-		super(..._args);
-		this.type = GatewayDispatchEvents.Ready;
-	}
-};
-var ResumedListener = class extends BaseListener {
-	constructor(..._args2) {
-		super(..._args2);
-		this.type = GatewayDispatchEvents.Resumed;
-	}
-};
-var GuildCreateListener = class extends BaseListener {
-	constructor(..._args3) {
-		super(..._args3);
-		this.type = GatewayDispatchEvents.GuildCreate;
-	}
-};
-var GuildDeleteListener = class extends BaseListener {
-	constructor(..._args4) {
-		super(..._args4);
-		this.type = GatewayDispatchEvents.GuildDelete;
-	}
-};
-var MessageCreateListener = class extends BaseListener {
-	constructor(..._args5) {
-		super(..._args5);
-		this.type = GatewayDispatchEvents.MessageCreate;
-	}
-};
-var InteractionCreateListener = class extends BaseListener {
-	constructor(..._args6) {
-		super(..._args6);
-		this.type = GatewayDispatchEvents.InteractionCreate;
-	}
-};
-var MessageReactionAddListener = class extends BaseListener {
-	constructor(..._args7) {
-		super(..._args7);
-		this.type = GatewayDispatchEvents.MessageReactionAdd;
-	}
-};
-var MessageReactionRemoveListener = class extends BaseListener {
-	constructor(..._args8) {
-		super(..._args8);
-		this.type = GatewayDispatchEvents.MessageReactionRemove;
-	}
-};
-var PresenceUpdateListener = class extends BaseListener {
-	constructor(..._args9) {
-		super(..._args9);
-		this.type = GatewayDispatchEvents.PresenceUpdate;
-	}
-};
-var VoiceStateUpdateListener = class extends BaseListener {
-	constructor(..._args10) {
-		super(..._args10);
-		this.type = GatewayDispatchEvents.VoiceStateUpdate;
-	}
-};
-var ThreadUpdateListener = class extends BaseListener {
-	constructor(..._args11) {
-		super(..._args11);
-		this.type = GatewayDispatchEvents.ThreadUpdate;
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/discord.ts
-var discord_exports = /* @__PURE__ */ __exportAll({
-	AutocompleteInteraction: () => AutocompleteInteraction,
-	BaseCommand: () => BaseCommand,
-	BaseComponentInteraction: () => BaseComponentInteraction,
-	BaseMessageInteractiveComponent: () => BaseMessageInteractiveComponent,
-	Button: () => Button,
-	ButtonInteraction: () => ButtonInteraction,
-	ChannelSelectMenu: () => ChannelSelectMenu,
-	ChannelSelectMenuInteraction: () => ChannelSelectMenuInteraction,
-	CheckboxGroup: () => CheckboxGroup,
-	Client: () => Client,
-	Command: () => Command,
-	CommandInteraction: () => CommandInteraction,
-	CommandWithSubcommands: () => CommandWithSubcommands,
-	Container: () => Container,
-	DiscordError: () => DiscordError,
-	Embed: () => Embed,
-	File: () => File,
-	Guild: () => Guild,
-	GuildCreateListener: () => GuildCreateListener,
-	GuildDeleteListener: () => GuildDeleteListener,
-	GuildMember: () => GuildMember,
-	InteractionCreateListener: () => InteractionCreateListener,
-	Label: () => Label,
-	LinkButton: () => LinkButton,
-	MediaGallery: () => MediaGallery,
-	MentionableSelectMenu: () => MentionableSelectMenu,
-	MentionableSelectMenuInteraction: () => MentionableSelectMenuInteraction,
-	Message: () => Message,
-	MessageCreateListener: () => MessageCreateListener,
-	MessageReactionAddListener: () => MessageReactionAddListener,
-	MessageReactionRemoveListener: () => MessageReactionRemoveListener,
-	Modal: () => Modal,
-	ModalInteraction: () => ModalInteraction,
-	Plugin: () => Plugin,
-	PresenceUpdateListener: () => PresenceUpdateListener,
-	RadioGroup: () => RadioGroup,
-	RateLimitError: () => RateLimitError,
-	ReadyListener: () => ReadyListener,
-	RequestClient: () => RequestClient,
-	ResumedListener: () => ResumedListener,
-	Role: () => Role,
-	RoleSelectMenu: () => RoleSelectMenu,
-	RoleSelectMenuInteraction: () => RoleSelectMenuInteraction,
-	Row: () => Row,
-	Section: () => Section,
-	Separator: () => Separator,
-	StringSelectMenu: () => StringSelectMenu,
-	StringSelectMenuInteraction: () => StringSelectMenuInteraction,
-	TextDisplay: () => TextDisplay,
-	TextInput: () => TextInput,
-	ThreadUpdateListener: () => ThreadUpdateListener,
-	Thumbnail: () => Thumbnail,
-	User: () => User,
-	UserSelectMenu: () => UserSelectMenu,
-	UserSelectMenuInteraction: () => UserSelectMenuInteraction,
-	VoiceStateUpdateListener: () => VoiceStateUpdateListener,
-	addGuildMemberRole: () => addGuildMemberRole,
-	channelFactory: () => channelFactory,
-	createApplicationCommand: () => createApplicationCommand,
-	createChannelMessage: () => createChannelMessage,
-	createChannelWebhook: () => createChannelWebhook,
-	createGuildBan: () => createGuildBan,
-	createGuildChannel: () => createGuildChannel,
-	createGuildEmoji: () => createGuildEmoji,
-	createGuildScheduledEvent: () => createGuildScheduledEvent,
-	createGuildSticker: () => createGuildSticker,
-	createInteraction: () => createInteraction,
-	createInteractionCallback: () => createInteractionCallback,
-	createOwnMessageReaction: () => createOwnMessageReaction,
-	createThread: () => createThread,
-	createUserDmChannel: () => createUserDmChannel,
-	createWebhookMessage: () => createWebhookMessage,
-	deferCommandInteractionIfNeeded: () => deferCommandInteractionIfNeeded,
-	deleteApplicationCommand: () => deleteApplicationCommand,
-	deleteChannel: () => deleteChannel,
-	deleteChannelMessage: () => deleteChannelMessage,
-	deleteChannelPermission: () => deleteChannelPermission,
-	deleteOwnMessageReaction: () => deleteOwnMessageReaction,
-	deleteWebhookMessage: () => deleteWebhookMessage,
-	editApplicationCommand: () => editApplicationCommand,
-	editChannel: () => editChannel,
-	editChannelMessage: () => editChannelMessage,
-	editWebhookMessage: () => editWebhookMessage,
-	getChannel: () => getChannel,
-	getChannelMessage: () => getChannelMessage,
-	getCurrentUser: () => getCurrentUser,
-	getGuild: () => getGuild,
-	getGuildMember: () => getGuildMember,
-	getGuildVoiceState: () => getGuildVoiceState,
-	getThreadMember: () => getThreadMember,
-	getUser: () => getUser,
-	getWebhookMessage: () => getWebhookMessage,
-	isUnknownDiscordVoiceStateError: () => isUnknownDiscordVoiceStateError,
-	listApplicationCommands: () => listApplicationCommands,
-	listChannelArchivedThreads: () => listChannelArchivedThreads,
-	listChannelMessages: () => listChannelMessages,
-	listChannelPins: () => listChannelPins,
-	listGuildActiveThreads: () => listGuildActiveThreads,
-	listGuildChannels: () => listGuildChannels,
-	listGuildEmojis: () => listGuildEmojis,
-	listGuildRoles: () => listGuildRoles,
-	listGuildScheduledEvents: () => listGuildScheduledEvents,
-	listMessageReactionUsers: () => listMessageReactionUsers,
-	moveGuildChannels: () => moveGuildChannels,
-	overwriteApplicationCommands: () => overwriteApplicationCommands,
-	overwriteGuildApplicationCommands: () => overwriteGuildApplicationCommands,
-	parseComponentInteractionData: () => parseComponentInteractionData,
-	parseCustomId: () => parseCustomId,
-	pinChannelMessage: () => pinChannelMessage,
-	putChannelPermission: () => putChannelPermission,
-	removeGuildMember: () => removeGuildMember,
-	removeGuildMemberRole: () => removeGuildMemberRole,
-	resolveFocusedCommandOptionAutocompleteHandler: () => resolveFocusedCommandOptionAutocompleteHandler,
-	searchGuildMessages: () => searchGuildMessages,
-	sendChannelTyping: () => sendChannelTyping,
-	serializePayload: () => serializePayload,
-	timeoutGuildMember: () => timeoutGuildMember,
-	unpinChannelMessage: () => unpinChannelMessage
-});
-import * as import_discord_api_types_v10 from "discord-api-types/v10";
-__reExport(discord_exports, import_discord_api_types_v10);
-//#endregion
-//#region extensions/discord/src/target-parsing.ts
-function parseDiscordTarget(raw, options = {}) {
-	const trimmed = raw.trim();
-	if (!trimmed) return;
-	const providerPrefixedTarget = parseDiscordProviderPrefixedTarget(trimmed);
-	if (providerPrefixedTarget) return providerPrefixedTarget;
-	const userTarget = parseMentionPrefixOrAtUserTarget({
-		raw: trimmed,
-		mentionPattern: /^<@!?(\d+)>$/,
-		prefixes: [
-			{
-				prefix: "user:",
-				kind: "user"
-			},
-			{
-				prefix: "channel:",
-				kind: "channel"
-			},
-			{
-				prefix: "discord:",
-				kind: "user"
-			}
-		],
-		atUserPattern: /^\d+$/,
-		atUserErrorMessage: "Discord DMs require a user id (use user:<id> or a <@id> mention)"
-	});
-	if (userTarget) return userTarget;
-	if (/^\d+$/.test(trimmed)) {
-		if (options.defaultKind) return buildMessagingTarget(options.defaultKind, trimmed, trimmed);
-		throw new Error(options.ambiguousMessage ?? `Ambiguous Discord recipient "${trimmed}". For DMs use "user:${trimmed}" or "<@${trimmed}>"; for channels use "channel:${trimmed}".`);
-	}
-	return buildMessagingTarget("channel", trimmed, trimmed);
-}
-function parseDiscordProviderPrefixedTarget(raw) {
-	const match = /^discord:(channel|user):(.+)$/i.exec(raw);
-	if (!match) return;
-	const kind = match[1]?.toLowerCase();
-	const id = match[2]?.trim();
-	if (!kind || !id) return;
-	return buildMessagingTarget(kind, id, `${kind}:${id}`);
-}
-function resolveDiscordChannelId(raw) {
-	return requireTargetKind({
-		platform: "Discord",
-		target: parseDiscordTarget(raw, { defaultKind: "channel" }),
-		kind: "channel"
-	});
-}
-//#endregion
-//#region extensions/discord/src/normalize.ts
-function normalizeDiscordMessagingTarget(raw) {
-	return parseDiscordTarget(raw, { defaultKind: "channel" })?.normalized;
-}
-/**
-* Normalize a Discord outbound target for delivery. Bare numeric IDs are
-* prefixed with "channel:" to avoid the ambiguous-target error in
-* parseDiscordTarget, unless the ID is explicitly configured as an allowed DM
-* sender. All other formats pass through unchanged.
-*/
-function normalizeDiscordOutboundTarget(to, allowFrom) {
-	const trimmed = to?.trim();
-	if (!trimmed) return {
-		ok: false,
-		error: /* @__PURE__ */ new Error("Discord recipient is required. Use \"channel:<id>\" for channels or \"user:<id>\" for DMs.")
-	};
-	if (/^\d+$/.test(trimmed)) {
-		if (allowFromContainsDiscordUserId(allowFrom, trimmed)) return {
-			ok: true,
-			to: `user:${trimmed}`
-		};
-		return {
-			ok: true,
-			to: `channel:${trimmed}`
-		};
-	}
-	return {
-		ok: true,
-		to: trimmed
-	};
-}
-function allowFromContainsDiscordUserId(allowFrom, userId) {
-	const normalizedUserId = userId.trim();
-	if (!normalizedUserId) return false;
-	return resolveAllowlistMatchByCandidates({
-		allowList: (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry)),
-		candidates: [{
-			value: normalizedUserId,
-			source: "id"
-		}]
-	}).allowed;
-}
-function normalizeAllowFromDiscordUserId(entry) {
-	const trimmed = entry.trim().toLowerCase();
-	if (!trimmed || trimmed === "*") return;
-	const mentionMatch = /^<@!?(\d+)>$/.exec(trimmed);
-	if (mentionMatch) return mentionMatch[1];
-	const prefixedMatch = /^(?:discord:)?user:(\d+)$/.exec(trimmed);
-	if (prefixedMatch) return prefixedMatch[1];
-	const discordMatch = /^discord:(\d+)$/.exec(trimmed);
-	if (discordMatch) return discordMatch[1];
-	return /^\d+$/.test(trimmed) ? trimmed : void 0;
-}
-function looksLikeDiscordTargetId(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return false;
-	if (/^<@!?\d+>$/.test(trimmed)) return true;
-	if (/^(?:(?:user|channel|discord):\d+|discord:(?:user|channel):\d+)$/i.test(trimmed)) return true;
-	if (/^\d{6,}$/.test(trimmed)) return true;
-	return false;
-}
-//#endregion
-//#region extensions/discord/src/reply-reference.ts
-function resolveDiscordReplyReference(params) {
-	if (!params.replyToId) return;
-	const singleUse = params.replyToIdSource !== "explicit" && params.replyToMode !== void 0 && isSingleUseReplyToMode(params.replyToMode);
-	return {
-		messageId: params.replyToId,
-		scope: singleUse ? "first" : "all"
-	};
-}
-function createReusableDiscordReplyReference(messageId) {
-	return messageId ? {
-		messageId,
-		scope: "all"
-	} : void 0;
-}
-function resolveDiscordReplyMessageId(reply, isFirst) {
-	return reply && (isFirst || reply.scope === "all") ? reply.messageId : void 0;
-}
-//#endregion
-//#region extensions/discord/src/chunk.ts
-const DEFAULT_MAX_CHARS = 2e3;
-const DEFAULT_MAX_LINES = 17;
-const REASONING_ITALICS_MARKER_CHARS = 2;
-const MIN_REASONING_ITALICS_CHUNK_CHARS = 4;
-const FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
-function hasReasoningItalics(text) {
-	return /^(?:Reasoning:|Thinking\.{0,3})\n+_/u.test(text) && text.trimEnd().endsWith("_");
-}
-function resolveDiscordChunkLimit(value, fallback) {
-	return resolveIntegerOption(value, fallback, { min: 1 });
-}
-function countLines(text) {
-	if (!text) return 0;
-	return text.split("\n").length;
-}
-function parseFenceLine(line) {
-	const match = line.match(FENCE_RE);
-	if (!match) return null;
-	const indent = match[1] ?? "";
-	const marker = match[2] ?? "";
-	return {
-		indent,
-		markerChar: marker[0] ?? "`",
-		markerLen: marker.length,
-		openLine: line
-	};
-}
-function closeFenceLine(openFence) {
-	return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
-}
-function canBalanceFence(openFence, maxChars) {
-	return closeFenceLine(openFence).length * 2 + 3 <= maxChars;
-}
-function reopenFenceLine(openFence, maxChars) {
-	const bareMarker = closeFenceLine(openFence);
-	if (!canBalanceFence(openFence, maxChars)) return null;
-	if (openFence.openLine.length + bareMarker.length + 3 <= maxChars) return openFence.openLine;
-	return bareMarker;
-}
-function closeFenceIfNeeded(text, openFence, maxChars) {
-	if (!openFence || !canBalanceFence(openFence, maxChars)) return text;
-	const closeLine = closeFenceLine(openFence);
-	if (!text) return closeLine;
-	if (!text.endsWith("\n")) return `${text}\n${closeLine}`;
-	return `${text}${closeLine}`;
-}
-/**
-* Chunks outbound Discord text by both character count and (soft) line count,
-* while keeping fenced code blocks balanced across chunks.
-*/
-function chunkDiscordText(text, opts = {}) {
-	const hardMaxChars = resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS);
-	const maxLines = resolveDiscordChunkLimit(opts.maxLines, DEFAULT_MAX_LINES);
-	const body = text ?? "";
-	if (!body) return [];
-	if (body.length <= hardMaxChars && countLines(body) <= maxLines) return [body];
-	const maxChars = hardMaxChars >= MIN_REASONING_ITALICS_CHUNK_CHARS && hasReasoningItalics(body) ? hardMaxChars - REASONING_ITALICS_MARKER_CHARS : hardMaxChars;
-	const lines = body.split("\n");
-	const chunks = [];
-	let current = "";
-	let currentLines = 0;
-	let openFence = null;
-	const flush = () => {
-		if (!current) return;
-		const payload = closeFenceIfNeeded(current, openFence, maxChars);
-		if (payload.trim().length) chunks.push(payload);
-		current = "";
-		currentLines = 0;
-		if (openFence) {
-			const reopenLine = reopenFenceLine(openFence, maxChars);
-			if (reopenLine) {
-				current = reopenLine;
-				currentLines = 1;
-			}
-		}
-	};
-	for (const originalLine of lines) {
-		const fenceInfo = parseFenceLine(originalLine);
-		const wasInsideFence = openFence !== null;
-		let nextOpenFence = openFence;
-		if (fenceInfo) {
-			if (!openFence) nextOpenFence = fenceInfo;
-			else if (openFence.markerChar === fenceInfo.markerChar && fenceInfo.markerLen >= openFence.markerLen) nextOpenFence = null;
-		}
-		const candidateFence = nextOpenFence ?? openFence;
-		const fenceToReserve = candidateFence && canBalanceFence(candidateFence, maxChars) ? candidateFence : null;
-		const reserveChars = fenceToReserve ? closeFenceLine(fenceToReserve).length + 1 : 0;
-		const reserveLines = fenceToReserve ? 1 : 0;
-		const effectiveMaxChars = maxChars - reserveChars;
-		const effectiveMaxLines = maxLines - reserveLines;
-		const charLimit = effectiveMaxChars > 0 ? effectiveMaxChars : maxChars;
-		const lineLimit = effectiveMaxLines > 0 ? effectiveMaxLines : maxLines;
-		const reopenPrefixLen = fenceToReserve ? reopenFenceLine(fenceToReserve, maxChars)?.length ?? 0 : 0;
-		const prefixLen = current.length > 0 ? current.length + 1 : 0;
-		const reopenBudget = reopenPrefixLen > 0 ? reopenPrefixLen + 1 : 0;
-		const segments = chunkTextForOutbound(originalLine, Math.max(1, charLimit - Math.max(prefixLen, reopenBudget)), { preserveWhitespace: wasInsideFence });
-		for (let segIndex = 0; segIndex < segments.length; segIndex++) {
-			const segment = segments[segIndex];
-			const isLineContinuation = segIndex > 0;
-			let delimiter = isLineContinuation ? "" : current.length > 0 ? "\n" : "";
-			let addition = `${delimiter}${segment}`;
-			const nextLen = current.length + addition.length;
-			const nextLines = currentLines + (isLineContinuation ? 0 : 1);
-			if ((nextLen > charLimit || nextLines > lineLimit) && current.length > 0) {
-				flush();
-				delimiter = current.length > 0 ? "\n" : "";
-				addition = `${delimiter}${segment}`;
-			}
-			if (current.length > 0) {
-				current += addition;
-				if (!isLineContinuation || delimiter) currentLines += 1;
-			} else {
-				current = expectDefined(segment, "current Discord chunk segment");
-				currentLines = 1;
-			}
-		}
-		openFence = nextOpenFence;
-	}
-	if (current.length) {
-		const payload = closeFenceIfNeeded(current, openFence, maxChars);
-		if (payload.trim().length) chunks.push(payload);
-	}
-	return rebalanceReasoningItalics(text, chunks, hardMaxChars);
-}
-function chunkDiscordTextWithMode(text, opts) {
-	if ((opts.chunkMode ?? "length") !== "newline") return chunkDiscordText(text, opts);
-	const lineChunks = chunkMarkdownTextWithMode(text, resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS), "newline");
-	const chunks = [];
-	for (const line of lineChunks) {
-		const nested = chunkDiscordText(line, opts);
-		if (!nested.length && line) {
-			chunks.push(line);
-			continue;
-		}
-		chunks.push(...nested);
-	}
-	return chunks;
-}
-function leadingCodeSpanEnd(body) {
-	if (!body) return -1;
-	const firstNewline = body.indexOf("\n");
-	const openFence = parseFenceLine(firstNewline === -1 ? body : body.slice(0, firstNewline));
-	if (openFence) {
-		if (firstNewline === -1) return body.length;
-		let lineStart = firstNewline + 1;
-		while (lineStart <= body.length) {
-			const lineEnd = body.indexOf("\n", lineStart);
-			const line = lineEnd === -1 ? body.slice(lineStart) : body.slice(lineStart, lineEnd);
-			const closeFence = parseFenceLine(line);
-			const closeSuffix = closeFence ? line.slice(closeFence.indent.length + closeFence.markerLen) : "";
-			if (closeFence?.markerChar === openFence.markerChar && closeFence.markerLen >= openFence.markerLen && /^[ \t]*_?[ \t]*$/u.test(closeSuffix)) {
-				const markerEnd = closeFence.indent.length + closeFence.markerLen;
-				const trailingSpaces = /^ */.exec(line.slice(markerEnd))?.[0].length ?? 0;
-				return lineStart + markerEnd + trailingSpaces;
-			}
-			if (lineEnd === -1) return body.length;
-			lineStart = lineEnd + 1;
-		}
-		return body.length;
-	}
-	if (!body.startsWith("`")) return -1;
-	const ticks = /^(?<ticks>`+)/.exec(body)?.groups?.ticks;
-	if (!ticks) return -1;
-	for (let index = ticks.length; index < body.length;) {
-		if (body[index] !== "`") {
-			index += 1;
-			continue;
-		}
-		let runEnd = index + 1;
-		while (body[runEnd] === "`") runEnd += 1;
-		if (runEnd - index === ticks.length) return runEnd;
-		index = runEnd;
-	}
-	return -1;
-}
-function leadingCodePrefixEnd(body) {
-	let prefixEnd = leadingCodeSpanEnd(body);
-	if (prefixEnd < 0) return -1;
-	while (prefixEnd < body.length) {
-		const separator = /^\s+/u.exec(body.slice(prefixEnd))?.[0] ?? "";
-		if (!separator) break;
-		const nextStart = prefixEnd + separator.length;
-		const nextEnd = leadingCodeSpanEnd(body.slice(nextStart));
-		if (nextEnd < 0) break;
-		prefixEnd = nextStart + nextEnd;
-	}
-	return prefixEnd;
-}
-function hasReasoningItalicsOpen(chunk) {
-	const trimmed = chunk.trimStart();
-	if (trimmed.startsWith("_") || /^(?:Reasoning:|Thinking\.{0,3})\n+_/u.test(trimmed)) return true;
-	const codeEnd = leadingCodePrefixEnd(trimmed);
-	return codeEnd >= 0 && trimmed.slice(codeEnd).trimStart().startsWith("_");
-}
-function reopenReasoningItalicsAfterLeadingCode(body, codeEnd) {
-	const code = body.slice(0, codeEnd);
-	const rest = body.slice(codeEnd);
-	if (!rest.trim()) return code + rest;
-	if (/^\s*_\s*$/.test(rest)) return code;
-	const whitespaceLength = rest.length - rest.trimStart().length;
-	const whitespace = rest.slice(0, whitespaceLength);
-	const restBody = rest.slice(whitespaceLength);
-	return restBody.startsWith("_") ? code + rest : `${code}${whitespace}_${restBody}`;
-}
-function rebalanceReasoningItalics(source, chunks, maxChars) {
-	if (chunks.length <= 1 || maxChars < MIN_REASONING_ITALICS_CHUNK_CHARS) return chunks;
-	if (!hasReasoningItalics(source)) return chunks;
-	const adjusted = [...chunks];
-	for (let i = 0; i < adjusted.length; i++) {
-		const isLast = i === adjusted.length - 1;
-		const current = expectDefined(adjusted[i], "Discord chunk adjustment index");
-		if (!current.trimEnd().endsWith("_") && hasReasoningItalicsOpen(current)) adjusted[i] = `${current}_`;
-		if (isLast) break;
-		const next = expectDefined(adjusted[i + 1], "non-final Discord chunk successor");
-		const leadingWhitespaceLen = next.length - next.trimStart().length;
-		const leadingWhitespace = next.slice(0, leadingWhitespaceLen);
-		const nextBody = next.slice(leadingWhitespaceLen);
-		if (nextBody.startsWith("_")) continue;
-		const codeEnd = leadingCodePrefixEnd(nextBody);
-		adjusted[i + 1] = codeEnd >= 0 ? `${leadingWhitespace}${reopenReasoningItalicsAfterLeadingCode(nextBody, codeEnd)}` : `${leadingWhitespace}_${nextBody}`;
-	}
-	return adjusted;
-}
-//#endregion
-export { Section as $, readDiscordMessage as A, createGuildBan as At, Label as B, listGuildChannels as Bt, Client as C, listChannelMessages as Ct, RateLimitError as D, sendChannelTyping as Dt, DiscordError as E, searchGuildMessages as Et, Message as F, deleteChannelPermission as Ft, ChannelSelectMenu as G, putChannelPermission as Gt, RadioGroup as H, listGuildRoles as Ht, User as I, getGuild as It, LinkButton as J, timeoutGuildMember as Jt, Container as K, removeGuildMember as Kt, serializePayload as L, getGuildMember as Lt, Command as M, createGuildEmoji as Mt, CommandWithSubcommands as N, createGuildScheduledEvent as Nt, isUnknownDiscordVoiceStateError as O, unpinChannelMessage as Ot, Guild as P, createGuildSticker as Pt, Row as Q, Embed as R, getGuildVoiceState as Rt, VoiceStateUpdateListener as S, listChannelArchivedThreads as St, RequestClient as T, pinChannelMessage as Tt, TextInput as U, listGuildScheduledEvents as Ut, Modal as V, listGuildEmojis as Vt, Button as W, moveGuildChannels as Wt, MentionableSelectMenu as X, MediaGallery as Y, __exportAll as Yt, RoleSelectMenu as Z, MessageReactionRemoveListener as _, editChannel as _t, allowFromContainsDiscordUserId as a, BaseMessageInteractiveComponent as at, ResumedListener as b, getChannelMessage as bt, normalizeDiscordOutboundTarget as c, createUserDmChannel as ct, discord_exports as d, deleteOwnMessageReaction as dt, Separator as et, GuildCreateListener as f, listMessageReactionUsers as ft, MessageReactionAddListener as g, deleteChannelMessage as gt, MessageCreateListener as h, deleteChannel as ht, resolveDiscordReplyReference as i, UserSelectMenu as it, readRetryAfter as j, createGuildChannel as jt, readDiscordCode as k, addGuildMemberRole as kt, parseDiscordTarget as l, getCurrentUser as lt, InteractionCreateListener as m, createThread as mt, createReusableDiscordReplyReference as n, TextDisplay as nt, looksLikeDiscordTargetId as o, parseCustomId as ot, GuildDeleteListener as p, createChannelMessage as pt, File as q, removeGuildMemberRole as qt, resolveDiscordReplyMessageId as r, Thumbnail as rt, normalizeDiscordMessagingTarget as s, createChannelWebhook as st, chunkDiscordTextWithMode as t, StringSelectMenu as tt, resolveDiscordChannelId as u, createOwnMessageReaction as ut, PresenceUpdateListener as v, editChannelMessage as vt, Plugin as w, listChannelPins as wt, ThreadUpdateListener as x, getThreadMember as xt, ReadyListener as y, getChannel as yt, CheckboxGroup as z, listGuildActiveThreads as zt };