@stonyx/discord 0.1.1-beta.12 → 0.1.1-beta.13

package/dist/base.js

@@ -0,0 +1 @@
+export { SlashCommandBuilder, MessageFlags, PermissionFlagsBits, GatewayIntentBits, AttachmentBuilder, Client, Partials } from 'discord.js';

package/dist/bot.d.ts

@@ -0,0 +1,44 @@
+import { Client } from 'discord.js';
+import type { ChatInputCommandInteraction, Message } from 'discord.js';
+interface CommandInstance {
+    data?: {
+        name: string;
+    };
+    execute?: (interaction: ChatInputCommandInteraction) => Promise<void>;
+    _bot?: DiscordBot;
+    [key: string]: unknown;
+}
+interface EventHandlerInstance {
+    handle?: (...args: unknown[]) => void | Promise<void>;
+    _bot?: DiscordBot;
+    constructor: {
+        event: string | null;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export default class DiscordBot {
+    static instance: DiscordBot | null;
+    commands: Record<string, CommandInstance>;
+    eventHandlers: EventHandlerInstance[];
+    resolveReady: () => void;
+    ready: Promise<void>;
+    client: Client | null;
+    constructor();
+    init(): Promise<void>;
+    registerClientEvents(): void;
+    discoverCommands(): Promise<void>;
+    discoverEvents(): Promise<void>;
+    sendMessage(content: string, channelId: string, imagePath?: string | null): Promise<Message>;
+    sendFile(file: string, messageObject: Message): Promise<Message>;
+    reply(interaction: ChatInputCommandInteraction, content: string): Promise<void>;
+    updateStatus(name: string, type?: number): Promise<void>;
+    getChannelMessages(channelId: string, options?: Record<string, unknown>): Promise<unknown>;
+    getChannelMessage(channelId: string, messageId: string): Promise<unknown>;
+    getGuild(guildId?: string): Promise<unknown>;
+    clearChannelMessages(channelId: string): Promise<unknown[]>;
+    giveRole(memberId: string, roleId: string): Promise<void>;
+    close(): void;
+    reset(): void;
+}
+export {};

package/dist/bot.js

@@ -0,0 +1,200 @@
+import config from 'stonyx/config';
+import log from 'stonyx/log';
+import { Client, GatewayIntentBits, AttachmentBuilder, MessageFlags } from 'discord.js';
+import { forEachFileImport } from '@stonyx/utils/file';
+import { deriveIntents, derivePartials } from './intents.js';
+import { chunkMessage } from './message.js';
+export default class DiscordBot {
+    static instance;
+    commands = {};
+    eventHandlers = [];
+    resolveReady;
+    ready = new Promise(resolve => { this.resolveReady = resolve; });
+    client = null;
+    constructor() {
+        if (DiscordBot.instance)
+            return DiscordBot.instance;
+        DiscordBot.instance = this;
+    }
+    async init() {
+        const { token } = config.discord;
+        if (!token) {
+            log.discord('No DISCORD_TOKEN configured — bot will not start');
+            this.resolveReady();
+            return;
+        }
+        await this.discoverCommands();
+        await this.discoverEvents();
+        const hasWork = Object.keys(this.commands).length > 0 || this.eventHandlers.length > 0;
+        if (!hasWork) {
+            log.discord('No discord commands or event handlers found — skipping bot initialization');
+            this.resolveReady();
+            return;
+        }
+        const discordConfig = config.discord;
+        const intents = deriveIntents(this.eventHandlers, discordConfig.additionalIntents);
+        const partials = derivePartials(intents, discordConfig.additionalPartials);
+        if (Object.keys(this.commands).length > 0) {
+            intents.push(GatewayIntentBits.Guilds);
+        }
+        this.client = new Client({ intents: [...new Set(intents)], partials });
+        this.registerClientEvents();
+        this.client.login(token);
+        await this.ready;
+    }
+    registerClientEvents() {
+        const { client } = this;
+        if (!client)
+            return;
+        client.on('ready', () => {
+            this.resolveReady();
+            log.discord('Discord Bot is Ready!');
+        });
+        client.on('interactionCreate', async (interaction) => {
+            if (!interaction.isChatInputCommand())
+                return;
+            const { commandName } = interaction;
+            const command = this.commands[commandName];
+            if (!command) {
+                await interaction.reply({ content: `\`/${commandName}\` is not available`, flags: MessageFlags.Ephemeral });
+                return;
+            }
+            try {
+                await command.execute(interaction);
+            }
+            catch (error) {
+                log.error(String(error));
+                const reply = { content: 'There was an error executing this command!', flags: MessageFlags.Ephemeral };
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp(reply);
+                }
+                else {
+                    await interaction.reply(reply);
+                }
+            }
+        });
+        for (const handler of this.eventHandlers) {
+            const event = handler.constructor.event;
+            if (event) {
+                client.on(event, (...args) => handler.handle(...args));
+            }
+        }
+    }
+    async discoverCommands() {
+        const { commandDir } = config.discord;
+        if (!commandDir)
+            return;
+        await forEachFileImport(commandDir, (CommandClassUntyped, { name }) => {
+            const CommandClass = CommandClassUntyped;
+            const instance = new CommandClass();
+            if (!instance.data || typeof instance.execute !== 'function') {
+                log.discord(`Command "${name}" is missing data or execute — skipping`);
+                return;
+            }
+            instance._bot = this;
+            this.commands[instance.data.name] = instance;
+            log.discord(`Loaded command: /${instance.data.name}`);
+        }, { ignoreAccessFailure: true });
+    }
+    async discoverEvents() {
+        const { eventDir } = config.discord;
+        if (!eventDir)
+            return;
+        await forEachFileImport(eventDir, (EventHandlerClassUntyped, { name }) => {
+            const EventHandlerClass = EventHandlerClassUntyped;
+            if (!EventHandlerClass.event) {
+                log.discord(`Event handler "${name}" is missing static event property — skipping`);
+                return;
+            }
+            const instance = new EventHandlerClass();
+            instance._bot = this;
+            this.eventHandlers.push(instance);
+            log.discord(`Loaded event handler: ${EventHandlerClass.event} (${name})`);
+        }, { ignoreAccessFailure: true });
+    }
+    async sendMessage(content, channelId, imagePath = null) {
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel)
+            throw new Error('Invalid Channel ID');
+        const options = { content };
+        if (imagePath) {
+            options.files = [new AttachmentBuilder(imagePath)];
+        }
+        return await channel.send(options);
+    }
+    async sendFile(file, messageObject) {
+        return await messageObject.edit({
+            content: '',
+            files: [{
+                    attachment: file,
+                    name: file.split('/').pop()
+                }]
+        });
+    }
+    async reply(interaction, content) {
+        if (content.length <= 2000) {
+            if (interaction.deferred || interaction.replied) {
+                await interaction.editReply({ content });
+                return;
+            }
+            await interaction.reply({ content });
+            return;
+        }
+        const [first, ...rest] = chunkMessage('', content);
+        if (interaction.deferred || interaction.replied) {
+            await interaction.editReply({ content: first });
+        }
+        else {
+            await interaction.reply({ content: first });
+        }
+        for (const chunk of rest) {
+            await interaction.followUp({ content: chunk });
+        }
+    }
+    async updateStatus(name, type = 0) {
+        await this.client.user.setPresence({
+            activities: [{ name, type }],
+            status: 'online'
+        });
+    }
+    async getChannelMessages(channelId, options = {}) {
+        const channel = await this.client.channels.fetch(channelId);
+        const discordConfig = config.discord;
+        return await channel.messages.fetch({
+            limit: discordConfig.maxMessagesPerRequest,
+            ...options
+        });
+    }
+    async getChannelMessage(channelId, messageId) {
+        const channel = await this.client.channels.fetch(channelId);
+        return await channel.messages.fetch(messageId);
+    }
+    async getGuild(guildId) {
+        const discordConfig = config.discord;
+        return await this.client.guilds.fetch(guildId || discordConfig.serverId);
+    }
+    async clearChannelMessages(channelId) {
+        const promises = [];
+        const messages = await this.getChannelMessages(channelId);
+        messages.forEach(message => promises.push(message.delete()));
+        return Promise.all(promises);
+    }
+    async giveRole(memberId, roleId) {
+        const guild = await this.getGuild();
+        const role = await guild.roles.fetch(roleId);
+        const member = await guild.members.fetch(memberId);
+        await member.roles.add(role);
+    }
+    close() {
+        if (this.client) {
+            this.client.destroy();
+            this.client = null;
+        }
+        DiscordBot.instance = null;
+    }
+    reset() {
+        this.close();
+        this.commands = {};
+        this.eventHandlers = [];
+    }
+}

