@openclaw/discord 2026.8.2 → 2026.8.34

package/dist/retry-t5RcEsPk.js

@@ -1,3626 +0,0 @@
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-BrLjLUJi.js";
-import "node:module";
-import { redactIdentifier, redactSensitiveFieldValue } from "openclaw/plugin-sdk/logging-core";
-import { ApplicationCommandOptionType, ApplicationCommandType, ButtonStyle, ComponentType, GatewayDispatchEvents, InteractionContextType, InteractionResponseType, InteractionType, MessageFlags, Routes, TextInputStyle } from "discord-api-types/v10";
-import { Type } from "typebox";
-import { Check } from "typebox/value";
-import { createHash } from "node:crypto";
-import { asDateTimestampMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveIntegerOption, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { inspect } from "node:util";
-import { gunzipSync } from "node:zlib";
-import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
-import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
-import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner, parseRetryAfterHeaderSeconds, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-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";
-import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
-//#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
-const discordGuildEmojiListSchema = Type.Array(Type.Object({
-	id: Type.Union([Type.String(), Type.Null()]),
-	name: Type.Union([Type.String(), Type.Null()]),
-	animated: Type.Optional(Type.Boolean())
-}, { additionalProperties: true }));
-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) {
-	const emojis = await rest.get(Routes.guildEmojis(guildId));
-	if (!Check(discordGuildEmojiListSchema, emojis)) throw new Error("Invalid Discord guild emoji response.");
-	return emojis;
-}
-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/undefined-fields.ts
-function stripUndefinedFields(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-//#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 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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			...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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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 stripUndefinedFields({
-			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
-var Embed = class {
-	constructor(embed) {
-		Object.assign(this, embed);
-	}
-	serialize() {
-		return stripUndefinedFields({
-			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 hasDiscordV2Components(components) {
-	return Boolean(components?.some((component) => "isV2" in component && component.isV2 || "type" in component && component.type !== ComponentType.ActionRow));
-}
-function normalizePayloadFlags(payload) {
-	const flags = payload.ephemeral ? (payload.flags ?? 0) | MessageFlags.Ephemeral : payload.flags;
-	if (!hasDiscordV2Components(payload.components)) 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 stripUndefinedFields({
-		content: payload.content,
-		embeds: payload.embeds?.map((entry) => "serialize" in entry ? entry.serialize() : entry),
-		components: payload.components?.map((entry) => "serialize" in entry ? entry.serialize() : 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: existing.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 ?? "";
-	}
-	get icon() {
-		return this.rawDataValue?.icon;
-	}
-	get iconUrl() {
-		return this.icon ? `https://cdn.discordapp.com/icons/${this.id}/${this.icon}.png` : null;
-	}
-};
-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);
-		});
-	}
-	async fetchGuildEmojis(guildId, fetcher) {
-		return await this.fetchCached(`guild-emojis:${guildId}`, fetcher);
-	}
-	invalidateForGatewayEvent(type, data) {
-		const raw = data && typeof data === "object" ? data : {};
-		const channelUpdate = GatewayDispatchEvents.ChannelUpdate;
-		const channelDelete = GatewayDispatchEvents.ChannelDelete;
-		const threadUpdate = GatewayDispatchEvents.ThreadUpdate;
-		const threadDelete = GatewayDispatchEvents.ThreadDelete;
-		const guildUpdate = GatewayDispatchEvents.GuildUpdate;
-		const guildEmojisUpdate = GatewayDispatchEvents.GuildEmojisUpdate;
-		const guildMemberAdd = GatewayDispatchEvents.GuildMemberAdd;
-		const guildMemberRemove = GatewayDispatchEvents.GuildMemberRemove;
-		const guildMemberUpdate = GatewayDispatchEvents.GuildMemberUpdate;
-		if (type === channelUpdate || type === channelDelete || type === threadUpdate || type === threadDelete) this.deleteId("channel", raw.id);
-		if (type === guildUpdate) this.deleteId("guild", raw.id);
-		if (type === guildEmojisUpdate) this.deleteId("guild-emojis", raw.guild_id);
-		if (type === guildMemberAdd || type === guildMemberRemove || 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 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 resolveFocusedCommandOptionAutocompleteHandler(command, interaction) {
-	const focusedName = interaction.options.getFocused()?.name;
-	const autocomplete = findCommandOption(command.commandKind === "group" ? findSelectedSubcommand(command.subcommands, interaction)?.options : command.options, 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 stripUndefinedFields({
-			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.commandKind = "leaf";
-		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.commandKind = "group";
-		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) => stripUndefinedFields({
-			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.pendingResponse = Promise.resolve();
-		this.sentFollowUp = false;
-		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;
-	}
-	/**
-	* True once a follow-up message has been delivered. Follow-ups are visible to
-	* the user but never advance `responseState`, so this is the only record that
-	* the interaction has already produced output.
-	*/
-	get hasSentFollowUp() {
-		return this.sentFollowUp;
-	}
-	enqueueResponse(operation) {
-		const result = this.pendingResponse.then(operation);
-		this.pendingResponse = result.then(() => void 0, () => void 0);
-		return result;
-	}
-	async performCallback(type, data) {
-		if (this.response.acknowledged) throw new Error("Discord interaction has already been acknowledged.");
-		const result = await createInteractionCallback(this.client.rest, this.id, this.token, data === void 0 ? { type } : {
-			type,
-			data
-		});
-		this.response.recordCallback(type);
-		return result;
-	}
-	async callback(type, data) {
-		return await this.enqueueResponse(() => this.performCallback(type, data));
-	}
-	async reply(payload) {
-		return await this.enqueueResponse(async () => {
-			const action = this.response.nextReplyAction();
-			if (action === "edit") return await this.performReplyEdit(payload);
-			if (action === "follow-up") return await this.performFollowUp(payload);
-			return await this.performCallback(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) {
-		return await this.enqueueResponse(() => this.performReplyEdit(payload));
-	}
-	/**
-	* Edits the deferred placeholder only if this interaction is still an
-	* unanswered spinner when the queue reaches this operation.
-	*
-	* Both conditions are re-read inside the queue. A follow-up that was still in
-	* flight when the caller decided to report will have settled — and recorded
-	* itself in `sentFollowUp` — by the time this runs, so the decision cannot be
-	* made against state that is about to change.
-	*
-	* Resolves true when the edit was sent.
-	*/
-	async editDeferredPlaceholderIfUnanswered(payload) {
-		return await this.enqueueResponse(async () => {
-			if (this.responseState !== "deferred" || this.sentFollowUp) return false;
-			await this.performReplyEdit(payload);
-			return true;
-		});
-	}
-	async performReplyEdit(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() {
-		return await this.enqueueResponse(async () => {
-			const result = await deleteWebhookMessage(this.client.rest, this.client.options.clientId, this.token, "@original");
-			this.response.recordReplyDelete();
-			return result;
-		});
-	}
-	async fetchReply() {
-		return await this.enqueueResponse(() => 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) {
-		return await this.enqueueResponse(() => this.performFollowUp(payload));
-	}
-	async performFollowUp(payload) {
-		const body = serializePayload(payload);
-		const result = await createWebhookMessage(this.client.rest, this.client.options.clientId, this.token, { body }, needsComponentsV2Query(body) ? { with_components: true } : void 0);
-		this.sentFollowUp = true;
-		return result;
-	}
-};
-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 (command.commandKind === "leaf") await command.autocomplete(autocompleteInteraction);
-		return;
-	}
-	try {
-		await dispatchAcknowledgeableInteraction(client, rawData, interaction);
-	} catch (error) {
-		await reportInteractionFailure(interaction);
-		throw error;
-	}
-}
-async function dispatchAcknowledgeableInteraction(client, rawData, interaction) {
-	if (rawData.type === InteractionType.ApplicationCommand) {
-		const command = client.commands.find((entry) => entry.name === readInteractionName(rawData));
-		if (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);
-	}
-}
-/**
-* Fixed text. The thrown error is deliberately not echoed here: an interaction
-* response is visible to the whole channel, and handler exceptions routinely
-* carry absolute paths, config keys, and provider responses. The rethrow keeps
-* the detail in the Gateway log where operators already look for it.
-*/
-const INTERACTION_FAILURE_NOTICE = "Command failed. Check the Gateway logs for details.";
-/**
-* Best-effort user-visible notice for a failed interaction. Never throws: a
-* reporting failure must not mask the original error.
-*
-* Deliberately narrow. It reports only for `deferred`, where a spinner is known
-* to exist and the original response is a placeholder this dispatch created:
-*
-* - `deferred`        the deferring callback succeeded (state advances only
-*                     after a REST success), so editing the original response
-*                     resolves a spinner that would otherwise hang forever.
-* - `deferred-update` a component acknowledgement. Discord leaves no spinner,
-*                     and the original response is the message the component is
-*                     attached to, so editing it would overwrite content the
-*                     user is still reading.
-* - `unacknowledged`  nothing is known to have reached Discord. A second
-*                     initial callback risks "already acknowledged" if the
-*                     first one landed after all, and Discord already shows its
-*                     own "did not respond" notice.
-* - `replied`         the user has seen a message, and nextReplyAction() would
-*                     turn this into a contradictory follow-up beside it.
-*/
-async function reportInteractionFailure(interaction) {
-	if (interaction.responseState !== "deferred") return;
-	if (interaction.hasSentFollowUp) return;
-	try {
-		await interaction.editDeferredPlaceholderIfUnanswered({
-			content: INTERACTION_FAILURE_NOTICE,
-			allowed_mentions: { parse: [] }
-		});
-	} catch {}
-}
-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;
-const DISCORD_ERROR_BODY_MAX_DEPTH = 64;
-const DISCORD_ERROR_BODY_MAX_NODES = 1e4;
-const DISCORD_ERROR_BODY_MAX_DEPTH_MARKER = "[Discord error body redacted: maximum depth exceeded]";
-const DISCORD_ERROR_BODY_MAX_NODES_MARKER = "[Discord error body redacted: node limit exceeded]";
-const DISCORD_ERROR_BODY_PRIORITY_KEYS = /* @__PURE__ */ new Set([
-	"message",
-	"code",
-	"retry_after",
-	"global"
-]);
-const DISCORD_RATE_LIMIT_SCOPES = /* @__PURE__ */ new Set([
-	"user",
-	"global",
-	"shared"
-]);
-function isSensitiveDiscordErrorKey(key) {
-	return redactSensitiveFieldValue(key, "") !== "";
-}
-function reserveRedactedKey(key, usedKeys, collisionCounts) {
-	let count = (collisionCounts.get(key) ?? 0) + 1;
-	let candidate = count === 1 ? key : `${key} [${count}]`;
-	while (usedKeys.has(candidate)) {
-		count += 1;
-		candidate = `${key} [${count}]`;
-	}
-	collisionCounts.set(key, count);
-	usedKeys.add(candidate);
-	return candidate;
-}
-function redactDiscordErrorBody(body, fieldKey = "", sensitiveAncestorKey, state = {
-	seen: /* @__PURE__ */ new WeakSet(),
-	remainingNodes: DISCORD_ERROR_BODY_MAX_NODES
-}, depth = 0) {
-	if (state.remainingNodes <= 0) return DISCORD_ERROR_BODY_MAX_NODES_MARKER;
-	state.remainingNodes -= 1;
-	if (typeof body === "string") return redactSensitiveFieldValue(sensitiveAncestorKey ?? fieldKey, body);
-	if (sensitiveAncestorKey && (typeof body === "number" || typeof body === "boolean" || typeof body === "bigint")) return redactSensitiveFieldValue(sensitiveAncestorKey, String(body));
-	if (!body || typeof body !== "object") return body;
-	if (depth >= DISCORD_ERROR_BODY_MAX_DEPTH) return DISCORD_ERROR_BODY_MAX_DEPTH_MARKER;
-	if (state.seen.has(body)) return "[Circular]";
-	state.seen.add(body);
-	let redacted;
-	if (Array.isArray(body)) {
-		const items = [];
-		for (const entry of body) {
-			if (state.remainingNodes <= 0) {
-				items.push(DISCORD_ERROR_BODY_MAX_NODES_MARKER);
-				break;
-			}
-			items.push(redactDiscordErrorBody(entry, fieldKey, sensitiveAncestorKey, state, depth + 1));
-		}
-		redacted = items;
-	} else {
-		const usedKeys = /* @__PURE__ */ new Set();
-		const collisionCounts = /* @__PURE__ */ new Map();
-		const entries = [];
-		const appendEntry = (nestedKey) => {
-			if (state.remainingNodes <= 0) return false;
-			const outputKey = reserveRedactedKey(redactSensitiveFieldValue(sensitiveAncestorKey ?? "", nestedKey), usedKeys, collisionCounts);
-			const nestedSensitiveKey = isSensitiveDiscordErrorKey(nestedKey) ? nestedKey : sensitiveAncestorKey;
-			entries.push([outputKey, redactDiscordErrorBody(body[nestedKey], nestedKey, nestedSensitiveKey, state, depth + 1)]);
-			return true;
-		};
-		let truncated = false;
-		for (const priorityKey of DISCORD_ERROR_BODY_PRIORITY_KEYS) if (Object.hasOwn(body, priorityKey) && !appendEntry(priorityKey)) {
-			truncated = true;
-			break;
-		}
-		if (!truncated) for (const nestedKey in body) {
-			if (!Object.hasOwn(body, nestedKey) || DISCORD_ERROR_BODY_PRIORITY_KEYS.has(nestedKey)) continue;
-			if (!appendEntry(nestedKey)) {
-				truncated = true;
-				break;
-			}
-		}
-		if (truncated) {
-			const markerKey = reserveRedactedKey(DISCORD_ERROR_BODY_MAX_NODES_MARKER, usedKeys, collisionCounts);
-			entries.push([markerKey, DISCORD_ERROR_BODY_MAX_NODES_MARKER]);
-		}
-		redacted = Object.fromEntries(entries);
-	}
-	state.seen.delete(body);
-	return redacted;
-}
-function readDiscordCode(body) {
-	const value = body && typeof body === "object" && "code" in body ? body.code : void 0;
-	return parseStrictNonNegativeInteger(value);
-}
-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) {
-	const bodyValue = body && typeof body === "object" && "retry_after" in body ? body.retry_after : void 0;
-	return parseDiscordRetryAfterBodySeconds(bodyValue) ?? parseRetryAfterHeaderSeconds(response.headers.get("Retry-After")) ?? fallbackSeconds;
-}
-function readDiscordRateLimitBucket(response) {
-	const value = response.headers.get("X-RateLimit-Bucket")?.trim();
-	return value ? redactIdentifier(value, { len: 32 }) : null;
-}
-function readDiscordRateLimitScope(response) {
-	const value = response.headers.get("X-RateLimit-Scope");
-	return value && DISCORD_RATE_LIMIT_SCOPES.has(value) ? value : null;
-}
-var DiscordError = class extends Error {
-	constructor(response, body) {
-		const fallbackMessage = `Discord API request failed (${response.status})`;
-		const redactedMessage = redactSensitiveFieldValue("message", readDiscordMessage(body, fallbackMessage));
-		const redactedBody = redactDiscordErrorBody(body);
-		super(redactedMessage);
-		this.name = "DiscordError";
-		this.status = response.status;
-		this.statusCode = response.status;
-		this.rawBody = redactedBody;
-		this.rawError = redactedBody;
-		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" : readDiscordRateLimitScope(response);
-		this.bucket = readDiscordRateLimitBucket(response);
-	}
-};
-//#endregion
-//#region extensions/discord/src/internal/rest-routes.ts
-const RATE_LIMIT_HEADER_NUMBER_RE = /^\d+(?:\.\d+)?$/;
-const DISCORD_ROUTE_IDENTIFIER_HASH_LENGTH = 32;
-function redactWebhookTokenInPath(path) {
-	const hasLeadingSlash = path.startsWith("/");
-	const segments = path.replace(/^\/+/, "").split("/");
-	if (segments[0] !== "webhooks" || !segments[1] || !segments[2]) return path;
-	segments[2] = redactIdentifier(segments[2], { len: DISCORD_ROUTE_IDENTIFIER_HASH_LENGTH });
-	return `${hasLeadingSlash ? "/" : ""}${segments.join("/")}`;
-}
-function createRouteKey(method, path) {
-	const pathname = path.split("?")[0] ?? path;
-	return `${method.toUpperCase()} ${redactWebhookTokenInPath(pathname)}`;
-}
-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}/${redactIdentifier(token, { len: DISCORD_ROUTE_IDENTIFIER_HASH_LENGTH })}` : `${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 = 6e5;
-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 = readDiscordRateLimitBucket(response);
-		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 = readDiscordRateLimitBucket(response);
-		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 = 8388608;
-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: resolveIntegerOption(this.options.scheduler?.maxConcurrency, DEFAULT_MAX_CONCURRENT_WORKERS, { min: 1 }),
-			maxQueueSize: this.options.maxQueueSize,
-			maxRateLimitRetries: resolveIntegerOption(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 normalizeRequestClientOptions(options) {
-	const merged = {
-		...defaultOptions,
-		...options
-	};
-	return {
-		...merged,
-		apiVersion: resolveIntegerOption(merged.apiVersion, defaultOptions.apiVersion, { min: 1 }),
-		timeout: clampTimerTimeoutMs(merged.timeout, 1) ?? resolveTimerTimeoutMs(defaultOptions.timeout, 1),
-		maxQueueSize: resolveIntegerOption(merged.maxQueueSize, defaultOptions.maxQueueSize, { min: 1 })
-	};
-}
-function normalizeSchedulerLanes(maxQueueSize, lanes) {
-	const fallbackMaxQueueSize = resolveIntegerOption(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 ? resolveIntegerOption(options.staleAfterMs, defaults.staleAfterMs ?? 0, { min: 0 }) : defaults.staleAfterMs;
-	return {
-		maxQueueSize: options?.maxQueueSize !== void 0 ? resolveIntegerOption(options.maxQueueSize, maxQueueSize, { min: 1 }) : maxQueueSize,
-		...staleAfterMs !== void 0 ? { staleAfterMs } : {},
-		weight: options?.weight !== void 0 ? resolveIntegerOption(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 fetchGuildEmojis(guildId, fetcher) {
-		return await this.entityCache.fetchGuildEmojis(guildId, fetcher);
-	}
-	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;
-	}
-};
-var ThreadDeleteListener = class extends BaseListener {
-	constructor(..._args12) {
-		super(..._args12);
-		this.type = GatewayDispatchEvents.ThreadDelete;
-	}
-};
-//#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,
-	ThreadDeleteListener: () => ThreadDeleteListener,
-	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,
-	hasDiscordV2Components: () => hasDiscordV2Components,
-	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) {
-	const target = parseDiscordTarget(raw, { defaultKind: "channel" });
-	return requireTargetKind({
-		platform: "Discord",
-		target,
-		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;
-	const normalizedAllowFrom = (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry));
-	return resolveAllowlistMatchByCandidates({
-		allowList: normalizedAllowFrom,
-		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/send.receipt.ts
-function toDiscordOutboundDeliveryResult(result) {
-	const { channelId, ...delivery } = result;
-	return {
-		...delivery,
-		target: {
-			kind: "channel",
-			id: channelId
-		}
-	};
-}
-function createDiscordSendReceiptFromResults(params) {
-	const receipt = createMessageReceiptFromOutboundResults({
-		results: attachChannelToResults("discord", params.results),
-		threadId: params.threadId
-	});
-	return {
-		...receipt,
-		parts: receipt.parts.map(({ platformMessageId, kind, threadId, replyToId, raw }, index) => ({
-			platformMessageId,
-			kind,
-			index,
-			threadId,
-			replyToId,
-			raw
-		}))
-	};
-}
-function createDiscordSendReceipt(params) {
-	const results = params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId, index) => {
-		const result = {
-			channel: "discord",
-			messageId
-		};
-		if (params.channelId) result.channelId = params.channelId;
-		if (params.reply?.scope === "first" && index === 0) {
-			const rawResult = {
-				channel: "discord",
-				messageId
-			};
-			if (params.channelId) rawResult.channelId = params.channelId;
-			result.receipt = createMessageReceiptFromOutboundResults({
-				results: [rawResult],
-				kind: params.kind,
-				threadId: params.threadId,
-				replyToId: params.reply.messageId
-			});
-		}
-		return result;
-	});
-	return createMessageReceiptFromOutboundResults({
-		results,
-		kind: params.kind,
-		threadId: params.threadId,
-		replyToId: params.reply?.scope === "all" ? params.reply.messageId : void 0
-	});
-}
-function createDiscordSendResult(params) {
-	const messageId = params.result.id || "unknown";
-	const channelId = params.result.channel_id ?? params.fallbackChannelId;
-	const receiptParams = {
-		platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
-		channelId,
-		kind: params.kind
-	};
-	if (params.threadId != null) receiptParams.threadId = String(params.threadId);
-	if (params.reply) receiptParams.reply = params.reply;
-	return {
-		messageId,
-		channelId,
-		receipt: createDiscordSendReceipt(receiptParams)
-	};
-}
-//#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 segmentLimit = Math.max(1, charLimit - Math.max(prefixLen, reopenBudget));
-		const segments = chunkTextForOutbound(originalLine, segmentLimit, { 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
-//#region extensions/discord/src/retry.ts
-const DISCORD_RETRY_DEFAULTS = {
-	attempts: 3,
-	minDelayMs: 500,
-	maxDelayMs: 3e4,
-	jitter: .1
-};
-const DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS = 2;
-const DISCORD_TRANSIENT_MESSAGE_RE = /\b(?:bad gateway|fetch failed|network error|networkerror|service unavailable|socket hang up|temporarily unavailable|timed out|timeout)\b|connection (?:closed|reset|refused)/i;
-const ambiguousDiscordMessageCreates = /* @__PURE__ */ new WeakSet();
-function readDiscordErrorStatus(err) {
-	if (!err || typeof err !== "object") return;
-	const raw = "status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0;
-	return parseStrictNonNegativeInteger(raw);
-}
-function classifyDiscordDeliveryFailure(error) {
-	const candidates = collectErrorGraphCandidates(error, (current) => [current.cause, current.error]);
-	for (const candidate of candidates) {
-		const status = readDiscordErrorStatus(candidate);
-		if (status !== void 0) {
-			if (status === 408 || status >= 500) return "ambiguous";
-			if (status >= 400) return "rejected";
-		}
-	}
-	if (candidates.some((candidate) => readErrorName(candidate) === "AbortError" || classifyTransientNetworkErrorCode(extractErrorCode(candidate)) === "ambiguous")) return "ambiguous";
-	if (candidates.some((candidate) => classifyTransientNetworkErrorCode(extractErrorCode(candidate)) === "pre-connect")) return "pre-connect";
-	return candidates.some((candidate) => (candidate instanceof Error || candidate !== null && typeof candidate === "object") && DISCORD_TRANSIENT_MESSAGE_RE.test(formatErrorMessage(candidate))) ? "ambiguous" : "unknown";
-}
-function recordDiscordMessageCreateAmbiguity(error) {
-	if (error !== null && typeof error === "object") ambiguousDiscordMessageCreates.add(error);
-}
-function hasDiscordMessageCreateAmbiguity(error) {
-	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => candidate !== null && typeof candidate === "object" && ambiguousDiscordMessageCreates.has(candidate));
-}
-function hasDiscordRateLimitRejection(error) {
-	return error instanceof RateLimitError || collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) === 429);
-}
-function isRetryableDiscordTransientError(error) {
-	const failure = classifyDiscordDeliveryFailure(error);
-	return failure === "ambiguous" || failure === "pre-connect" || hasDiscordRateLimitRejection(error);
-}
-function isRetryableDiscordPreConnectError(error) {
-	const failure = classifyDiscordDeliveryFailure(error);
-	return failure === "pre-connect" || failure === "rejected" && hasDiscordRateLimitRejection(error);
-}
-function resolveDiscordRetryPredicate(safety) {
-	return safety === "non-idempotent-create" ? isRetryableDiscordPreConnectError : isRetryableDiscordTransientError;
-}
-function isRetryableDiscordGatewayTransportError(err) {
-	if (!isRetryableDiscordTransientError(err) || err instanceof RateLimitError) return false;
-	return !collectErrorGraphCandidates(err, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) !== void 0);
-}
-function createDiscordRetryRunner(params) {
-	const retryConfig = resolveRetryConfig(DISCORD_RETRY_DEFAULTS, params.retry);
-	const attempts = retryConfig.attempts > 1 ? retryConfig.attempts + DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS : retryConfig.attempts;
-	return (fn, label, options) => {
-		const isRetryable = resolveDiscordRetryPredicate(options?.safety ?? "idempotent");
-		let observedGatewayDisconnect = false;
-		const runRequest = async () => {
-			if (params.signal?.aborted) throw params.signal.reason instanceof Error ? params.signal.reason : /* @__PURE__ */ new Error("Discord request aborted");
-			observedGatewayDisconnect ||= params.isGatewayDisconnected?.() === true;
-			try {
-				return await fn();
-			} catch (err) {
-				observedGatewayDisconnect ||= params.isGatewayDisconnected?.() === true;
-				throw err;
-			}
-		};
-		const shouldRetry = (err, attempt) => isRetryable(err) && (attempt < retryConfig.attempts || observedGatewayDisconnect && isRetryableDiscordGatewayTransportError(err));
-		const retryAfterMs = (err) => err instanceof RateLimitError ? err.retryAfter * 1e3 : void 0;
-		const signal = params.signal;
-		if (signal) return retryAsync(runRequest, {
-			...retryConfig,
-			attempts,
-			label,
-			shouldRetry,
-			retryAfterMs,
-			sleep: async (delayMs) => {
-				try {
-					await sleepWithAbort(delayMs, signal);
-				} catch (error) {
-					throw signal.aborted && signal.reason instanceof Error ? signal.reason : error;
-				}
-			}
-		});
-		return createChannelApiRetryRunner({
-			retry: {
-				...retryConfig,
-				attempts
-			},
-			shouldRetry,
-			strictShouldRetry: true,
-			retryAfterMs,
-			verbose: params.verbose
-		})(runRequest, label);
-	};
-}
-//#endregion
-export { TextInput as $, listGuildRoles as $t, ThreadUpdateListener as A, getChannel as At, readRetryAfter as B, addGuildMemberRole as Bt, MessageCreateListener as C, listMessageReactionUsers as Ct, ReadyListener as D, deleteChannelMessage as Dt, PresenceUpdateListener as E, deleteChannel as Et, DiscordError as F, listChannelPins as Ft, User as G, createGuildSticker as Gt, CommandWithSubcommands as H, createGuildChannel as Ht, RateLimitError as I, pinChannelMessage as It, Embed as J, getGuildMember as Jt, hasDiscordV2Components as K, deleteChannelPermission as Kt, isUnknownDiscordVoiceStateError as L, searchGuildMessages as Lt, Client as M, getThreadMember as Mt, Plugin as N, listChannelArchivedThreads as Nt, ResumedListener as O, editChannel as Ot, RequestClient as P, listChannelMessages as Pt, RadioGroup as Q, listGuildEmojis as Qt, readDiscordCode as R, sendChannelTyping as Rt, InteractionCreateListener as S, deleteOwnMessageReaction as St, MessageReactionRemoveListener as T, createThread as Tt, Guild as U, createGuildEmoji as Ut, Command as V, createGuildBan as Vt, Message as W, createGuildScheduledEvent as Wt, Label as X, listGuildActiveThreads as Xt, CheckboxGroup as Y, getGuildVoiceState as Yt, Modal as Z, listGuildChannels as Zt, parseDiscordTarget as _, stripUndefinedFields as _t, chunkDiscordTextWithMode as a, timeoutGuildMember as an, MediaGallery as at, GuildCreateListener as b, getCurrentUser as bt, createDiscordSendResult as c, Row as ct, resolveDiscordReplyMessageId as d, StringSelectMenu as dt, listGuildScheduledEvents as en, Button as et, resolveDiscordReplyReference as f, TextDisplay as ft, normalizeDiscordOutboundTarget as g, parseCustomId as gt, normalizeDiscordMessagingTarget as h, BaseMessageInteractiveComponent as ht, recordDiscordMessageCreateAmbiguity as i, removeGuildMemberRole as in, LinkButton as it, VoiceStateUpdateListener as j, getChannelMessage as jt, ThreadDeleteListener as k, editChannelMessage as kt, toDiscordOutboundDeliveryResult as l, Section as lt, looksLikeDiscordTargetId as m, UserSelectMenu as mt, createDiscordRetryRunner as n, putChannelPermission as nn, Container as nt, createDiscordSendReceipt as o, __exportAll as on, MentionableSelectMenu as ot, allowFromContainsDiscordUserId as p, Thumbnail as pt, serializePayload as q, getGuild as qt, hasDiscordMessageCreateAmbiguity as r, removeGuildMember as rn, File as rt, createDiscordSendReceiptFromResults as s, RoleSelectMenu as st, classifyDiscordDeliveryFailure as t, moveGuildChannels as tn, ChannelSelectMenu as tt, createReusableDiscordReplyReference as u, Separator as ut, resolveDiscordChannelId as v, createChannelWebhook as vt, MessageReactionAddListener as w, createChannelMessage as wt, GuildDeleteListener as x, createOwnMessageReaction as xt, discord_exports as y, createUserDmChannel as yt, readDiscordMessage as z, unpinChannelMessage as zt };