@fluxerjs/core 1.0.6 → 1.0.8

package/dist/index.mjs

@@ -1,30 +1,36 @@
 import {
-  Message
-} from "./chunk-3CNUPFDI.mjs";
+  ClientUser,
+  User
+} from "./chunk-4GCZFOS5.mjs";
 import {
   Webhook
-} from "./chunk-BUEXP5SZ.mjs";
+} from "./chunk-ZGMM6IPQ.mjs";
 import {
-  Guild
-} from "./chunk-7GZN6JXT.mjs";
+  Message
+} from "./chunk-CO5EL5LH.mjs";
 import {
   CategoryChannel,
   Channel,
+  DMChannel,
   GuildChannel,
   LinkChannel,
+  MessageManager,
   TextChannel,
   VoiceChannel
-} from "./chunk-OHIHIQAS.mjs";
+} from "./chunk-CZIO2D7F.mjs";
+import {
+  Guild
+} from "./chunk-TJVZEILY.mjs";
+import "./chunk-HQMYRYMY.mjs";
 import {
   GuildMember
-} from "./chunk-TE5IC7IP.mjs";
+} from "./chunk-JVEOQFUX.mjs";
 import {
-  ClientUser
-} from "./chunk-6CEMF2LO.mjs";
+  Role
+} from "./chunk-SQVCCSNN.mjs";
 import {
-  User
-} from "./chunk-P4IRDGB4.mjs";
-import "./chunk-HQMYRYMY.mjs";
+  MessageReaction
+} from "./chunk-HBF5QEDH.mjs";
 import {
   Base
 } from "./chunk-XNS4O6QJ.mjs";