package/dist/command.d.ts

@@ -0,0 +1,6 @@
+import type { ChatInputCommandInteraction, SlashCommandBuilder } from 'discord.js';
+export default class Command {
+    static skipAuth: boolean;
+    data?: SlashCommandBuilder;
+    execute?: (interaction: ChatInputCommandInteraction) => Promise<void>;
+}

package/{src → dist}/command.js

@@ -1,3 +1,3 @@
 export default class Command {
-  static skipAuth = false;
+    static skipAuth = false;
 }

package/dist/event-handler.d.ts

@@ -0,0 +1,4 @@
+export default class EventHandler {
+    static event: string | null;
+    handle?: (...args: unknown[]) => void | Promise<void>;
+}

package/{src → dist}/event-handler.js

@@ -1,3 +1,3 @@
 export default class EventHandler {
-  static event = null;
+    static event = null;
 }

package/dist/intents.d.ts

@@ -0,0 +1,11 @@
+import { GatewayIntentBits, Partials } from 'discord.js';
+interface EventHandlerLike {
+    constructor: {
+        event: string | null;
+    };
+}
+declare const EVENT_INTENT_MAP: Record<string, GatewayIntentBits[]>;
+declare const INTENT_PARTIAL_MAP: Partial<Record<GatewayIntentBits, Partials[]>>;
+export declare function deriveIntents(eventHandlers: EventHandlerLike[], additionalIntents?: string[]): GatewayIntentBits[];
+export declare function derivePartials(intents: GatewayIntentBits[], additionalPartials?: string[]): Partials[];
+export { EVENT_INTENT_MAP, INTENT_PARTIAL_MAP };

