@ninenity/neutrun 1.0.0

package/dist/Shared/Definer.js

@@ -0,0 +1,711 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartTasksScheduler = exports.RegisterSlashCommands = exports.Setup = exports.StopTasksForClient = exports.StopTaskTimer = exports.StartTaskTimer = exports.ExecuteTask = void 0;
+// --------------------------------------------------------------------------------
+const discord_js_1 = require("discord.js");
+const InputInteraction_Type_1 = require("../Types/InputInteraction.Type");
+const Permission_Type_1 = require("../Types/Permission.Type");
+const InteractionContext_1 = require("./InteractionContext");
+const InteractionManager_1 = __importDefault(require("./InteractionManager"));
+const ConsoleLog_1 = require("./ConsoleLog");
+const Color_1 = __importDefault(require("../Logger/Color"));
+const CooldownManager_1 = __importDefault(require("./CooldownManager"));
+const QueueManager_1 = __importDefault(require("./QueueManager"));
+const I18n_1 = __importDefault(require("../I18n"));
+const InputInteraction_Type_2 = require("../Types/InputInteraction.Type");
+const TelemetryService_1 = __importDefault(require("./TelemetryService"));
+const ComponentRuntime = __importStar(require("./ComponentRuntime"));
+const RoleLoader_1 = __importDefault(require("./RoleLoader"));
+const ChannelLoader_1 = __importDefault(require("./ChannelLoader"));
+const WebSocket = __importStar(require("./WebSocket"));
+// --------------------------------------------------------------------------------
+const ProcessCooldown = async (interaction, commandId, definer) => {
+    const userId = interaction.user.id;
+    const guildId = interaction.guildId || interaction.guild?.id || undefined;
+    const globalCooldown = CooldownManager_1.default.check(userId, 'global');
+    if (globalCooldown) {
+        TelemetryService_1.default.registerCounter('cooldownGlobalRejections');
+        const Reply = {
+            content: `Você está em cooldown global. Aguarde ${globalCooldown.formatted}.`,
+            allowedMentions: { parse: [] },
+            flags: 64
+        };
+        if (interaction.reply)
+            await interaction.reply(Reply).catch(() => { });
+        return false;
+    }
+    const cmdCooldown = CooldownManager_1.default.check(userId, commandId, guildId);
+    if (cmdCooldown) {
+        TelemetryService_1.default.registerCounter('cooldownRejections');
+        const Reply = {
+            content: `Aguarde ${cmdCooldown.formatted} para usar este comando novamente.`,
+            allowedMentions: { parse: [] },
+            flags: 64
+        };
+        if (interaction.reply)
+            await interaction.reply(Reply).catch(() => { });
+        return false;
+    }
+    if (definer.cooldown) {
+        let duration = null;
+        if (Array.isArray(definer.cooldown)) {
+            const userRoles = interaction.member?.roles?.cache?.map((R) => R.id) || [];
+            duration = CooldownManager_1.default.resolveLowestDuration(userRoles, definer.cooldown);
+        }
+        else {
+            duration = definer.cooldown;
+        }
+        if (duration) {
+            CooldownManager_1.default.set(userId, commandId, duration, guildId);
+        }
+    }
+    return true;
+};
+const ProcessQueue = async (interaction, commandId, definer, execute) => {
+    if (definer.queue) {
+        TelemetryService_1.default.registerCounter('queuedCommands');
+        // Prefixo "cmd:" isola as filas automáticas dos definers das filas
+        // manuais de client.queue(<name>): sem ele, `queue: 'guild'` colidiria
+        // com uma fila manual de mesmo nome no mesmo escopo.
+        let key = `cmd:${commandId}`;
+        if (definer.queue === 'user') {
+            // User queues are isolated by guild. Use global-user when an old bot
+            // explicitly needs one user queue shared across every guild.
+            key += `:user:${interaction.guildId || 'dm'}:${interaction.user.id}`;
+        }
+        else if (definer.queue === 'channel')
+            key += `:channel:${interaction.channelId}`;
+        else if (definer.queue === 'guild')
+            key += `:guild:${interaction.guildId || 'dm'}`;
+        else if (definer.queue === 'global-user')
+            key += `:user:${interaction.user.id}`;
+        else
+            key += `:${definer.queue}`;
+        await QueueManager_1.default.enqueue(key, execute);
+    }
+    else {
+        await execute();
+    }
+};
+const SafeAsyncListener = (label, handler) => (...args) => {
+    const guildId = args
+        .map((arg) => arg?.guildId || arg?.guild?.id || arg?.member?.guild?.id || undefined)
+        .find(Boolean);
+    void Promise.resolve()
+        .then(() => guildId
+        ? (0, InteractionContext_1.RunWithGuild)(String(guildId), () => handler(...args))
+        : handler(...args))
+        .catch((error) => {
+        (0, ConsoleLog_1.logError)(`Erro no listener ${label}: ${error?.message || error}`, 'Events');
+    });
+};
+const RegisterSlashCommands = async (client) => {
+    const Token = process.env.BOT_TOKEN;
+    const ApplicationId = client.application?.id || client.user?.id;
+    if (Token && ApplicationId) {
+        const Rest = new discord_js_1.REST({ version: '10' }).setToken(Token);
+        const GlobalCommands = client.slashCommands
+            .filter((d) => d.global === true)
+            .map((d) => d.data.toJSON());
+        const GuildCommands = client.slashCommands
+            .filter((d) => d.global !== true)
+            .map((d) => d.data.toJSON());
+        const GlobalContextMenuCommands = client.contextMenuCommands
+            .filter((d) => d.global === true)
+            .map((d) => d.data.toJSON());
+        const GuildContextMenuCommands = client.contextMenuCommands
+            .filter((d) => d.global !== true)
+            .map((d) => d.data.toJSON());
+        try {
+            await Rest.put(discord_js_1.Routes.applicationCommands(ApplicationId), {
+                body: [...GlobalCommands, ...GlobalContextMenuCommands]
+            });
+            const Total = GlobalCommands.length + GlobalContextMenuCommands.length;
+            if (Total > 0) {
+                (0, ConsoleLog_1.logSuccess)(`${(0, Color_1.default)(String(Total), 'cyan', 'bold')} comandos globais registrados`);
+            }
+        }
+        catch (error) {
+            (0, ConsoleLog_1.logError)('Erro ao registrar comandos globais');
+        }
+        const Guilds = client.guilds.cache;
+        for (const [GuildId, Guild] of Guilds) {
+            try {
+                await Rest.put(discord_js_1.Routes.applicationGuildCommands(ApplicationId, GuildId), {
+                    body: [...GuildCommands, ...GuildContextMenuCommands]
+                });
+                const Total = GuildCommands.length + GuildContextMenuCommands.length;
+                if (Total > 0) {
+                    (0, ConsoleLog_1.logSuccess)(`${(0, Color_1.default)(String(Total), 'cyan', 'bold')} comandos registrados`, 'Loader');
+                }
+            }
+            catch (error) {
+                (0, ConsoleLog_1.logError)(`Erro ao registrar comandos em ${Guild.name}`);
+            }
+        }
+    }
+};
+exports.RegisterSlashCommands = RegisterSlashCommands;
+const ParseTimeoutMs = (timeout) => {
+    if (typeof timeout === 'number')
+        return timeout;
+    const str = String(timeout).trim().toLowerCase();
+    const match = str.match(/^(\d+)\s*(s|sec|seconds|m|min|minutes|h|hour|hours|d|day|days)?$/);
+    if (!match) {
+        const parsed = Number(str);
+        return isNaN(parsed) ? 60000 : parsed;
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 's':
+        case 'sec':
+        case 'seconds':
+            return value * 1000;
+        case 'm':
+        case 'min':
+        case 'minutes':
+            return value * 60 * 1000;
+        case 'h':
+        case 'hour':
+        case 'hours':
+            return value * 60 * 60 * 1000;
+        case 'd':
+        case 'day':
+        case 'days':
+            return value * 24 * 60 * 60 * 1000;
+        default:
+            return value;
+    }
+};
+const activeTaskTimers = new Map();
+const runningTasks = new Set();
+const taskKey = (client, taskId) => `${client.runtimeKey || 'default'}:${taskId}`;
+const ExecuteTask = async (client, task) => {
+    const startedAt = Date.now();
+    try {
+        if (task.scope !== 'guild') {
+            await task.execute(client);
+        }
+        else {
+            for (const guildId of client.guilds.cache.keys()) {
+                await (0, InteractionContext_1.RunWithGuild)(guildId, () => task.execute(client, guildId));
+            }
+        }
+        TelemetryService_1.default.registerAction('job', task.id, true, {}, undefined, Date.now() - startedAt);
+    }
+    catch (error) {
+        TelemetryService_1.default.registerAction('job', task.id, false, {}, String(error), Date.now() - startedAt);
+        throw error;
+    }
+};
+exports.ExecuteTask = ExecuteTask;
+const StartTaskTimer = (client, taskId) => {
+    const task = client.tasks.get(taskId);
+    if (!task)
+        throw new Error(`Task "${taskId}" não está registrada.`);
+    const scopedTaskId = taskKey(client, taskId);
+    if (activeTaskTimers.has(scopedTaskId)) {
+        clearInterval(activeTaskTimers.get(scopedTaskId));
+        activeTaskTimers.delete(scopedTaskId);
+    }
+    const timeoutMs = Math.max(1_000, ParseTimeoutMs(task.timeout));
+    const timer = setInterval(async () => {
+        if (runningTasks.has(scopedTaskId))
+            return;
+        runningTasks.add(scopedTaskId);
+        try {
+            await (0, exports.ExecuteTask)(client, task);
+        }
+        catch (error) {
+            (0, ConsoleLog_1.logError)(`Erro ao executar task ${(0, Color_1.default)(taskId, 'cyan', 'bold')}: ${error}`);
+        }
+        finally {
+            runningTasks.delete(scopedTaskId);
+        }
+    }, timeoutMs);
+    timer.unref?.();
+    activeTaskTimers.set(scopedTaskId, timer);
+    (0, ConsoleLog_1.logInfo)(`Task ativada/iniciada: ${(0, Color_1.default)(taskId, 'cyan', 'bold')} (${timeoutMs}ms)`);
+};
+exports.StartTaskTimer = StartTaskTimer;
+const StopTaskTimer = (taskId, runtimeKey) => {
+    const scopedTaskId = runtimeKey
+        ? `${runtimeKey}:${taskId}`
+        : Array.from(activeTaskTimers.keys()).find((key) => key.endsWith(`:${taskId}`)) || taskId;
+    const timer = activeTaskTimers.get(scopedTaskId);
+    if (timer) {
+        clearInterval(timer);
+        activeTaskTimers.delete(scopedTaskId);
+        (0, ConsoleLog_1.logInfo)(`Task pausada/parada: ${(0, Color_1.default)(taskId, 'cyan', 'bold')}`);
+    }
+};
+exports.StopTaskTimer = StopTaskTimer;
+const StopTasksForClient = (runtimeKey) => {
+    const prefix = `${runtimeKey}:`;
+    for (const [key, timer] of activeTaskTimers.entries()) {
+        if (!key.startsWith(prefix))
+            continue;
+        clearInterval(timer);
+        activeTaskTimers.delete(key);
+    }
+    for (const key of Array.from(runningTasks)) {
+        if (key.startsWith(prefix))
+            runningTasks.delete(key);
+    }
+};
+exports.StopTasksForClient = StopTasksForClient;
+const StartTasksScheduler = (client) => {
+    if (!client.tasks || client.tasks.size === 0)
+        return;
+    client.tasks.forEach((task, taskId) => {
+        if (task.runOnStart) {
+            void Promise.resolve()
+                .then(() => (0, exports.ExecuteTask)(client, task))
+                .catch((err) => (0, ConsoleLog_1.logError)(`Erro na execução inicial da task ${taskId}: ${err}`));
+        }
+        if (task.started !== false) {
+            (0, exports.StartTaskTimer)(client, taskId);
+        }
+        else {
+            (0, ConsoleLog_1.logInfo)(`Task registrada (aguardando acionamento manual via runTask/startTask): ${(0, Color_1.default)(taskId, 'cyan', 'bold')}`);
+        }
+    });
+};
+exports.StartTasksScheduler = StartTasksScheduler;
+const Setup = async (client) => {
+    // Graceful Shutdown
+    const shutdownHandler = async () => {
+        (0, ConsoleLog_1.logInfo)('Encerrando serviços e finalizando aplicação...', 'Shutdown');
+        (0, exports.StopTasksForClient)(client.runtimeKey || 'default');
+        await client.destroy();
+        process.exit(0);
+    };
+    process.once('SIGINT', shutdownHandler);
+    process.once('SIGTERM', shutdownHandler);
+    client._on(discord_js_1.Events.GuildCreate, SafeAsyncListener('GuildCreate', async (guild) => {
+        TelemetryService_1.default.registerEvent('discord:guildCreate');
+        TelemetryService_1.default.registerCounter('guildsJoined');
+        (0, ConsoleLog_1.logInfo)(`Adicionado em uma nova guild: ${guild.name}. Sincronizando comandos...`);
+        await (0, RoleLoader_1.default)(client);
+        await (0, ChannelLoader_1.default)(client);
+        await WebSocket.SendResourceSnapshot();
+        await RegisterSlashCommands(client);
+    }));
+    client._on(discord_js_1.Events.GuildDelete, SafeAsyncListener('GuildDelete', async () => {
+        TelemetryService_1.default.registerEvent('discord:guildDelete');
+        TelemetryService_1.default.registerCounter('guildsLeft');
+        await (0, RoleLoader_1.default)(client);
+        await (0, ChannelLoader_1.default)(client);
+        await WebSocket.SendResourceSnapshot();
+    }));
+    client.registeredEvents.forEach((definers, eventName) => {
+        definers.forEach((definer) => {
+            client._on(eventName, SafeAsyncListener(`event:${eventName}`, async (...args) => {
+                const startedAt = Date.now();
+                try {
+                    await definer.execute(...args);
+                    TelemetryService_1.default.registerEvent(`discord:${eventName}`, {
+                        durationMs: Date.now() - startedAt
+                    });
+                }
+                catch (error) {
+                    TelemetryService_1.default.registerEvent(`discord:${eventName}`, {
+                        error: true,
+                        durationMs: Date.now() - startedAt
+                    });
+                    throw error;
+                }
+            }));
+        });
+    });
+    client.registeredOnceEvents.forEach((definers, eventName) => {
+        definers.forEach((definer) => {
+            client._once(eventName, SafeAsyncListener(`once:${eventName}`, async (...args) => {
+                const startedAt = Date.now();
+                try {
+                    await definer.execute(...args);
+                    TelemetryService_1.default.registerEvent(`discord:once:${eventName}`, {
+                        durationMs: Date.now() - startedAt
+                    });
+                }
+                catch (error) {
+                    TelemetryService_1.default.registerEvent(`discord:once:${eventName}`, {
+                        error: true,
+                        durationMs: Date.now() - startedAt
+                    });
+                    throw error;
+                }
+            }));
+        });
+    });
+    client._on(discord_js_1.Events.InteractionCreate, SafeAsyncListener('InteractionCreate', async (interaction) => {
+        TelemetryService_1.default.registerCounter('interactionsSeen');
+        if (interaction.isAutocomplete()) {
+            const Command = client.slashCommands.get(interaction.commandName);
+            if (!Command?.autocomplete) {
+                // Autocomplete sem handler não pode ficar sem resposta: o Discord
+                // exibe "carregando" eternamente para o usuário.
+                await interaction.respond([]).catch(() => { });
+                return;
+            }
+            TelemetryService_1.default.registerCounter('autocompleteRequests');
+            const autocompleteStartedAt = Date.now();
+            try {
+                await Command.autocomplete(interaction);
+                TelemetryService_1.default.registerAction('autocomplete', interaction.commandName, true, { user: interaction.user.id, guild: interaction.guildId }, undefined, Date.now() - autocompleteStartedAt);
+            }
+            catch (error) {
+                (0, ConsoleLog_1.logError)(`Erro no autocomplete do comando ${(0, Color_1.default)(interaction.commandName, 'cyan', 'bold')}: ${error}`);
+                TelemetryService_1.default.registerAction('autocomplete', interaction.commandName, false, { user: interaction.user.id, guild: interaction.guildId }, String(error), Date.now() - autocompleteStartedAt);
+            }
+            return;
+        }
+        if (interaction.isChatInputCommand()) {
+            const Command = client.slashCommands.get(interaction.commandName);
+            if (!Command) {
+                // Comando removido/renomeado após o Discord cachear a entrada:
+                // responder, não deixar a interação morrer com "falhou".
+                TelemetryService_1.default.registerCounter('unknownCommandInteractions');
+                await interaction
+                    .reply({
+                    content: 'Este comando não está mais disponível. Tente novamente em instantes.',
+                    flags: 64
+                })
+                    .catch(() => { });
+                return;
+            }
+            const CreateRequire = (options) => {
+                const Member = interaction.member;
+                const ChannelId = interaction.channelId;
+                if (options.roles && Member) {
+                    const RoleIds = Member.roles?.cache?.map((R) => R.id) || [];
+                    if ('any' in options.roles) {
+                        const HasAny = options.roles.any.some((Id) => RoleIds.includes(Id));
+                        if (!HasAny) {
+                            throw new Permission_Type_1.PermissionError(options.message ||
+                                'Você não tem o cargo necessário para usar este comando.');
+                        }
+                    }
+                    if ('all' in options.roles) {
+                        const HasAll = options.roles.all.every((Id) => RoleIds.includes(Id));
+                        if (!HasAll) {
+                            throw new Permission_Type_1.PermissionError(options.message ||
+                                'Você não tem o cargo necessário para usar este comando.');
+                        }
+                    }
+                    if ('min' in options.roles) {
+                        const Count = options.roles.from.filter((Id) => RoleIds.includes(Id)).length;
+                        if (Count < options.roles.min) {
+                            throw new Permission_Type_1.PermissionError(options.message ||
+                                'Você não tem o cargo necessário para usar este comando.');
+                        }
+                    }
+                }
+                if (options.channels && ChannelId) {
+                    if ('any' in options.channels) {
+                        const InAny = options.channels.any.includes(ChannelId);
+                        if (!InAny) {
+                            throw new Permission_Type_1.PermissionError(options.message ||
+                                'Este comando não pode ser usado neste canal.');
+                        }
+                    }
+                    if ('all' in options.channels) {
+                        const InAll = options.channels.all.includes(ChannelId);
+                        if (!InAll) {
+                            throw new Permission_Type_1.PermissionError(options.message ||
+                                'Este comando não pode ser usado neste canal.');
+                        }
+                    }
+                    if ('min' in options.channels) {
+                        const Count = options.channels.from.filter((Id) => Id === ChannelId).length;
+                        if (Count < options.channels.min) {
+                            throw new Permission_Type_1.PermissionError(options.message ||
+                                'Este comando não pode ser usado neste canal.');
+                        }
+                    }
+                }
+                return Promise.resolve(true);
+            };
+            const Ctx = ComponentRuntime.attachRequests(Object.assign(interaction, {
+                Type: 'Slash',
+                require: CreateRequire,
+                t: (key, params, locale) => {
+                    return I18n_1.default.t(key, params, locale || interaction.locale || interaction.guild?.preferredLocale);
+                }
+            }), client.runtimeKey);
+            Ctx.options = (0, InputInteraction_Type_2.ProxyOptions)(Ctx.options);
+            try {
+                const canExecute = await ProcessCooldown(Ctx, interaction.commandName, Command);
+                if (!canExecute)
+                    return;
+                const executeAction = async () => {
+                    // A medição começa aqui para excluir o tempo de espera na fila.
+                    const handlerStartedAt = Date.now();
+                    await (0, InteractionContext_1.RunWith)(Ctx, () => Command.execute(Ctx));
+                    TelemetryService_1.default.registerAction('slash', interaction.commandName, true, {
+                        user: interaction.user.id,
+                        guild: interaction.guildId,
+                        params: interaction.options.data
+                    }, undefined, Date.now() - handlerStartedAt);
+                };
+                await ProcessQueue(Ctx, interaction.commandName, Command, executeAction);
+                TelemetryService_1.default.registerCounter('slashHandled');
+            }
+            catch (error) {
+                if (error instanceof Permission_Type_1.PermissionError) {
+                    TelemetryService_1.default.registerCounter('permissionRejections');
+                    const Reply = { content: error.message, flags: 64 };
+                    if (interaction.replied || interaction.deferred) {
+                        await interaction.followUp(Reply).catch(() => { });
+                    }
+                    else {
+                        await interaction.reply(Reply).catch(() => { });
+                    }
+                    return;
+                }
+                (0, ConsoleLog_1.logError)(`Erro no slash command ${(0, Color_1.default)(interaction.commandName, 'cyan', 'bold')}: ${error}`);
+                TelemetryService_1.default.registerAction('slash', interaction.commandName, false, {
+                    user: interaction.user.id,
+                    guild: interaction.guildId,
+                    params: interaction.options.data
+                }, String(error));
+                const Reply = { content: 'Erro ao executar comando', flags: 64 };
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp(Reply).catch(() => { });
+                }
+                else {
+                    await interaction.reply(Reply).catch(() => { });
+                }
+            }
+            return;
+        }
+        if (interaction.isContextMenuCommand()) {
+            const Command = client.contextMenuCommands.get(interaction.commandName);
+            if (!Command)
+                return;
+            const Ctx = ComponentRuntime.attachRequests((0, InputInteraction_Type_1.CreateContextMenuInputCommandInteraction)(interaction), client.runtimeKey);
+            try {
+                const handlerStartedAt = Date.now();
+                await (0, InteractionContext_1.RunWith)(Ctx, () => Command.execute(Ctx));
+                TelemetryService_1.default.registerAction('context', interaction.commandName, true, {
+                    user: interaction.user.id,
+                    guild: interaction.guildId
+                }, undefined, Date.now() - handlerStartedAt);
+            }
+            catch (error) {
+                if (error instanceof Permission_Type_1.PermissionError) {
+                    TelemetryService_1.default.registerCounter('permissionRejections');
+                    const Reply = { content: error.message, flags: 64 };
+                    if (interaction.replied || interaction.deferred) {
+                        await interaction.followUp(Reply).catch(() => { });
+                    }
+                    else {
+                        await interaction.reply(Reply).catch(() => { });
+                    }
+                    return;
+                }
+                (0, ConsoleLog_1.logError)(`Erro no context menu ${(0, Color_1.default)(interaction.commandName, 'cyan', 'bold')}: ${error}`);
+                TelemetryService_1.default.registerAction('context', interaction.commandName, false, {
+                    user: interaction.user.id,
+                    guild: interaction.guildId
+                }, String(error));
+                const Reply = { content: 'Erro ao executar comando', flags: 64 };
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp(Reply).catch(() => { });
+                }
+                else {
+                    await interaction.reply(Reply).catch(() => { });
+                }
+            }
+            return;
+        }
+        if (interaction.isModalSubmit()) {
+            const Modal = client.modals.get(interaction.customId);
+            if (!Modal) {
+                // Modal sem handler registrado (ex.: removido após restart):
+                // responder evita o "falha na interação" para o usuário.
+                TelemetryService_1.default.registerCounter('unknownModalSubmits');
+                await interaction
+                    .reply({
+                    content: 'Este formulário não está mais disponível.',
+                    flags: 64
+                })
+                    .catch(() => { });
+                return;
+            }
+            TelemetryService_1.default.registerCounter('modalSubmits');
+            const handlerStartedAt = Date.now();
+            try {
+                await Modal.execute(interaction);
+                TelemetryService_1.default.registerAction('modal', interaction.customId, true, { user: interaction.user.id, guild: interaction.guildId }, undefined, Date.now() - handlerStartedAt);
+            }
+            catch (error) {
+                (0, ConsoleLog_1.logError)(`Erro no modal ${(0, Color_1.default)(interaction.customId, 'cyan', 'bold')}: ${error}`);
+                TelemetryService_1.default.registerAction('modal', interaction.customId, false, { user: interaction.user.id, guild: interaction.guildId }, String(error), Date.now() - handlerStartedAt);
+                const Reply = { content: 'Erro ao processar modal', flags: 64 };
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp(Reply).catch(() => { });
+                }
+                else {
+                    await interaction.reply(Reply).catch(() => { });
+                }
+            }
+            return;
+        }
+        if (interaction.isButton() || interaction.isAnySelectMenu()) {
+            TelemetryService_1.default.registerCounter('componentInteractions');
+            const ActiveComponent = InteractionManager_1.default.FindActive(interaction.customId, interaction, client.runtimeKey);
+            if (!ActiveComponent) {
+                const runtimeStartedAt = Date.now();
+                try {
+                    if (await ComponentRuntime.resolve(interaction, client.runtimeKey)) {
+                        TelemetryService_1.default.registerAction('component', interaction.customId, true, { user: interaction.user.id, guild: interaction.guildId, runtime: 'componentb' }, undefined, Date.now() - runtimeStartedAt);
+                        return;
+                    }
+                }
+                catch (error) {
+                    (0, ConsoleLog_1.logError)(`Erro no runtime da ComponentB ${(0, Color_1.default)(interaction.customId, 'cyan', 'bold')}: ${error?.message || error}`, 'ComponentB');
+                    TelemetryService_1.default.registerAction('component', interaction.customId, false, { user: interaction.user.id, guild: interaction.guildId, runtime: 'componentb' }, String(error?.message || error), Date.now() - runtimeStartedAt);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({
+                            content: 'Não foi possível processar este componente.',
+                            flags: 64
+                        }).catch(() => { });
+                    }
+                }
+                return;
+            }
+            if (ActiveComponent.user &&
+                ActiveComponent.user !== interaction.user.id) {
+                TelemetryService_1.default.registerCounter('componentUserMismatches');
+                await interaction
+                    .reply({
+                    content: 'Você não pode interagir com este componente.',
+                    flags: 64
+                })
+                    .catch(() => { });
+                return;
+            }
+            const handlerStartedAt = Date.now();
+            try {
+                if (ActiveComponent.definer.Execute) {
+                    const Ctx = InteractionManager_1.default.CreateContext(interaction);
+                    await ActiveComponent.definer.Execute(Ctx);
+                }
+                else {
+                    await InteractionManager_1.default.ResolveActive(interaction.customId, interaction, client.runtimeKey);
+                }
+                TelemetryService_1.default.registerAction('component', interaction.customId, true, { user: interaction.user.id, guild: interaction.guildId }, undefined, Date.now() - handlerStartedAt);
+            }
+            catch (error) {
+                (0, ConsoleLog_1.logError)(`Erro no componente ${(0, Color_1.default)(interaction.customId, 'cyan', 'bold')}: ${error}`);
+                TelemetryService_1.default.registerAction('component', interaction.customId, false, { user: interaction.user.id, guild: interaction.guildId }, String(error), Date.now() - handlerStartedAt);
+                const Reply = {
+                    content: 'Erro ao processar componente',
+                    flags: 64
+                };
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp(Reply).catch(() => { });
+                }
+                else {
+                    await interaction.reply(Reply).catch(() => { });
+                }
+            }
+            return;
+        }
+    }));
+    const Prefix = process.env.PREFIX || '!';
+    client._on(discord_js_1.Events.MessageCreate, SafeAsyncListener('MessageCreate', async (message) => {
+        if (message.author.bot)
+            return;
+        TelemetryService_1.default.registerCounter('messagesSeen');
+        if (!message.content.startsWith(Prefix))
+            return;
+        const Args = message.content.slice(Prefix.length).trim().split(/ +/);
+        const CommandName = Args.shift()?.toLowerCase();
+        if (!CommandName)
+            return;
+        let Command = client.prefixCommands.get(CommandName);
+        if (!Command) {
+            Command = client.prefixCommands.find((cmd) => {
+                const Config = cmd.data.toConfig();
+                return Config.Aliases.some((A) => A.toLowerCase() === CommandName);
+            });
+        }
+        if (!Command)
+            return;
+        const Config = Command.data.toConfig();
+        const Ctx = ComponentRuntime.attachRequests((0, InputInteraction_Type_1.CreatePrefixInputCommandInteraction)(message, Args, Config, Config.Name, client.runtimeKey), client.runtimeKey);
+        try {
+            const canExecute = await ProcessCooldown(Ctx, Config.Name, Command);
+            if (!canExecute)
+                return;
+            const executeAction = async () => {
+                const handlerStartedAt = Date.now();
+                await (0, InteractionContext_1.RunWith)(Ctx, () => Command.execute(Ctx));
+                TelemetryService_1.default.registerAction('prefix', Config.Name, true, {
+                    user: message.author.id,
+                    guild: message.guildId,
+                    params: Args
+                }, undefined, Date.now() - handlerStartedAt);
+            };
+            await ProcessQueue(Ctx, Config.Name, Command, executeAction);
+            TelemetryService_1.default.registerCounter('prefixHandled');
+        }
+        catch (error) {
+            if (error instanceof Permission_Type_1.PermissionError) {
+                TelemetryService_1.default.registerCounter('permissionRejections');
+                await message.reply(error.message).catch(() => { });
+                return;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            (0, ConsoleLog_1.logError)(`Erro no prefix command ${(0, Color_1.default)(Config.Name, 'cyan', 'bold')}: ${errorMessage}`);
+            TelemetryService_1.default.registerAction('prefix', Config.Name, false, {
+                user: message.author.id,
+                guild: message.guildId,
+                params: Args
+            }, String(error));
+            await message.reply('Erro ao executar comando').catch(() => { });
+        }
+    }));
+};
+exports.Setup = Setup;
+// --------------------------------------------------------------------------------
+//# sourceMappingURL=Definer.js.map