@minesa-org/mini-interaction 0.1.12 → 0.2.0

package/dist/clients/MiniInteraction.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { ApplicationCommandType, InteractionResponseType, InteractionType, } from "discord-api-types/v10";
 import { verifyKey } from "discord-interactions";
+import { resolveJSONEncodable } from "../builders/shared.js";
 import { DISCORD_BASE_URL } from "../utils/constants.js";
 import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
 import { createMessageComponentInteraction, } from "../utils/MessageComponentInteraction.js";
@@ -30,10 +31,12 @@ export class MiniInteraction {
     commandsDirectory;
     componentsDirectory;
     utilsDirectory;
+    timeoutConfig;
     commands = new Map();
     componentHandlers = new Map();
     modalHandlers = new Map();
     htmlTemplateCache = new Map();
+    interactionStates = new Map();
     commandsLoaded = false;
     loadCommandsPromise = null;
     componentsLoaded = false;
@@ -43,7 +46,7 @@ export class MiniInteraction {
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, utilsDirectory, fetchImplementation, verifyKeyImplementation, }) {
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, utilsDirectory, fetchImplementation, verifyKeyImplementation, timeoutConfig, }) {
         if (!applicationId) {
             throw new Error("[MiniInteraction] applicationId is required");
         }
@@ -70,13 +73,135 @@ export class MiniInteraction {
             utilsDirectory === false
                 ? null
                 : this.resolveUtilsDirectory(utilsDirectory);
+        this.timeoutConfig = {
+            initialResponseTimeout: 2800, // Leave 200ms buffer before Discord's 3s limit
+            enableTimeoutWarnings: true,
+            autoDeferSlowOperations: true,
+            enableResponseDebugLogging: false,
+            responseAcknowledgmentTimeout: 500, // 500ms to wait for acknowledgment
+            responseAcknowledgmentRetries: 2,
+            responseAcknowledgmentRetryDelay: 100,
+            ...timeoutConfig,
+        };
+    }
+    /**
+     * Tracks the state of an interaction to prevent race conditions and double responses.
+     */
+    trackInteractionState(interactionId, token, state) {
+        const existing = this.interactionStates.get(interactionId);
+        const now = Date.now();
+        this.interactionStates.set(interactionId, {
+            state,
+            timestamp: now,
+            token,
+            responseCount: existing ? existing.responseCount + 1 : 1,
+        });
+        if (this.timeoutConfig.enableResponseDebugLogging) {
+            console.log(`[MiniInteraction:DEBUG] Interaction ${interactionId} state: ${state} (${existing ? existing.responseCount + 1 : 1} responses)`);
+        }
+    }
+    /**
+     * Checks if an interaction can still respond (not expired and not already responded).
+     */
+    canRespond(interactionId) {
+        const state = this.getInteractionState(interactionId);
+        if (!state)
+            return true; // New interaction
+        // Check if expired (15 minutes)
+        if (Date.now() - state.timestamp > 900000) {
+            this.trackInteractionState(interactionId, state.token, 'expired');
+            return false;
+        }
+        // Check if already responded
+        if (state.state === 'responded') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Logs response timing and acknowledgment for debugging.
+     */
+    logResponseTiming(interactionId, operation, startTime, success) {
+        if (!this.timeoutConfig.enableResponseDebugLogging)
+            return;
+        const elapsed = Date.now() - startTime;
+        const status = success ? 'SUCCESS' : 'FAILED';
+        console.log(`[MiniInteraction:DEBUG] ${operation} for interaction ${interactionId}: ${status} (${elapsed}ms)`);
+        if (success && elapsed > 2000) {
+            console.warn(`[MiniInteraction:WARN] ${operation} took ${elapsed}ms - consider using deferReply() for slow operations`);
+        }
+    }
+    /**
+     * Simulates waiting for Discord acknowledgment to help debug timing issues.
+     * Note: This is a best-effort simulation since actual acknowledgment happens at the HTTP level.
+     */
+    async simulateAcknowledgmentWait(interactionId, operation) {
+        if (!this.timeoutConfig.enableResponseDebugLogging)
+            return;
+        const timeout = this.timeoutConfig.responseAcknowledgmentTimeout || 500;
+        const retries = this.timeoutConfig.responseAcknowledgmentRetries || 2;
+        const retryDelay = this.timeoutConfig.responseAcknowledgmentRetryDelay || 100;
+        console.log(`[MiniInteraction:DEBUG] Waiting for acknowledgment of ${operation} for interaction ${interactionId}...`);
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            await new Promise(resolve => setTimeout(resolve, attempt === 0 ? timeout : retryDelay));
+            // In a real implementation, this would verify Discord actually received the response
+            // For now, we just simulate the wait time
+            const state = this.getInteractionState(interactionId);
+            if (state?.state === 'responded' || state?.state === 'deferred') {
+                console.log(`[MiniInteraction:DEBUG] Acknowledgment confirmed for ${operation} after ${attempt + 1} attempts`);
+                return;
+            }
+        }
+        console.warn(`[MiniInteraction:WARN] Acknowledgment timeout for ${operation} on interaction ${interactionId}`);
+    }
+    /**
+     * Enables or disables debug logging for interaction responses and timing.
+     * Useful for troubleshooting "didn't respond in time" errors.
+     *
+     * @param enabled - Whether to enable debug logging
+     */
+    setResponseDebugLogging(enabled) {
+        this.timeoutConfig.enableResponseDebugLogging = enabled;
+        console.log(`[MiniInteraction] Response debug logging ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    /**
+     * Gets the current state of an interaction.
+     */
+    getInteractionState(interactionId) {
+        return this.interactionStates.get(interactionId);
+    }
+    /**
+     * Gets the current state of an interaction for debugging purposes.
+     *
+     * @param interactionId - The interaction ID to check
+     * @returns The current interaction state or null if not found
+     */
+    getInteractionStateInfo(interactionId) {
+        const state = this.interactionStates.get(interactionId);
+        return state ? { ...state } : null; // Return a copy to prevent external modification
+    }
+    /**
+     * Clears expired interaction states to prevent memory leaks.
+     * Call this periodically to clean up old interaction data.
+     */
+    cleanupExpiredInteractions() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [id, state] of this.interactionStates.entries()) {
+            // Remove interactions older than 15 minutes
+            if (now - state.timestamp > 900000) {
+                this.interactionStates.delete(id);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[MiniInteraction] Cleaned up ${cleaned} expired interactions`);
+        }
+        return cleaned;
     }
     normalizeCommandData(data) {
         if (typeof data === "object" && data !== null) {
-            const toJSON = data.toJSON;
-            if (typeof toJSON === "function") {
-                return toJSON.call(data);
-            }
+            return resolveJSONEncodable(data);
         }
         return data;
     }