package/dist/intents.js

@@ -0,0 +1,51 @@
+import { GatewayIntentBits, Partials } from 'discord.js';
+const EVENT_INTENT_MAP = {
+    messageCreate: [GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+    messageDelete: [GatewayIntentBits.GuildMessages],
+    messageUpdate: [GatewayIntentBits.GuildMessages],
+    guildMemberAdd: [GatewayIntentBits.GuildMembers],
+    guildMemberRemove: [GatewayIntentBits.GuildMembers],
+    inviteCreate: [GatewayIntentBits.GuildInvites],
+    inviteDelete: [GatewayIntentBits.GuildInvites],
+    voiceStateUpdate: [GatewayIntentBits.GuildVoiceStates],
+    interactionCreate: [],
+};
+const INTENT_PARTIAL_MAP = {
+    [GatewayIntentBits.DirectMessages]: [Partials.Channel],
+};
+export function deriveIntents(eventHandlers, additionalIntents = []) {
+    const intents = new Set([GatewayIntentBits.Guilds]);
+    for (const handler of eventHandlers) {
+        const event = handler.constructor.event;
+        if (!event)
+            continue;
+        const required = EVENT_INTENT_MAP[event];
+        if (required) {
+            for (const intent of required)
+                intents.add(intent);
+        }
+    }
+    for (const name of additionalIntents) {
+        const intent = GatewayIntentBits[name];
+        if (intent !== undefined)
+            intents.add(intent);
+    }
+    return [...intents];
+}
+export function derivePartials(intents, additionalPartials = []) {
+    const partials = new Set();
+    for (const intent of intents) {
+        const required = INTENT_PARTIAL_MAP[intent];
+        if (required) {
+            for (const partial of required)
+                partials.add(partial);
+        }
+    }
+    for (const name of additionalPartials) {
+        const partial = Partials[name];
+        if (partial !== undefined)
+            partials.add(partial);
+    }
+    return [...partials];
+}
+export { EVENT_INTENT_MAP, INTENT_PARTIAL_MAP };

package/dist/main.d.ts

@@ -0,0 +1,6 @@
+export default class Discord {
+    static instance: Discord | null;
+    constructor();
+    init(): Promise<void>;
+    reset(): void;
+}

package/dist/main.js

@@ -0,0 +1,15 @@
+export default class Discord {
+    static instance;
+    constructor() {
+        if (Discord.instance)
+            return Discord.instance;
+        Discord.instance = this;
+    }
+    async init() {
+        // Bot initialization is deferred to DiscordBot.init()
+        // This entry point satisfies Stonyx module auto-initialization
+    }
+    reset() {
+        Discord.instance = null;
+    }
+}

package/dist/message.d.ts

@@ -0,0 +1 @@
+export declare function chunkMessage(header: string, body: string): string[];

package/dist/message.js

@@ -0,0 +1,25 @@
+const MAX_LENGTH = 2000;
+function splitAtBoundary(text, max) {
+    if (text.length <= max)
+        return [text, ''];
+    const region = text.slice(0, max);
+    const newlineIdx = region.lastIndexOf('\n');
+    if (newlineIdx > 0)
+        return [text.slice(0, newlineIdx + 1), text.slice(newlineIdx + 1)];
+    const spaceIdx = region.lastIndexOf(' ');
+    if (spaceIdx > 0)
+        return [text.slice(0, spaceIdx + 1), text.slice(spaceIdx + 1)];
+    return [text.slice(0, max), text.slice(max)];
+}
+export function chunkMessage(header, body) {
+    const chunks = [];
+    const firstChunkMax = MAX_LENGTH - header.length;
+    let [first, remaining] = splitAtBoundary(body, firstChunkMax);
+    chunks.push(header + first);
+    while (remaining.length > 0) {
+        let chunk;
+        [chunk, remaining] = splitAtBoundary(remaining, MAX_LENGTH);
+        chunks.push(chunk);
+    }
+    return chunks;
+}

package/package.json

@@ -4,23 +4,42 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.1.1-beta.12",
+  "version": "0.1.1-beta.13",
   "description": "Discord bot module for the Stonyx framework",
-  "main": "src/main.js",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
   "type": "module",
   "files": [
-    "src",
+    "dist",
     "config",
     "LICENSE.md",
     "README.md"
   ],
   "exports": {
-    ".": "./src/main.js",
-    "./bot": "./src/bot.js",
-    "./command": "./src/command.js",
-    "./event-handler": "./src/event-handler.js",
-    "./message": "./src/message.js",
-    "./base": "./src/base.js"
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    },
+    "./bot": {
+      "types": "./dist/bot.d.ts",
+      "default": "./dist/bot.js"
+    },
+    "./command": {
+      "types": "./dist/command.d.ts",
+      "default": "./dist/command.js"
+    },
+    "./event-handler": {
+      "types": "./dist/event-handler.d.ts",
+      "default": "./dist/event-handler.js"
+    },
+    "./message": {
+      "types": "./dist/message.d.ts",
+      "default": "./dist/message.js"
+    },
+    "./base": {
+      "types": "./dist/base.d.ts",
+      "default": "./dist/base.js"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -46,11 +65,15 @@
   },
   "devDependencies": {
     "@stonyx/utils": "0.2.3-beta.7",
+    "@types/node": "^25.5.2",
     "qunit": "^2.24.1",
     "sinon": "^21.0.0",
-    "stonyx": "0.2.3-beta.12"
+    "stonyx": "0.2.3-beta.12",
+    "typescript": "^5.8.3"
   },
   "scripts": {
-    "test": "stonyx test"
+    "build": "tsc",
+    "build:test": "tsc -p tsconfig.test.json",
+    "test": "pnpm build && pnpm build:test && stonyx test 'dist-test/test/**/*-test.js'"
   }
 }