@@ -33,8 +39,120 @@ import {
 import { EventEmitter } from "events";
 import { REST } from "@fluxerjs/rest";
 import { WebSocketManager } from "@fluxerjs/ws";
-import { Routes } from "@fluxerjs/types";
+import { Routes as Routes3 } from "@fluxerjs/types";
+import { Collection as Collection3 } from "@fluxerjs/collection";
+
+// src/client/ChannelManager.ts
 import { Collection } from "@fluxerjs/collection";
+import { Routes } from "@fluxerjs/types";
+var ChannelManager = class extends Collection {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+  /**
+   * Fetch a channel by ID from the API (or return from cache if present).
+   * @param channelId - Snowflake of the channel
+   * @returns The channel, or null if not found
+   * @example
+   * const channel = await client.channels.fetch(channelId);
+   * if (channel?.isSendable()) await channel.send('Hello!');
+   */
+  async fetch(channelId) {
+    const cached = this.get(channelId);
+    if (cached) return cached;
+    try {
+      const { Channel: Channel2 } = await import("./Channel-TWPDKW2P.mjs");
+      const data = await this.client.rest.get(
+        Routes.channel(channelId)
+      );
+      const channel = Channel2.fromOrCreate(this.client, data);
+      if (channel) this.set(channel.id, channel);
+      return channel;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch a message by ID from the API.
+   * @param channelId - Snowflake of the channel
+   * @param messageId - Snowflake of the message
+   * @returns The message, or null if not found
+   * @deprecated Use channel.messages.fetch(messageId). Prefer (await client.channels.fetch(channelId))?.messages?.fetch(messageId).
+   * @example
+   * const channel = await client.channels.fetch(channelId);
+   * const message = await channel?.messages?.fetch(messageId);
+   */
+  async fetchMessage(channelId, messageId) {
+    try {
+      const { Message: Message2 } = await import("./Message-G2QIKZQK.mjs");
+      const data = await this.client.rest.get(
+        Routes.channelMessage(channelId, messageId)
+      );
+      return new Message2(this.client, data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Send a message to a channel by ID. Works even when the channel is not cached.
+   * Skips the fetch when you only need to send.
+   * @param channelId - Snowflake of the channel (text channel or DM)
+   * @param payload - Text content or object with content and/or embeds
+   * @returns The created message
+   * @example
+   * await client.channels.send(logChannelId, 'User joined!');
+   * await client.channels.send(channelId, { embeds: [embed.toJSON()] });
+   */
+  async send(channelId, payload) {
+    const body = typeof payload === "string" ? { content: payload } : payload;
+    const { Message: Message2 } = await import("./Message-G2QIKZQK.mjs");
+    const data = await this.client.rest.post(Routes.channelMessages(channelId), { body });
+    return new Message2(this.client, data);
+  }
+};
+
+// src/client/GuildManager.ts
+import { Collection as Collection2 } from "@fluxerjs/collection";
+import { Routes as Routes2 } from "@fluxerjs/types";
+var GuildManager = class extends Collection2 {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+  /**
+   * Fetch a guild by ID from the API (or return from cache if present).
+   * @param guildId - Snowflake of the guild
+   * @returns The guild, or null if not found
+   * @example
+   * const guild = await client.guilds.fetch(guildId);
+   * if (guild) console.log(guild.name);
+   */
+  async fetch(guildId) {
+    const cached = this.get(guildId);
+    if (cached) return cached;
+    try {
+      const { Guild: Guild2 } = await import("./Guild-CMZGA6DW.mjs");
+      const data = await this.client.rest.get(
+        Routes2.guild(guildId)
+      );
+      const guild = new Guild2(this.client, data);
+      this.set(guild.id, guild);
+      return guild;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/errors/FluxerError.ts
+var FluxerError = class _FluxerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FluxerError";
+    Object.setPrototypeOf(this, _FluxerError.prototype);
+  }
+};
 
 // src/util/Events.ts
 var Events = {
@@ -42,6 +160,7 @@ var Events = {
   MessageCreate: "messageCreate",
   MessageUpdate: "messageUpdate",
   MessageDelete: "messageDelete",
+  MessageDeleteBulk: "messageDeleteBulk",
   MessageReactionAdd: "messageReactionAdd",
   MessageReactionRemove: "messageReactionRemove",
   MessageReactionRemoveAll: "messageReactionRemoveAll",
@@ -50,24 +169,284 @@ var Events = {
   GuildCreate: "guildCreate",
   GuildUpdate: "guildUpdate",
   GuildDelete: "guildDelete",
-  ChannelCreate: "channelCreate",
-  ChannelUpdate: "channelUpdate",
-  ChannelDelete: "channelDelete",
+  GuildBanAdd: "guildBanAdd",
+  GuildBanRemove: "guildBanRemove",
+  GuildEmojisUpdate: "guildEmojisUpdate",
+  GuildStickersUpdate: "guildStickersUpdate",
+  GuildIntegrationsUpdate: "guildIntegrationsUpdate",
   GuildMemberAdd: "guildMemberAdd",
   GuildMemberUpdate: "guildMemberUpdate",
   GuildMemberRemove: "guildMemberRemove",
+  GuildRoleCreate: "guildRoleCreate",
+  GuildRoleUpdate: "guildRoleUpdate",
+  GuildRoleDelete: "guildRoleDelete",
+  GuildScheduledEventCreate: "guildScheduledEventCreate",
+  GuildScheduledEventUpdate: "guildScheduledEventUpdate",
+  GuildScheduledEventDelete: "guildScheduledEventDelete",
+  ChannelCreate: "channelCreate",
+  ChannelUpdate: "channelUpdate",
+  ChannelDelete: "channelDelete",
+  ChannelPinsUpdate: "channelPinsUpdate",
+  InviteCreate: "inviteCreate",
+  InviteDelete: "inviteDelete",
+  TypingStart: "typingStart",
+  UserUpdate: "userUpdate",
+  PresenceUpdate: "presenceUpdate",
   VoiceStateUpdate: "voiceStateUpdate",
   VoiceServerUpdate: "voiceServerUpdate",
   VoiceStatesSync: "voiceStatesSync",
+  WebhooksUpdate: "webhooksUpdate",
+  Resumed: "resumed",
   Error: "error",
   Debug: "debug"
 };
 
+// src/client/Client.ts
+import { formatEmoji, parseEmoji } from "@fluxerjs/util";
+
+// src/client/EventHandlerRegistry.ts
+var handlers = /* @__PURE__ */ new Map();
+handlers.set("MESSAGE_CREATE", async (client, d) => {
+  const { Message: Message2 } = await import("./Message-G2QIKZQK.mjs");
+  client.emit(Events.MessageCreate, new Message2(client, d));
+});
+handlers.set("MESSAGE_UPDATE", async (client, d) => {
+  const { Message: Message2 } = await import("./Message-G2QIKZQK.mjs");
+  client.emit(Events.MessageUpdate, null, new Message2(client, d));
+});
+handlers.set("MESSAGE_DELETE", async (client, d) => {
+  const data = d;
+  const channel = client.channels.get(data.channel_id) ?? null;
+  client.emit(Events.MessageDelete, {
+    id: data.id,
+    channelId: data.channel_id,
+    channel
+  });
+});
+handlers.set("MESSAGE_REACTION_ADD", async (client, d) => {
+  const data = d;
+  const { MessageReaction: MessageReaction2 } = await import("./MessageReaction-XRPYZDSC.mjs");
+  const reaction = new MessageReaction2(client, data);
+  const user = client.getOrCreateUser({
+    id: data.user_id,
+    username: "Unknown",
+    discriminator: "0"
+  });
+  client.emit(Events.MessageReactionAdd, reaction, user);
+});
+handlers.set("MESSAGE_REACTION_REMOVE", async (client, d) => {
+  const data = d;
+  const { MessageReaction: MessageReaction2 } = await import("./MessageReaction-XRPYZDSC.mjs");
+  const reaction = new MessageReaction2(client, data);
+  const user = client.getOrCreateUser({
+    id: data.user_id,
+    username: "Unknown",
+    discriminator: "0"
+  });
+  client.emit(Events.MessageReactionRemove, reaction, user);
+});
+handlers.set("MESSAGE_REACTION_REMOVE_ALL", async (client, d) => {
+  client.emit(Events.MessageReactionRemoveAll, d);
+});
+handlers.set("MESSAGE_REACTION_REMOVE_EMOJI", async (client, d) => {
+  client.emit(
+    Events.MessageReactionRemoveEmoji,
+    d
+  );
+});
+handlers.set("GUILD_CREATE", async (client, d) => {
+  const { Guild: Guild2 } = await import("./Guild-CMZGA6DW.mjs");
+  const { Channel: Channel2 } = await import("./Channel-TWPDKW2P.mjs");
+  const guild = new Guild2(client, d);
+  client.guilds.set(guild.id, guild);
+  const g = d;
+  for (const ch of g.channels ?? []) {
+    const channel = Channel2.from(client, ch);
+    if (channel) client.channels.set(channel.id, channel);
+  }
+  client.emit(Events.GuildCreate, guild);
+  if (g.voice_states?.length) {
+    client.emit(Events.VoiceStatesSync, { guildId: guild.id, voiceStates: g.voice_states });
+  }
+});
+handlers.set("GUILD_UPDATE", async (client, d) => {
+  const { Guild: Guild2 } = await import("./Guild-CMZGA6DW.mjs");
+  const g = d;
+  const old = client.guilds.get(g.id);
+  const updated = new Guild2(client, g);
+  client.guilds.set(updated.id, updated);
+  client.emit(Events.GuildUpdate, old ?? updated, updated);
+});
+handlers.set("GUILD_DELETE", async (client, d) => {
+  const g = d;
+  const guild = client.guilds.get(g.id);
+  if (guild) {
+    client.guilds.delete(g.id);
+    client.emit(Events.GuildDelete, guild);
+  }
+});
+handlers.set("CHANNEL_CREATE", async (client, d) => {
+  const { Channel: Channel2 } = await import("./Channel-TWPDKW2P.mjs");
+  const ch = Channel2.from(client, d);
+  if (ch) {
+    client.channels.set(ch.id, ch);
+    client.emit(Events.ChannelCreate, ch);
+  }
+});
+handlers.set("CHANNEL_UPDATE", async (client, d) => {
+  const { Channel: Channel2 } = await import("./Channel-TWPDKW2P.mjs");
+  const ch = d;
+  const oldCh = client.channels.get(ch.id);
+  const newCh = Channel2.from(client, ch);
+  if (newCh) {
+    client.channels.set(newCh.id, newCh);
+    client.emit(Events.ChannelUpdate, oldCh ?? newCh, newCh);
+  }
+});
+handlers.set("CHANNEL_DELETE", async (client, d) => {
+  const ch = d;
+  const channel = client.channels.get(ch.id);
+  if (channel) {
+    client.channels.delete(ch.id);
+    client.emit(Events.ChannelDelete, channel);
+  }
+});
+handlers.set("GUILD_MEMBER_ADD", async (client, d) => {
+  const { GuildMember: GuildMember2 } = await import("./GuildMember-DW2N6ITI.mjs");
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const member = new GuildMember2(client, data, guild);
+    guild.members.set(member.id, member);
+    client.emit(Events.GuildMemberAdd, member);
+  }
+});
+handlers.set("GUILD_MEMBER_UPDATE", async (client, d) => {
+  const { GuildMember: GuildMember2 } = await import("./GuildMember-DW2N6ITI.mjs");
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const oldM = guild.members.get(data.user.id);
+    const newM = new GuildMember2(client, data, guild);
+    guild.members.set(newM.id, newM);
+    client.emit(Events.GuildMemberUpdate, oldM ?? newM, newM);
+  }
+});
+handlers.set("GUILD_MEMBER_REMOVE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const member = guild.members.get(data.user.id);
+    if (member) {
+      guild.members.delete(data.user.id);
+      client.emit(Events.GuildMemberRemove, member);
+    }
+  }
+});
+handlers.set("INTERACTION_CREATE", async (client, d) => {
+  client.emit(Events.InteractionCreate, d);
+});
+handlers.set("VOICE_STATE_UPDATE", async (client, d) => {
+  client.emit(Events.VoiceStateUpdate, d);
+});
+handlers.set("VOICE_SERVER_UPDATE", async (client, d) => {
+  client.emit(Events.VoiceServerUpdate, d);
+});
+handlers.set("MESSAGE_DELETE_BULK", async (client, d) => {
+  client.emit(Events.MessageDeleteBulk, d);
+});
+handlers.set("GUILD_BAN_ADD", async (client, d) => {
+  client.emit(Events.GuildBanAdd, d);
+});
+handlers.set("GUILD_BAN_REMOVE", async (client, d) => {
+  client.emit(Events.GuildBanRemove, d);
+});
+handlers.set("GUILD_EMOJIS_UPDATE", async (client, d) => {
+  client.emit(Events.GuildEmojisUpdate, d);
+});
+handlers.set("GUILD_STICKERS_UPDATE", async (client, d) => {
+  client.emit(Events.GuildStickersUpdate, d);
+});
+handlers.set("GUILD_INTEGRATIONS_UPDATE", async (client, d) => {
+  client.emit(Events.GuildIntegrationsUpdate, d);
+});
+handlers.set("GUILD_ROLE_CREATE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const { Role: Role2 } = await import("./Role-SVLWIAMN.mjs");
+    guild.roles.set(data.role.id, new Role2(client, data.role, guild.id));
+  }
+  client.emit(Events.GuildRoleCreate, data);
+});
+handlers.set("GUILD_ROLE_UPDATE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const { Role: Role2 } = await import("./Role-SVLWIAMN.mjs");
+    guild.roles.set(data.role.id, new Role2(client, data.role, guild.id));
+  }
+  client.emit(Events.GuildRoleUpdate, data);
+});
+handlers.set("GUILD_ROLE_DELETE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) guild.roles.delete(data.role_id);
+  client.emit(Events.GuildRoleDelete, data);
+});
+handlers.set("GUILD_SCHEDULED_EVENT_CREATE", async (client, d) => {
+  client.emit(Events.GuildScheduledEventCreate, d);
+});
+handlers.set("GUILD_SCHEDULED_EVENT_UPDATE", async (client, d) => {
+  client.emit(Events.GuildScheduledEventUpdate, d);
+});
+handlers.set("GUILD_SCHEDULED_EVENT_DELETE", async (client, d) => {
+  client.emit(Events.GuildScheduledEventDelete, d);
+});
+handlers.set("CHANNEL_PINS_UPDATE", async (client, d) => {
+  client.emit(Events.ChannelPinsUpdate, d);
+});
+handlers.set("INVITE_CREATE", async (client, d) => {
+  client.emit(Events.InviteCreate, d);
+});
+handlers.set("INVITE_DELETE", async (client, d) => {
+  client.emit(Events.InviteDelete, d);
+});
+handlers.set("TYPING_START", async (client, d) => {
+  client.emit(Events.TypingStart, d);
+});
+handlers.set("USER_UPDATE", async (client, d) => {
+  const data = d;
+  if (client.user?.id === data.id) {
+    client.user._patch(data);
+  }
+  client.emit(Events.UserUpdate, data);
+});
+handlers.set("PRESENCE_UPDATE", async (client, d) => {
+  client.emit(Events.PresenceUpdate, d);
+});
+handlers.set("WEBHOOKS_UPDATE", async (client, d) => {
+  client.emit(Events.WebhooksUpdate, d);
+});
+handlers.set("RESUMED", async (client) => {
+  client.emit(Events.Resumed);
+});
+var eventHandlers = handlers;
+
 // src/client/Client.ts
 var Client = class extends EventEmitter {
+  /** @param options - Token, REST config, WebSocket, presence, etc. */
   constructor(options = {}) {
     super();
     this.options = options;
+    Object.defineProperty(this.channels, "cache", {
+      get: () => this.channels,
+      configurable: true
+    });
+    Object.defineProperty(this.guilds, "cache", {
+      get: () => this.guilds,
+      configurable: true
+    });
     this.rest = new REST({
       api: options.rest?.api ?? "https://api.fluxer.app",
       version: options.rest?.version ?? "1",
@@ -75,17 +454,87 @@ var Client = class extends EventEmitter {
     });
   }
   rest;
-  guilds = new Collection();
-  channels = new Collection();
-  users = new Collection();
+  guilds = new GuildManager(this);
+  channels = new ChannelManager(this);
+  users = new Collection3();
   user = null;
   readyAt = null;
   _ws = null;
+  /**
+   * Resolve an emoji argument to the API format (unicode or "name:id").
+   * Supports: <:name:id>, :name:, name:id, { name, id }, unicode.
+   * When id is missing (e.g. :name:), fetches guild emojis if guildId provided.
+   * @param emoji - Emoji string or object
+   * @param guildId - Guild ID for resolving custom emoji by name (required when id is missing)
+   * @returns API-formatted string for reactions
+   */
+  async resolveEmoji(emoji, guildId) {
+    if (typeof emoji === "object" && emoji.id) {
+      return formatEmoji({ name: emoji.name, id: emoji.id, animated: emoji.animated });
+    }
+    const parsed = parseEmoji(typeof emoji === "string" ? emoji : `:${emoji.name}:`);
+    if (!parsed) throw new Error("Invalid emoji");
+    if (parsed.id) return formatEmoji(parsed);
+    if (guildId) {
+      const emojis = await this.rest.get(Routes3.guildEmojis(guildId));
+      const list = Array.isArray(emojis) ? emojis : Object.values(emojis ?? {});
+      const found = list.find((e) => e.name && e.name.toLowerCase() === parsed.name.toLowerCase());
+      if (found) return formatEmoji({ ...parsed, id: found.id, animated: found.animated });
+      throw new Error(
+        `Custom emoji ":${parsed.name}:" not found in guild. Use name:id or <:name:id> format.`
+      );
+    }
+    if (/^\w+$/.test(parsed.name)) {
+      throw new Error(
+        `Custom emoji ":${parsed.name}:" requires guild context. Use message.react() in a guild channel, or pass guildId to client.resolveEmoji().`
+      );
+    }
+    return encodeURIComponent(parsed.name);
+  }
+  /**
+   * Fetch a message by channel and message ID. Use when you have IDs (e.g. from a DB).
+   * @param channelId - Snowflake of the channel
+   * @param messageId - Snowflake of the message
+   * @returns The message, or null if not found
+   * @deprecated Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.fetch(channelId))?.messages?.fetch(messageId)
+   * @example
+   * const channel = await client.channels.fetch(channelId);
+   * const message = await channel?.messages?.fetch(messageId);
+   */
+  async fetchMessage(channelId, messageId) {
+    return this.channels.fetchMessage(channelId, messageId);
+  }
+  /**
+   * Send a message to any channel by ID. Shorthand for client.channels.send().
+   * Works even when the channel is not cached.
+   */
+  async sendToChannel(channelId, payload) {
+    return this.channels.send(channelId, payload);
+  }
+  /**
+   * Get or create a User from API data. Caches in client.users.
+   * Updates existing user's username, avatar, etc. when fresh data is provided.
+   */
+  getOrCreateUser(data) {
+    const existing = this.users.get(data.id);
+    if (existing) {
+      existing._patch(data);
+      return existing;
+    }
+    const user = new User(this, data);
+    this.users.set(user.id, user);
+    return user;
+  }
+  /** WebSocket manager. Throws if not logged in. */
   get ws() {
     if (!this._ws) throw new Error("Client is not logged in");
     return this._ws;
   }
-  /** Send a payload to the gateway (e.g. Voice State Update). Uses shard 0 when single-shard. */
+  /**
+   * Send a payload to the gateway (e.g. Voice State Update).
+   * @param shardId - Shard ID (use 0 for single-shard)
+   * @param payload - Gateway payload to send
+   */
   sendToGateway(shardId, payload) {
     this.ws.send(shardId, payload);
   }
@@ -93,158 +542,27 @@ var Client = class extends EventEmitter {
     if (payload.op !== 0 || !payload.t) return;
     const { t: event, d } = payload;
     try {
-      switch (event) {
-        case "MESSAGE_CREATE": {
-          const { Message: Message2 } = await import("./Message-33APPS76.mjs");
-          this.emit(Events.MessageCreate, new Message2(this, d));
-          break;
-        }
-        case "MESSAGE_UPDATE": {
-          const { Message: Message2 } = await import("./Message-33APPS76.mjs");
-          this.emit(Events.MessageUpdate, null, new Message2(this, d));
-          break;
-        }
-        case "MESSAGE_DELETE":
-          this.emit(Events.MessageDelete, { id: d.id, channelId: d.channel_id });
-          break;
-        case "MESSAGE_REACTION_ADD":
-          this.emit(Events.MessageReactionAdd, d);
-          break;
-        case "MESSAGE_REACTION_REMOVE":
-          this.emit(Events.MessageReactionRemove, d);
-          break;
-        case "MESSAGE_REACTION_REMOVE_ALL":
-          this.emit(Events.MessageReactionRemoveAll, d);
-          break;
-        case "MESSAGE_REACTION_REMOVE_EMOJI":
-          this.emit(Events.MessageReactionRemoveEmoji, d);
-          break;
-        case "GUILD_CREATE": {
-          const { Guild: Guild2 } = await import("./Guild-NHNQ5TIA.mjs");
-          const { Channel: Channel2 } = await import("./Channel-IKL3SJXN.mjs");
-          const guild = new Guild2(this, d);
-          this.guilds.set(guild.id, guild);
-          const g = d;
-          for (const ch of g.channels ?? []) {
-            const channel = Channel2.from(this, ch);
-            if (channel) this.channels.set(channel.id, channel);
-          }
-          this.emit(Events.GuildCreate, guild);
-          if (g.voice_states?.length) {
-            this.emit(Events.VoiceStatesSync, { guildId: guild.id, voiceStates: g.voice_states });
-          }
-          break;
-        }
-        case "GUILD_UPDATE": {
-          const { Guild: Guild2 } = await import("./Guild-NHNQ5TIA.mjs");
-          const g = d;
-          const old = this.guilds.get(g.id);
-          const updated = new Guild2(this, g);
-          this.guilds.set(updated.id, updated);
-          this.emit(Events.GuildUpdate, old ?? updated, updated);
-          break;
-        }
-        case "GUILD_DELETE": {
-          const g = d;
-          const guild = this.guilds.get(g.id);
-          if (guild) {
-            this.guilds.delete(g.id);
-            this.emit(Events.GuildDelete, guild);
-          }
-          break;
-        }
-        case "CHANNEL_CREATE": {
-          const { Channel: Channel2 } = await import("./Channel-IKL3SJXN.mjs");
-          const ch = Channel2.from(this, d);
-          if (ch) {
-            this.channels.set(ch.id, ch);
-            this.emit(Events.ChannelCreate, ch);
-          }
-          break;
-        }
-        case "CHANNEL_UPDATE": {
-          const { Channel: Channel2 } = await import("./Channel-IKL3SJXN.mjs");
-          const ch = d;
-          const oldCh = this.channels.get(ch.id);
-          const newCh = Channel2.from(this, ch);
-          if (newCh) {
-            this.channels.set(newCh.id, newCh);
-            this.emit(Events.ChannelUpdate, oldCh ?? newCh, newCh);
-          }
-          break;
-        }
-        case "CHANNEL_DELETE": {
-          const ch = d;
-          const channel = this.channels.get(ch.id);
-          if (channel) {
-            this.channels.delete(ch.id);
-            this.emit(Events.ChannelDelete, channel);
-          }
-          break;
-        }
-        case "GUILD_MEMBER_ADD": {
-          const { GuildMember: GuildMember2 } = await import("./GuildMember-RGVPVUAG.mjs");
-          const data = d;
-          const guild = this.guilds.get(data.guild_id);
-          if (guild) {
-            const member = new GuildMember2(this, data, guild);
-            guild.members.set(member.id, member);
-            this.emit(Events.GuildMemberAdd, member);
-          }
-          break;
-        }
-        case "GUILD_MEMBER_UPDATE": {
-          const { GuildMember: GuildMember2 } = await import("./GuildMember-RGVPVUAG.mjs");
-          const data = d;
-          const guild = this.guilds.get(data.guild_id);
-          if (guild) {
-            const oldM = guild.members.get(data.user.id);
-            const newM = new GuildMember2(this, data, guild);
-            guild.members.set(newM.id, newM);
-            this.emit(Events.GuildMemberUpdate, oldM ?? newM, newM);
-          }
-          break;
-        }
-        case "GUILD_MEMBER_REMOVE": {
-          const data = d;
-          const guild = this.guilds.get(data.guild_id);
-          if (guild) {
-            const member = guild.members.get(data.user.id);
-            if (member) {
-              guild.members.delete(data.user.id);
-              this.emit(Events.GuildMemberRemove, member);
-            }
-          }
-          break;
-        }
-        case "INTERACTION_CREATE": {
-          this.emit(Events.InteractionCreate, d);
-          break;
-        }
-        case "VOICE_STATE_UPDATE": {
-          this.emit(Events.VoiceStateUpdate, d);
-          break;
-        }
-        case "VOICE_SERVER_UPDATE": {
-          this.emit(Events.VoiceServerUpdate, d);
-          break;
-        }
-        default:
-          break;
-      }
+      const handler = eventHandlers.get(event);
+      if (handler) await handler(this, d);
     } catch (err) {
       this.emit(Events.Error, err instanceof Error ? err : new Error(String(err)));
     }
   }
+  /**
+   * Connect to the Fluxer gateway and authenticate.
+   * @param token - Bot token (e.g. from FLUXER_BOT_TOKEN)
+   */
   async login(token) {
+    if (this._ws) {
+      throw new FluxerError("Client is already logged in. Call destroy() first.");
+    }
     this.rest.setToken(token);
     let intents = this.options.intents ?? 0;
     if (intents !== 0) {
       if (typeof process !== "undefined" && process.emitWarning) {
-        process.emitWarning(
-          "Fluxer does not support intents yet. Value has been set to 0.",
-          { type: "FluxerIntents" }
-        );
+        process.emitWarning("Fluxer does not support intents yet. Value has been set to 0.", {
+          type: "FluxerIntents"
+        });
       } else {
         console.warn("Fluxer does not support intents yet. Value has been set to 0.");
       }
@@ -259,33 +577,44 @@ var Client = class extends EventEmitter {
       WebSocket: this.options.WebSocket
     });
     this._ws.on("dispatch", ({ payload }) => {
-      this.handleDispatch(payload);
+      this.handleDispatch(payload).catch(
+        (err) => this.emit(Events.Error, err instanceof Error ? err : new Error(String(err)))
+      );
     });
-    this._ws.on("ready", async ({ data }) => {
-      const { ClientUser: ClientUser2 } = await import("./ClientUser-RNDKHQ3Z.mjs");
-      const { Guild: Guild2 } = await import("./Guild-NHNQ5TIA.mjs");
-      const { Channel: Channel2 } = await import("./Channel-IKL3SJXN.mjs");
-      this.user = new ClientUser2(this, data.user);
-      for (const g of data.guilds ?? []) {
-        const guild = new Guild2(this, g);
-        this.guilds.set(guild.id, guild);
-        const withCh = g;
-        for (const ch of withCh.channels ?? []) {
-          const channel = Channel2.from(this, ch);
-          if (channel) this.channels.set(channel.id, channel);
-        }
-        if (withCh.voice_states?.length) {
-          this.emit(Events.VoiceStatesSync, { guildId: guild.id, voiceStates: withCh.voice_states });
+    this._ws.on(
+      "ready",
+      async ({
+        data
+      }) => {
+        const { ClientUser: ClientUser2 } = await import("./ClientUser-2K2BACK7.mjs");
+        const { Guild: Guild2 } = await import("./Guild-CMZGA6DW.mjs");
+        const { Channel: Channel2 } = await import("./Channel-TWPDKW2P.mjs");
+        this.user = new ClientUser2(this, data.user);
+        for (const g of data.guilds ?? []) {
+          const guild = new Guild2(this, g);
+          this.guilds.set(guild.id, guild);
+          const withCh = g;
+          for (const ch of withCh.channels ?? []) {
+            const channel = Channel2.from(this, ch);
+            if (channel) this.channels.set(channel.id, channel);
+          }
+          if (withCh.voice_states?.length) {
+            this.emit(Events.VoiceStatesSync, {
+              guildId: guild.id,
+              voiceStates: withCh.voice_states
+            });
+          }
         }
+        this.readyAt = /* @__PURE__ */ new Date();
+        this.emit(Events.Ready);
       }
-      this.readyAt = /* @__PURE__ */ new Date();
-      this.emit(Events.Ready);
-    });
+    );
     this._ws.on("error", ({ error }) => this.emit(Events.Error, error));
     this._ws.on("debug", (msg) => this.emit(Events.Debug, msg));
     await this._ws.connect();
     return token;
   }
+  /** Disconnect from the gateway and clear cached data. */
   async destroy() {
     if (this._ws) {
       this._ws.destroy();
@@ -298,20 +627,12 @@ var Client = class extends EventEmitter {
     this.channels.clear();
     this.users.clear();
   }
+  /** Returns true if the client has received Ready and `user` is set. */
   isReady() {
     return this.readyAt !== null && this.user !== null;
   }
   static get Routes() {
-    return Routes;
-  }
-};
-
-// src/errors/FluxerError.ts
-var FluxerError = class _FluxerError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FluxerError";
-    Object.setPrototypeOf(this, _FluxerError.prototype);
+    return Routes3;
   }
 };
 
@@ -323,14 +644,16 @@ var ErrorCodes = {
 
 // src/index.ts
 import { EmbedBuilder, MessagePayload, AttachmentBuilder } from "@fluxerjs/builders";
-import { Routes as Routes2, GatewayOpcodes } from "@fluxerjs/types";
+import { Routes as Routes4, GatewayOpcodes } from "@fluxerjs/types";
 export {
   AttachmentBuilder,
   Base,
   CategoryChannel,
   Channel,
+  ChannelManager,
   Client,
   ClientUser,
+  DMChannel,
   EmbedBuilder,
   ErrorCodes,
   Events,
@@ -341,8 +664,11 @@ export {
   GuildMember,
   LinkChannel,
   Message,
+  MessageManager,
   MessagePayload,
-  Routes2 as Routes,
+  MessageReaction,
+  Role,
+  Routes4 as Routes,
   TextChannel,
   User,
   VoiceChannel,