@@ -94,12 +219,14 @@ export class MiniInteraction {
             data: normalizedData,
         };
         this.commands.set(commandName, normalizedCommand);
-        if (normalizedCommand.components && Array.isArray(normalizedCommand.components)) {
+        if (normalizedCommand.components &&
+            Array.isArray(normalizedCommand.components)) {
             for (const component of normalizedCommand.components) {
                 this.useComponent(component);
             }
         }
-        if (normalizedCommand.modals && Array.isArray(normalizedCommand.modals)) {
+        if (normalizedCommand.modals &&
+            Array.isArray(normalizedCommand.modals)) {
             for (const modal of normalizedCommand.modals) {
                 this.useModal(modal);
             }
@@ -354,6 +481,7 @@ export class MiniInteraction {
      * @param request - The request payload containing headers and body data.
      */
     async handleRequest(request) {
+        const requestStartTime = Date.now();
         const { body, signature, timestamp } = request;
         if (!signature || !timestamp) {
             return {
@@ -390,14 +518,34 @@ export class MiniInteraction {
             };
         }
         if (interaction.type === InteractionType.ApplicationCommand) {
+            // Track interaction start
+            this.trackInteractionState(interaction.id, interaction.token, 'pending');
             return this.handleApplicationCommand(interaction);
         }
         if (interaction.type === InteractionType.MessageComponent) {
+            // Track interaction start
+            this.trackInteractionState(interaction.id, interaction.token, 'pending');
             return this.handleMessageComponent(interaction);
         }
         if (interaction.type === InteractionType.ModalSubmit) {
+            // Track interaction start
+            this.trackInteractionState(interaction.id, interaction.token, 'pending');
             return this.handleModalSubmit(interaction);
         }
+        // Check total processing time and log potential timeout issues
+        const totalProcessingTime = Date.now() - requestStartTime;
+        if (this.timeoutConfig.enableTimeoutWarnings &&
+            totalProcessingTime >
+                this.timeoutConfig.initialResponseTimeout * 0.9) {
+            console.warn(`[MiniInteraction] CRITICAL: Interaction processing took ${totalProcessingTime}ms ` +
+                `(${Math.round((totalProcessingTime / 3000) * 100)}% of Discord's 3-second limit). ` +
+                `This may cause "didn't respond in time" errors. ` +
+                `Consider optimizing or using deferReply() for slow operations.`);
+        }
+        // Log successful response timing for debugging
+        if (this.timeoutConfig.enableResponseDebugLogging) {
+            console.log(`[MiniInteraction:DEBUG] Request completed in ${totalProcessingTime}ms`);
+        }
         return {
             status: 400,
             body: {
@@ -511,8 +659,8 @@ export class MiniInteraction {
      * The following placeholders are available in the HTML file:
      * - `{{username}}`, `{{discriminator}}`, `{{user_id}}`, `{{user_tag}}`
      * - `{{access_token}}`, `{{refresh_token}}`, `{{token_type}}`, `{{scope}}`, `{{expires_at}}`
-         * - `{{state}}`
-         */
+     * - `{{state}}`
+     */
     connectedOAuthPage(filePath) {
         const template = this.loadHtmlTemplate(filePath);
         return ({ user, tokens, state }) => {
@@ -569,7 +717,7 @@ export class MiniInteraction {
     }
     /**
      * Replaces placeholder tokens in a template with escaped HTML values.
- */
+     */
     renderHtmlTemplate(template, values, options) {
         const rawKeys = options?.rawKeys instanceof Set
             ? options.rawKeys
@@ -666,7 +814,9 @@ export class MiniInteraction {
                     const location = typeof options.successRedirect === "function"
                         ? options.successRedirect(authorizeContext)
                         : options.successRedirect;
-                    if (location && !response.headersSent && !response.writableEnded) {
+                    if (location &&
+                        !response.headersSent &&
+                        !response.writableEnded) {
                         response.statusCode = 302;
                         response.setHeader("location", location);
                         response.end();
@@ -1057,27 +1207,32 @@ export class MiniInteraction {
         }
         try {
             const interactionWithHelpers = createMessageComponentInteraction(interaction);
-            const response = await handler(interactionWithHelpers);
-            const resolvedResponse = response ?? interactionWithHelpers.getResponse();
-            if (!resolvedResponse) {
-                return {
-                    status: 500,
-                    body: {
-                        error: `[MiniInteraction] Component "${customId}" did not return a response. ` +
-                            "Return an APIInteractionResponse to acknowledge the interaction.",
-                    },
-                };
-            }
+            // Wrap component handler with timeout
+            const timeoutWrapper = createTimeoutWrapper(async () => {
+                const response = await handler(interactionWithHelpers);
+                const resolvedResponse = response ?? interactionWithHelpers.getResponse();
+                if (!resolvedResponse) {
+                    throw new Error(`Component "${customId}" did not return a response. ` +
+                        "Return an APIInteractionResponse to acknowledge the interaction.");
+                }
+                return resolvedResponse;
+            }, this.timeoutConfig.initialResponseTimeout, `Component "${customId}"`, this.timeoutConfig.enableTimeoutWarnings);
+            const resolvedResponse = await timeoutWrapper();
             return {
                 status: 200,
                 body: resolvedResponse,
             };
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes("Handler timeout")) {
+                console.error(`[MiniInteraction] CRITICAL: Component "${customId}" timed out. ` +
+                    `This will result in "didn't respond in time" errors for users.`);
+            }
             return {
                 status: 500,
                 body: {
-                    error: `[MiniInteraction] Component "${customId}" failed: ${String(error)}`,
+                    error: `[MiniInteraction] Component "${customId}" failed: ${errorMessage}`,
                 },
             };
         }
@@ -1107,27 +1262,32 @@ export class MiniInteraction {
         }
         try {
             const interactionWithHelpers = createModalSubmitInteraction(interaction);
-            const response = await handler(interactionWithHelpers);
-            const resolvedResponse = response ?? interactionWithHelpers.getResponse();
-            if (!resolvedResponse) {
-                return {
-                    status: 500,
-                    body: {
-                        error: `[MiniInteraction] Modal "${customId}" did not return a response. ` +
-                            "Return an APIInteractionResponse to acknowledge the interaction.",
-                    },
-                };
-            }
+            // Wrap modal handler with timeout
+            const timeoutWrapper = createTimeoutWrapper(async () => {
+                const response = await handler(interactionWithHelpers);
+                const resolvedResponse = response ?? interactionWithHelpers.getResponse();
+                if (!resolvedResponse) {
+                    throw new Error(`Modal "${customId}" did not return a response. ` +
+                        "Return an APIInteractionResponse to acknowledge the interaction.");
+                }
+                return resolvedResponse;
+            }, this.timeoutConfig.initialResponseTimeout, `Modal "${customId}"`, this.timeoutConfig.enableTimeoutWarnings);
+            const resolvedResponse = await timeoutWrapper();
             return {
                 status: 200,
                 body: resolvedResponse,
             };
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes("Handler timeout")) {
+                console.error(`[MiniInteraction] CRITICAL: Modal "${customId}" timed out. ` +
+                    `This will result in "didn't respond in time" errors for users.`);
+            }
             return {
                 status: 500,
                 body: {
-                    error: `[MiniInteraction] Modal "${customId}" failed: ${String(error)}`,
+                    error: `[MiniInteraction] Modal "${customId}" failed: ${errorMessage}`,
                 },
             };
         }
@@ -1159,41 +1319,54 @@ export class MiniInteraction {
         try {
             let response;
             let resolvedResponse = null;
-            // Check if it's a chat input (slash) command
-            if (commandInteraction.data.type ===
-                ApplicationCommandType.ChatInput) {
-                const interactionWithHelpers = createCommandInteraction(commandInteraction);
-                response = await command.handler(interactionWithHelpers);
-                resolvedResponse =
-                    response ?? interactionWithHelpers.getResponse();
-            }
-            else if (commandInteraction.data.type === ApplicationCommandType.User) {
-                // User context menu command
-                const interactionWithHelpers = createUserContextMenuInteraction(commandInteraction);
-                response = await command.handler(interactionWithHelpers);
-                resolvedResponse =
-                    response ?? interactionWithHelpers.getResponse();
-            }
-            else if (commandInteraction.data.type ===
-                ApplicationCommandType.PrimaryEntryPoint) {
-                const interactionWithHelpers = createAppCommandInteraction(commandInteraction);
-                response = await command.handler(interactionWithHelpers);
-                resolvedResponse =
-                    response ?? interactionWithHelpers.getResponse();
-            }
-            else if (commandInteraction.data.type === ApplicationCommandType.Message) {
-                // Message context menu command
-                const interactionWithHelpers = createMessageContextMenuInteraction(commandInteraction);
-                response = await command.handler(interactionWithHelpers);
-                resolvedResponse =
-                    response ?? interactionWithHelpers.getResponse();
-            }
-            else {
-                // Unknown command type
-                response = await command.handler(commandInteraction);
-                resolvedResponse = response ?? null;
-            }
+            // Create a timeout wrapper for the command handler
+            const timeoutWrapper = createTimeoutWrapper(async () => {
+                // Check if it's a chat input (slash) command
+                if (commandInteraction.data.type ===
+                    ApplicationCommandType.ChatInput) {
+                    const interactionWithHelpers = createCommandInteraction(commandInteraction, {
+                        canRespond: (id) => this.canRespond(id),
+                        trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
+                        logTiming: (id, op, start, success) => this.logResponseTiming(id, op, start, success),
+                    });
+                    response = await command.handler(interactionWithHelpers);
+                    resolvedResponse =
+                        response ?? interactionWithHelpers.getResponse();
+                }
+                else if (commandInteraction.data.type ===
+                    ApplicationCommandType.User) {
+                    // User context menu command
+                    const interactionWithHelpers = createUserContextMenuInteraction(commandInteraction);
+                    response = await command.handler(interactionWithHelpers);
+                    resolvedResponse =
+                        response ?? interactionWithHelpers.getResponse();
+                }
+                else if (commandInteraction.data.type ===
+                    ApplicationCommandType.PrimaryEntryPoint) {
+                    const interactionWithHelpers = createAppCommandInteraction(commandInteraction);
+                    response = await command.handler(interactionWithHelpers);
+                    resolvedResponse =
+                        response ?? interactionWithHelpers.getResponse();
+                }
+                else if (commandInteraction.data.type ===
+                    ApplicationCommandType.Message) {
+                    // Message context menu command
+                    const interactionWithHelpers = createMessageContextMenuInteraction(commandInteraction);
+                    response = await command.handler(interactionWithHelpers);
+                    resolvedResponse =
+                        response ?? interactionWithHelpers.getResponse();
+                }
+                else {
+                    // Unknown command type
+                    response = await command.handler(commandInteraction);
+                    resolvedResponse = response ?? null;
+                }
+            }, this.timeoutConfig.initialResponseTimeout, `Command "${commandName}"`, this.timeoutConfig.enableTimeoutWarnings);
+            await timeoutWrapper();
             if (!resolvedResponse) {
+                console.error(`[MiniInteraction] Command "${commandName}" did not return a response. ` +
+                    "This indicates the handler completed but no response was generated. " +
+                    "Check that deferReply(), reply(), showModal(), or a direct response is returned.");
                 return {
                     status: 500,
                     body: {
@@ -1209,10 +1382,18 @@ export class MiniInteraction {
             };
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if this was a timeout error
+            if (errorMessage.includes("Handler timeout")) {
+                console.error(`[MiniInteraction] CRITICAL: Command "${commandName}" timed out before responding to Discord. ` +
+                    `This will result in "didn't respond in time" errors for users. ` +
+                    `Handler took longer than ${this.timeoutConfig.initialResponseTimeout}ms to complete. ` +
+                    `Consider using deferReply() for operations that take more than 3 seconds.`);
+            }
             return {
                 status: 500,
                 body: {
-                    error: `[MiniInteraction] Command "${commandName}" failed: ${String(error)}`,
+                    error: `[MiniInteraction] Command "${commandName}" failed: ${errorMessage}`,
                 },
             };
         }
@@ -1382,3 +1563,45 @@ function resolveOAuthConfig(provided) {
         redirectUri,
     };
 }
+/**
+ * Wraps a handler function with timeout detection and error handling.
+ */
+function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings = true) {
+    return async (...args) => {
+        const startTime = Date.now();
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                const elapsed = Date.now() - startTime;
+                console.error(`[MiniInteraction] ${handlerName} timed out after ${elapsed}ms (limit: ${timeoutMs}ms)`);
+                reject(new Error(`Handler timeout: ${handlerName} exceeded ${timeoutMs}ms limit`));
+            }, timeoutMs);
+        });
+        try {
+            const result = await Promise.race([
+                Promise.resolve(handler(...args)),
+                timeoutPromise,
+            ]);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            const elapsed = Date.now() - startTime;
+            if (enableWarnings && elapsed > timeoutMs * 0.8) {
+                console.warn(`[MiniInteraction] ${handlerName} completed in ${elapsed}ms (${Math.round((elapsed / timeoutMs) * 100)}% of timeout limit)`);
+            }
+            return result;
+        }
+        catch (error) {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Re-throw the error with additional context
+            if (error instanceof Error &&
+                error.message.includes("Handler timeout")) {
+                throw error;
+            }
+            console.error(`[MiniInteraction] ${handlerName} failed:`, error);
+            throw error;
+        }
+    };
+}

package/dist/index.d.ts

@@ -5,21 +5,21 @@ export { CommandBuilder, CommandContext, IntegrationType, } from "./commands/Com
 export { UserCommandBuilder, MessageCommandBuilder, AppCommandBuilder, } from "./commands/ContextMenuCommandBuilder.js";
 export type { AttachmentOptionBuilder, ChannelOptionBuilder, MentionableOptionBuilder, NumberOptionBuilder, RoleOptionBuilder, StringOptionBuilder, SubcommandBuilder, SubcommandGroupBuilder, UserOptionBuilder, } from "./commands/CommandBuilder.js";
 export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
-export type { CommandInteraction, MentionableOption, ResolvedUserOption, } from "./utils/CommandInteractionOptions.js";
-export type { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction, } from "./utils/ContextMenuInteraction.js";
-export type { MiniInteractionFetchHandler, MiniInteractionNodeHandler, MiniInteractionHandlerResult, MiniInteractionRequest, MiniInteractionOptions, DiscordOAuthAuthorizeContext, DiscordOAuthCallbackOptions, DiscordOAuthCallbackTemplates, DiscordOAuthErrorTemplateContext, DiscordOAuthServerErrorTemplateContext, DiscordOAuthStateTemplateContext, DiscordOAuthSuccessTemplateContext, DiscordOAuthVerificationPageOptions, } from "./clients/MiniInteraction.js";
-export type { MiniInteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, AppCommandHandler, CommandHandler, } from "./types/Commands.js";
-export type { MiniInteractionComponent, MiniInteractionButtonHandler, MiniInteractionStringSelectHandler, MiniInteractionRoleSelectHandler, MiniInteractionUserSelectHandler, MiniInteractionChannelSelectHandler, MiniInteractionMentionableSelectHandler, MiniInteractionComponentHandler, MiniInteractionModal, MiniInteractionModalHandler, MiniInteractionHandler, } from "./clients/MiniInteraction.js";
-export type { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
-export type { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
+export { CommandInteraction, MentionableOption, ResolvedUserOption, } from "./utils/CommandInteractionOptions.js";
+export { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction, } from "./utils/ContextMenuInteraction.js";
+export type { InteractionFetchHandler, InteractionNodeHandler, InteractionHandlerResult, InteractionRequest, InteractionClientOptions, DiscordOAuthAuthorizeContext, DiscordOAuthCallbackOptions, DiscordOAuthCallbackTemplates, DiscordOAuthErrorTemplateContext, DiscordOAuthServerErrorTemplateContext, DiscordOAuthStateTemplateContext, DiscordOAuthSuccessTemplateContext, DiscordOAuthVerificationPageOptions, } from "./clients/MiniInteraction.js";
+export type { InteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, AppCommandHandler, CommandHandler, } from "./types/Commands.js";
+export type { ComponentCommand, ButtonComponentHandler, StringSelectComponentHandler, RoleSelectComponentHandler, UserSelectComponentHandler, ChannelSelectComponentHandler, MentionableSelectComponentHandler, ComponentHandler, ModalCommand, ModalHandler, InteractionHandler, } from "./clients/MiniInteraction.js";
+export { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
+export { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";
-export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
+export { InteractionFollowUpFlags, InteractionReplyFlags, InteractionFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
-export type { MiniComponentActionRow, MiniComponentMessageActionRow, } from "./types/ComponentTypes.js";
+export type { ActionRowComponent, MessageActionRowComponent, } from "./types/ComponentTypes.js";
 export * from "./builders/index.js";
 export { MiniDataBuilder } from "./database/MiniDataBuilder.js";
 export type { DataField } from "./database/MiniDataBuilder.js";

package/dist/index.js

@@ -3,9 +3,13 @@ export { MiniInteraction } from "./clients/MiniInteraction.js";
 export { CommandBuilder, CommandContext, IntegrationType, } from "./commands/CommandBuilder.js";
 export { UserCommandBuilder, MessageCommandBuilder, AppCommandBuilder, } from "./commands/ContextMenuCommandBuilder.js";
 export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
+export { CommandInteraction, MentionableOption, ResolvedUserOption, } from "./utils/CommandInteractionOptions.js";
+export { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction, } from "./utils/ContextMenuInteraction.js";
+export { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
+export { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";
-export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
+export { InteractionFollowUpFlags, InteractionReplyFlags, InteractionFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
 export { TextInputStyle } from "discord-api-types/v10";

package/dist/types/Commands.d.ts

@@ -1,7 +1,8 @@
 import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody } from "discord-api-types/v10";
 import type { CommandInteraction } from "../utils/CommandInteractionOptions.js";
 import type { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction } from "../utils/ContextMenuInteraction.js";
-import type { MiniInteractionComponent, MiniInteractionModal } from "../clients/MiniInteraction.js";
+import type { JSONEncodable } from "../builders/shared.js";
+import type { ComponentCommand, ModalCommand } from "../clients/MiniInteraction.js";
 import type { CommandBuilder } from "../commands/CommandBuilder.js";
 import type { MessageCommandBuilder, UserCommandBuilder, AppCommandBuilder } from "../commands/ContextMenuCommandBuilder.js";
 /** Handler signature for slash command executions within MiniInteraction. */
@@ -15,19 +16,19 @@ export type AppCommandHandler = (interaction: AppCommandInteraction) => Promise<
 /** Union of all command handler types. */
 export type CommandHandler = SlashCommandHandler | UserCommandHandler | MessageCommandHandler | AppCommandHandler;
 /** Structure representing a slash command definition and its runtime handler. */
-export type MiniInteractionCommand = {
-    data: RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody | CommandBuilder | UserCommandBuilder | MessageCommandBuilder | AppCommandBuilder;
+export type InteractionCommand = {
+    data: RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody | CommandBuilder | UserCommandBuilder | MessageCommandBuilder | AppCommandBuilder | JSONEncodable<RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody>;
     handler: CommandHandler;
     /**
      * Optional array of component handlers related to this command.
      * These will be automatically registered when the command is loaded.
  */
-    components?: MiniInteractionComponent[];
+    components?: ComponentCommand[];
     /**
      * Optional array of modal handlers related to this command.
      * These will be automatically registered when the command is loaded.
      */
-    modals?: MiniInteractionModal[];
+    modals?: ModalCommand[];
 };
 /** Map of command names to their registered MiniInteraction command definitions. */
-export type MiniInteractionCommandsMap = Map<string, MiniInteractionCommand>;
+export type InteractionCommandsMap = Map<string, InteractionCommand>;

package/dist/types/ComponentTypes.d.ts

@@ -1,5 +1,5 @@
 import type { APIComponentInActionRow, APIComponentInMessageActionRow } from "discord-api-types/v10";
-/** * Components that can appear inside a Discord action row container. */
-export type MiniComponentMessageActionRow = APIComponentInMessageActionRow;
-/** Components that are valid inside message action rows. */
-export type MiniComponentActionRow = APIComponentInActionRow;
+/** Defines a component structure for use in ActionRow builders. */
+export type ActionRowComponent = APIComponentInActionRow;
+/** Defines a message component structure for use in message builders. */
+export type MessageActionRowComponent = APIComponentInMessageActionRow;

package/dist/types/InteractionFlags.d.ts

@@ -1,10 +1,9 @@
-/** Flags available when responding directly to an interaction. */
-export declare enum InteractionReplyFlags {
-    Ephemeral = 64,
-    IsComponentsV2 = 32768
-}
-/** Flags available when sending a follow-up message for an interaction. */
-export declare enum InteractionFollowUpFlags {
+/** Flags available for interaction responses. */
+export declare enum InteractionFlags {
     Ephemeral = 64,
     IsComponentsV2 = 32768
 }
+/** @deprecated Use InteractionFlags instead. */
+export { InteractionFlags as InteractionReplyFlags };
+/** @deprecated Use InteractionFlags instead. */
+export { InteractionFlags as InteractionFollowUpFlags };

package/dist/types/InteractionFlags.js

@@ -1,12 +1,10 @@
-/** Flags available when responding directly to an interaction. */
-export var InteractionReplyFlags;
-(function (InteractionReplyFlags) {
-    InteractionReplyFlags[InteractionReplyFlags["Ephemeral"] = 64] = "Ephemeral";
-    InteractionReplyFlags[InteractionReplyFlags["IsComponentsV2"] = 32768] = "IsComponentsV2";
-})(InteractionReplyFlags || (InteractionReplyFlags = {}));
-/** Flags available when sending a follow-up message for an interaction. */
-export var InteractionFollowUpFlags;
-(function (InteractionFollowUpFlags) {
-    InteractionFollowUpFlags[InteractionFollowUpFlags["Ephemeral"] = 64] = "Ephemeral";
-    InteractionFollowUpFlags[InteractionFollowUpFlags["IsComponentsV2"] = 32768] = "IsComponentsV2";
-})(InteractionFollowUpFlags || (InteractionFollowUpFlags = {}));
+/** Flags available for interaction responses. */
+export var InteractionFlags;
+(function (InteractionFlags) {
+    InteractionFlags[InteractionFlags["Ephemeral"] = 64] = "Ephemeral";
+    InteractionFlags[InteractionFlags["IsComponentsV2"] = 32768] = "IsComponentsV2";
+})(InteractionFlags || (InteractionFlags = {}));
+/** @deprecated Use InteractionFlags instead. */
+export { InteractionFlags as InteractionReplyFlags };
+/** @deprecated Use InteractionFlags instead. */
+export { InteractionFlags as InteractionFollowUpFlags };