package/src/bot.js

@@ -1,214 +0,0 @@
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-import { Client, GatewayIntentBits, AttachmentBuilder, MessageFlags } from 'discord.js';
-import { forEachFileImport } from '@stonyx/utils/file';
-import { deriveIntents, derivePartials } from './intents.js';
-import { chunkMessage } from './message.js';
-
-export default class DiscordBot {
-  commands = {};
-  eventHandlers = [];
-  ready = new Promise(resolve => { this.resolveReady = resolve; });
-
-  constructor() {
-    if (DiscordBot.instance) return DiscordBot.instance;
-    DiscordBot.instance = this;
-  }
-
-  async init() {
-    const { token } = config.discord;
-
-    if (!token) {
-      log.discord('No DISCORD_TOKEN configured — bot will not start');
-      this.resolveReady();
-      return;
-    }
-
-    await this.discoverCommands();
-    await this.discoverEvents();
-
-    const hasWork = Object.keys(this.commands).length > 0 || this.eventHandlers.length > 0;
-
-    if (!hasWork) {
-      log.discord('No discord commands or event handlers found — skipping bot initialization');
-      this.resolveReady();
-      return;
-    }
-
-    const intents = deriveIntents(this.eventHandlers, config.discord.additionalIntents);
-    const partials = derivePartials(intents, config.discord.additionalPartials);
-
-    if (Object.keys(this.commands).length > 0) {
-      intents.push(GatewayIntentBits.Guilds);
-    }
-
-    this.client = new Client({ intents: [...new Set(intents)], partials });
-    this.registerClientEvents();
-    this.client.login(token);
-
-    await this.ready;
-  }
-
-  registerClientEvents() {
-    const { client } = this;
-
-    client.on('clientReady', () => {
-      this.resolveReady();
-      log.discord('Discord Bot is Ready!');
-    });
-
-    client.on('interactionCreate', async interaction => {
-      if (!interaction.isChatInputCommand()) return;
-
-      const { commandName } = interaction;
-      const command = this.commands[commandName];
-
-      if (!command) {
-        return await interaction.reply({ content: `\`/${commandName}\` is not available`, flags: MessageFlags.Ephemeral });
-      }
-
-      try {
-        await command.execute(interaction);
-      } catch (error) {
-        log.error(error);
-        const reply = { content: 'There was an error executing this command!', flags: MessageFlags.Ephemeral };
-        if (interaction.replied || interaction.deferred) {
-          await interaction.followUp(reply);
-        } else {
-          await interaction.reply(reply);
-        }
-      }
-    });
-
-    for (const handler of this.eventHandlers) {
-      client.on(handler.constructor.event, (...args) => handler.handle(...args));
-    }
-  }
-
-  async discoverCommands() {
-    const { commandDir } = config.discord;
-
-    await forEachFileImport(commandDir, (CommandClass, { name }) => {
-      const instance = new CommandClass();
-
-      if (!instance.data || typeof instance.execute !== 'function') {
-        log.discord(`Command "${name}" is missing data or execute — skipping`);
-        return;
-      }
-
-      instance._bot = this;
-      this.commands[instance.data.name] = instance;
-      log.discord(`Loaded command: /${instance.data.name}`);
-    }, { ignoreAccessFailure: true });
-  }
-
-  async discoverEvents() {
-    const { eventDir } = config.discord;
-
-    await forEachFileImport(eventDir, (EventHandlerClass, { name }) => {
-      if (!EventHandlerClass.event) {
-        log.discord(`Event handler "${name}" is missing static event property — skipping`);
-        return;
-      }
-
-      const instance = new EventHandlerClass();
-      instance._bot = this;
-      this.eventHandlers.push(instance);
-      log.discord(`Loaded event handler: ${EventHandlerClass.event} (${name})`);
-    }, { ignoreAccessFailure: true });
-  }
-
-  async sendMessage(content, channelId, imagePath = null) {
-    const channel = await this.client.channels.fetch(channelId);
-    if (!channel) throw new Error('Invalid Channel ID');
-
-    const options = { content };
-    if (imagePath) {
-      options.files = [new AttachmentBuilder(imagePath)];
-    }
-    return await channel.send(options);
-  }
-
-  async sendFile(file, messageObject) {
-    return await messageObject.edit({
-      content: '',
-      files: [{
-        attachment: file,
-        name: file.split('/').pop()
-      }]
-    });
-  }
-
-  async reply(interaction, content) {
-    if (content.length <= 2000) {
-      if (interaction.deferred || interaction.replied) {
-        return await interaction.editReply({ content });
-      }
-      return await interaction.reply({ content });
-    }
-
-    const [first, ...rest] = chunkMessage('', content);
-
-    if (interaction.deferred || interaction.replied) {
-      await interaction.editReply({ content: first });
-    } else {
-      await interaction.reply({ content: first });
-    }
-
-    for (const chunk of rest) {
-      await interaction.followUp({ content: chunk });
-    }
-  }
-
-  async updateStatus(name, type = 0) {
-    await this.client.user.setPresence({
-      activities: [{ name, type }],
-      status: 'online'
-    });
-  }
-
-  async getChannelMessages(channelId, options = {}) {
-    const channel = await this.client.channels.fetch(channelId);
-    return await channel.messages.fetch({
-      limit: config.discord.maxMessagesPerRequest,
-      ...options
-    });
-  }
-
-  async getChannelMessage(channelId, messageId) {
-    const channel = await this.client.channels.fetch(channelId);
-    return await channel.messages.fetch(messageId);
-  }
-
-  async getGuild(guildId = config.discord.serverId) {
-    return await this.client.guilds.fetch(guildId);
-  }
-
-  async clearChannelMessages(channelId) {
-    const promises = [];
-    const messages = await this.getChannelMessages(channelId);
-    messages.forEach(message => promises.push(message.delete()));
-    return Promise.all(promises);
-  }
-
-  async giveRole(memberId, roleId) {
-    const guild = await this.getGuild();
-    const role = await guild.roles.fetch(roleId);
-    const member = await guild.members.fetch(memberId);
-    await member.roles.add(role);
-  }
-
-  close() {
-    if (this.client) {
-      this.client.destroy();
-      this.client = null;
-    }
-    DiscordBot.instance = null;
-  }
-
-  reset() {
-    this.close();
-    this.commands = {};
-    this.eventHandlers = [];
-  }
-}

package/src/intents.js

@@ -1,56 +0,0 @@
-import { GatewayIntentBits, Partials } from 'discord.js';
-
-const EVENT_INTENT_MAP = {
-  messageCreate:      [GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
-  messageDelete:      [GatewayIntentBits.GuildMessages],
-  messageUpdate:      [GatewayIntentBits.GuildMessages],
-  guildMemberAdd:     [GatewayIntentBits.GuildMembers],
-  guildMemberRemove:  [GatewayIntentBits.GuildMembers],
-  inviteCreate:       [GatewayIntentBits.GuildInvites],
-  inviteDelete:       [GatewayIntentBits.GuildInvites],
-  voiceStateUpdate:   [GatewayIntentBits.GuildVoiceStates],
-  interactionCreate:  [],
-};
-
-const INTENT_PARTIAL_MAP = {
-  [GatewayIntentBits.DirectMessages]: [Partials.Channel],
-};
-
-export function deriveIntents(eventHandlers, additionalIntents = []) {
-  const intents = new Set([GatewayIntentBits.Guilds]);
-
-  for (const handler of eventHandlers) {
-    const event = handler.constructor.event;
-    const required = EVENT_INTENT_MAP[event];
-    if (required) {
-      for (const intent of required) intents.add(intent);
-    }
-  }
-
-  for (const name of additionalIntents) {
-    const intent = GatewayIntentBits[name];
-    if (intent !== undefined) intents.add(intent);
-  }
-
-  return [...intents];
-}
-
-export function derivePartials(intents, additionalPartials = []) {
-  const partials = new Set();
-
-  for (const intent of intents) {
-    const required = INTENT_PARTIAL_MAP[intent];
-    if (required) {
-      for (const partial of required) partials.add(partial);
-    }
-  }
-
-  for (const name of additionalPartials) {
-    const partial = Partials[name];
-    if (partial !== undefined) partials.add(partial);
-  }
-
-  return [...partials];
-}
-
-export { EVENT_INTENT_MAP, INTENT_PARTIAL_MAP };

package/src/main.js

@@ -1,15 +0,0 @@
-export default class Discord {
-  constructor() {
-    if (Discord.instance) return Discord.instance;
-    Discord.instance = this;
-  }
-
-  async init() {
-    // Bot initialization is deferred to DiscordBot.init()
-    // This entry point satisfies Stonyx module auto-initialization
-  }
-
-  reset() {
-    Discord.instance = null;
-  }
-}

package/src/message.js

@@ -1,30 +0,0 @@
-const MAX_LENGTH = 2000;
-
-function splitAtBoundary(text, max) {
-  if (text.length <= max) return [text, ''];
-
-  const region = text.slice(0, max);
-  const newlineIdx = region.lastIndexOf('\n');
-  if (newlineIdx > 0) return [text.slice(0, newlineIdx + 1), text.slice(newlineIdx + 1)];
-
-  const spaceIdx = region.lastIndexOf(' ');
-  if (spaceIdx > 0) return [text.slice(0, spaceIdx + 1), text.slice(spaceIdx + 1)];
-
-  return [text.slice(0, max), text.slice(max)];
-}
-
-export function chunkMessage(header, body) {
-  const chunks = [];
-  const firstChunkMax = MAX_LENGTH - header.length;
-
-  let [first, remaining] = splitAtBoundary(body, firstChunkMax);
-  chunks.push(header + first);
-
-  while (remaining.length > 0) {
-    let chunk;
-    [chunk, remaining] = splitAtBoundary(remaining, MAX_LENGTH);
-    chunks.push(chunk);
-  }
-
-  return chunks;
-}