@fluxerjs/core 1.0.6 → 1.0.8

package/dist/index.js

@@ -20,123 +20,34 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/structures/Base.ts
-var Base;
-var init_Base = __esm({
-  "src/structures/Base.ts"() {
-    "use strict";
-    Base = class {
-    };
-  }
-});
-
-// src/util/Constants.ts
-var CDN_URL;
-var init_Constants = __esm({
-  "src/util/Constants.ts"() {
-    "use strict";
-    CDN_URL = "https://fluxerusercontent.com";
-  }
-});
-
-// src/structures/User.ts
-var User;
-var init_User = __esm({
-  "src/structures/User.ts"() {
+// src/client/MessageManager.ts
+var MessageManager;
+var init_MessageManager = __esm({
+  "src/client/MessageManager.ts"() {
     "use strict";
-    init_Base();
-    init_Constants();
-    User = class extends Base {
-      client;
-      id;
-      username;
-      discriminator;
-      globalName;
-      avatar;
-      bot;
-      constructor(client, data) {
-        super();
+    MessageManager = class {
+      constructor(client, channelId) {
         this.client = client;
-        this.id = data.id;
-        this.username = data.username;
-        this.discriminator = data.discriminator;
-        this.globalName = data.global_name ?? null;
-        this.avatar = data.avatar ?? null;
-        this.bot = !!data.bot;
-      }
-      avatarURL(options) {
-        if (!this.avatar) return null;
-        const ext = options?.extension ?? "png";
-        const size = options?.size ? `?size=${options.size}` : "";
-        return `${CDN_URL}/avatars/${this.id}/${this.avatar}.${ext}${size}`;
-      }
-      displayAvatarURL(options) {
-        return this.avatarURL(options) ?? `${CDN_URL}/avatars/0/0.png`;
+        this.channelId = channelId;
       }
-      toString() {
-        return `<@${this.id}>`;
+      /**
+       * Fetch a message by ID from this channel.
+       * @param messageId - Snowflake of the message
+       * @returns The message, or null if not found
+       */
+      async fetch(messageId) {
+        return this.client.channels.fetchMessage(this.channelId, messageId);
       }
     };
   }
 });
 
-// src/structures/Message.ts
-var Message_exports = {};
-__export(Message_exports, {
-  Message: () => Message
-});
-var import_collection, import_types, import_builders, Message;
-var init_Message = __esm({
-  "src/structures/Message.ts"() {
+// src/structures/Base.ts
+var Base;
+var init_Base = __esm({
+  "src/structures/Base.ts"() {
     "use strict";
-    init_Base();
-    import_collection = require("@fluxerjs/collection");
-    import_types = require("@fluxerjs/types");
-    import_builders = require("@fluxerjs/builders");
-    init_User();
-    Message = class _Message extends Base {
-      client;
-      id;
-      channelId;
-      guildId;
-      author;
-      content;
-      createdAt;
-      editedAt;
-      pinned;
-      attachments;
-      channel;
-      constructor(client, data) {
-        super();
-        this.client = client;
-        this.id = data.id;
-        this.channelId = data.channel_id;
-        this.guildId = data.guild_id ?? null;
-        this.author = new User(client, data.author);
-        this.content = data.content;
-        this.createdAt = new Date(data.timestamp);
-        this.editedAt = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
-        this.pinned = data.pinned;
-        this.attachments = new import_collection.Collection();
-        for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
-      }
-      async reply(options) {
-        const body = typeof options === "string" ? { content: options, message_reference: { channel_id: this.channelId, message_id: this.id, guild_id: this.guildId ?? void 0 } } : { ...options, message_reference: { channel_id: this.channelId, message_id: this.id, guild_id: this.guildId ?? void 0 } };
-        const data = await this.client.rest.post(import_types.Routes.channelMessages(this.channelId), { body });
-        return new _Message(this.client, data);
-      }
-      async edit(options) {
-        const body = {};
-        if (options.content !== void 0) body.content = options.content;
-        if (options.embeds?.length) {
-          body.embeds = options.embeds.map((e) => e instanceof import_builders.EmbedBuilder ? e.toJSON() : e);
-        }
-        const data = await this.client.rest.patch(import_types.Routes.channelMessage(this.channelId, this.id), { body });
-        return new _Message(this.client, data);
-      }
-      async delete() {
-        await this.client.rest.delete(import_types.Routes.channelMessage(this.channelId, this.id));
-      }
+    Base = class {
     };
   }
 });
@@ -146,12 +57,12 @@ var Webhook_exports = {};
 __export(Webhook_exports, {
   Webhook: () => Webhook
 });
-var import_types2, Webhook;
+var import_types, Webhook;
 var init_Webhook = __esm({
   "src/structures/Webhook.ts"() {
     "use strict";
     init_Base();
-    import_types2 = require("@fluxerjs/types");
+    import_types = require("@fluxerjs/types");
     Webhook = class _Webhook extends Base {
       client;
       id;
@@ -161,6 +72,7 @@ var init_Webhook = __esm({
       avatar;
       /** Present only when webhook was created via createWebhook(); not returned when fetching. */
       token;
+      /** @param data - API webhook from POST /channels/{id}/webhooks (has token) or GET /webhooks/{id} (no token) */
       constructor(client, data) {
         super();
         this.client = client;
@@ -173,7 +85,7 @@ var init_Webhook = __esm({
       }
       /** Delete this webhook. Requires bot token with Manage Webhooks permission. */
       async delete() {
-        await this.client.rest.delete(import_types2.Routes.webhook(this.id), { auth: true });
+        await this.client.rest.delete(import_types.Routes.webhook(this.id), { auth: true });
       }
       /**
        * Send a message via this webhook. Requires the webhook token (only present when created, not when fetched).
@@ -181,24 +93,32 @@ var init_Webhook = __esm({
        */
       async send(options) {
         if (!this.token) {
-          throw new Error("Webhook token is required to send. The token is only returned when creating a webhook; fetched webhooks cannot send.");
+          throw new Error(
+            "Webhook token is required to send. The token is only returned when creating a webhook; fetched webhooks cannot send."
+          );
         }
         const body = typeof options === "string" ? { content: options } : options;
-        await this.client.rest.post(import_types2.Routes.webhookExecute(this.id, this.token), {
+        await this.client.rest.post(import_types.Routes.webhookExecute(this.id, this.token), {
           body,
           auth: false
         });
       }
       /**
-       * Fetch a webhook by ID using bot auth. The returned webhook will not have a token (cannot send).
+       * Fetch a webhook by ID using bot auth.
+       * @param client - The client instance
+       * @param webhookId - The webhook ID
+       * @returns Webhook without token (cannot send)
        */
       static async fetch(client, webhookId) {
-        const data = await client.rest.get(import_types2.Routes.webhook(webhookId));
+        const data = await client.rest.get(import_types.Routes.webhook(webhookId));
         return new _Webhook(client, data);
       }
       /**
        * Create a Webhook instance from an ID and token (e.g. from a stored webhook URL).
-       * Useful when you have the token from a previous createWebhook() call.
+       * @param client - The client instance
+       * @param webhookId - The webhook ID
+       * @param token - The webhook token (from createWebhook or stored)
+       * @param options - Optional channelId, guildId, name for display
        */
       static fromToken(client, webhookId, token, options) {
         return new _Webhook(client, {
@@ -215,53 +135,173 @@ var init_Webhook = __esm({
   }
 });
 
-// src/structures/Guild.ts
-var Guild_exports = {};
-__export(Guild_exports, {
-  Guild: () => Guild
+// src/structures/Message.ts
+var Message_exports = {};
+__export(Message_exports, {
+  Message: () => Message
 });
-var import_collection2, import_types3, Guild;
-var init_Guild = __esm({
-  "src/structures/Guild.ts"() {
+var import_collection, import_types2, import_builders, Message;
+var init_Message = __esm({
+  "src/structures/Message.ts"() {
     "use strict";
     init_Base();
-    import_collection2 = require("@fluxerjs/collection");
-    init_Constants();
-    import_types3 = require("@fluxerjs/types");
-    Guild = class extends Base {
+    import_collection = require("@fluxerjs/collection");
+    import_types2 = require("@fluxerjs/types");
+    import_builders = require("@fluxerjs/builders");
+    Message = class _Message extends Base {
       client;
       id;
-      name;
-      icon;
-      banner;
-      ownerId;
-      members = new import_collection2.Collection();
-      channels = new import_collection2.Collection();
+      channelId;
+      guildId;
+      author;
+      content;
+      createdAt;
+      editedAt;
+      pinned;
+      attachments;
+      /** Channel where this message was sent. Resolved from cache; null if not cached (e.g. DM channel not in cache). */
+      get channel() {
+        return this.client.channels.get(this.channelId) ?? null;
+      }
+      /** Guild where this message was sent. Resolved from cache; null for DMs or if not cached. */
+      get guild() {
+        return this.guildId ? this.client.guilds.get(this.guildId) ?? null : null;
+      }
+      /** @param data - API message from POST/PATCH /channels/{id}/messages or gateway MESSAGE_CREATE */
       constructor(client, data) {
         super();
         this.client = client;
         this.id = data.id;
-        this.name = data.name;
-        this.icon = data.icon ?? null;
-        this.banner = data.banner ?? null;
-        this.ownerId = data.owner_id;
+        this.channelId = data.channel_id;
+        this.guildId = data.guild_id ?? null;
+        this.author = client.getOrCreateUser(data.author);
+        this.content = data.content;
+        this.createdAt = new Date(data.timestamp);
+        this.editedAt = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
+        this.pinned = data.pinned;
+        this.attachments = new import_collection.Collection();
+        for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
       }
-      iconURL(options) {
-        if (!this.icon) return null;
-        const size = options?.size ? `?size=${options.size}` : "";
-        return `${CDN_URL}/icons/${this.id}/${this.icon}.png${size}`;
+      /**
+       * Send a message to this channel without replying. Use when you want a standalone message.
+       * @param options - Text content or object with content and/or embeds
+       * @example
+       * await message.send('Pong!');
+       * await message.send({ embeds: [embed.toJSON()] });
+       */
+      async send(options) {
+        const body = typeof options === "string" ? { content: options } : options;
+        const data = await this.client.rest.post(import_types2.Routes.channelMessages(this.channelId), { body });
+        return new _Message(this.client, data);
       }
-      bannerURL(options) {
-        if (!this.banner) return null;
-        const size = options?.size ? `?size=${options.size}` : "";
-        return `${CDN_URL}/banners/${this.id}/${this.banner}.png${size}`;
+      /**
+       * Send a message to a specific channel. Use for logging, forwarding, or sending to another channel in the guild.
+       * @param channelId - Snowflake of the target channel (e.g. log channel ID)
+       * @param options - Text content or object with content and/or embeds
+       * @example
+       * await message.sendTo(logChannelId, 'User ' + message.author.username + ' said: ' + message.content);
+       * await message.sendTo(announceChannelId, { embeds: [embed.toJSON()] });
+       */
+      async sendTo(channelId, options) {
+        return this.client.channels.send(channelId, options);
       }
-      /** Fetch all webhooks in this guild. Returned webhooks do not include the token (cannot send). */
-      async fetchWebhooks() {
-        const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.get(import_types3.Routes.guildWebhooks(this.id));
-        const list = Array.isArray(data) ? data : Object.values(data ?? {});
-        return list.map((w) => new Webhook2(this.client, w));
+      /**
+       * Reply to this message.
+       * @param options - Text content or object with content and/or embeds
+       */
+      async reply(options) {
+        const body = typeof options === "string" ? {
+          content: options,
+          message_reference: {
+            channel_id: this.channelId,
+            message_id: this.id,
+            guild_id: this.guildId ?? void 0
+          }
+        } : {
+          ...options,
+          message_reference: {
+            channel_id: this.channelId,
+            message_id: this.id,
+            guild_id: this.guildId ?? void 0
+          }
+        };
+        const data = await this.client.rest.post(import_types2.Routes.channelMessages(this.channelId), { body });
+        return new _Message(this.client, data);
+      }
+      /**
+       * Edit this message. Only the author (or admins) can edit.
+       * @param options - New content and/or embeds
+       */
+      async edit(options) {
+        const body = {};
+        if (options.content !== void 0) body.content = options.content;
+        if (options.embeds?.length) {
+          body.embeds = options.embeds.map((e) => e instanceof import_builders.EmbedBuilder ? e.toJSON() : e);
+        }
+        const data = await this.client.rest.patch(import_types2.Routes.channelMessage(this.channelId, this.id), {
+          body
+        });
+        return new _Message(this.client, data);
+      }
+      /**
+       * Re-fetch this message from the API to get the latest content, embeds, reactions, etc.
+       * Use when you have a stale Message (e.g. from an old event or cache) and need fresh data.
+       * @returns The updated message, or null if deleted or not found
+       * @example
+       * const updated = await message.fetch();
+       * if (updated) console.log('Latest content:', updated.content);
+       */
+      async fetch() {
+        return this.client.channels.fetchMessage(this.channelId, this.id);
+      }
+      /** Delete this message. */
+      async delete() {
+        await this.client.rest.delete(import_types2.Routes.channelMessage(this.channelId, this.id));
+      }
+      /**
+       * Format emoji for reaction API: unicode string or "name:id" for custom.
+       * For string resolution (e.g. :name:), use client.resolveEmoji; Message methods resolve automatically when guildId is available.
+       */
+      static formatEmoji(emoji) {
+        if (typeof emoji === "string") return emoji;
+        return `${emoji.name}:${emoji.id}`;
+      }
+      resolveEmojiForReaction(emoji) {
+        return this.client.resolveEmoji(emoji, this.guildId);
+      }
+      /**
+       * Add a reaction to this message (as the bot).
+       * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+       */
+      async react(emoji) {
+        const emojiStr = await this.resolveEmojiForReaction(emoji);
+        const route = `${import_types2.Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/@me`;
+        await this.client.rest.put(route);
+      }
+      /**
+       * Remove the bot's reaction, or a specific user's reaction if userId is provided.
+       * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+       * @param userId - If provided, removes that user's reaction (requires moderator permissions)
+       */
+      async removeReaction(emoji, userId) {
+        const emojiStr = await this.resolveEmojiForReaction(emoji);
+        const route = `${import_types2.Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/${userId ?? "@me"}`;
+        await this.client.rest.delete(route);
+      }
+      /**
+       * Remove all reactions from this message.
+       * Requires moderator permissions.
+       */
+      async removeAllReactions() {
+        await this.client.rest.delete(import_types2.Routes.channelMessageReactions(this.channelId, this.id));
+      }
+      /**
+       * Remove all reactions of a specific emoji from this message.
+       * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`. Requires moderator permissions.
+       */
+      async removeReactionEmoji(emoji) {
+        const emojiStr = await this.resolveEmojiForReaction(emoji);
+        await this.client.rest.delete(import_types2.Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
       }
     };
   }
@@ -272,35 +312,70 @@ var Channel_exports = {};
 __export(Channel_exports, {
   CategoryChannel: () => CategoryChannel,
   Channel: () => Channel,
+  DMChannel: () => DMChannel,
   GuildChannel: () => GuildChannel,
   LinkChannel: () => LinkChannel,
   TextChannel: () => TextChannel,
   VoiceChannel: () => VoiceChannel
 });
-var import_types4, Channel, GuildChannel, TextChannel, CategoryChannel, VoiceChannel, LinkChannel;
+var import_types3, Channel, GuildChannel, TextChannel, CategoryChannel, VoiceChannel, LinkChannel, DMChannel;
 var init_Channel = __esm({
   "src/structures/Channel.ts"() {
     "use strict";
+    init_MessageManager();
     init_Base();
-    import_types4 = require("@fluxerjs/types");
-    Channel = class extends Base {
+    import_types3 = require("@fluxerjs/types");
+    Channel = class _Channel extends Base {
+      /** Whether this channel has a send method (TextChannel, DMChannel). */
+      isSendable() {
+        return "send" in this;
+      }
+      /** Whether this channel is a DM or Group DM. */
+      isDM() {
+        return this.type === import_types3.ChannelType.DM || this.type === import_types3.ChannelType.GroupDM;
+      }
+      /** Whether this channel is voice-based (VoiceChannel). */
+      isVoice() {
+        return "bitrate" in this;
+      }
+      /** Create a DM channel from API data (type DM or GroupDM). */
+      static createDM(client, data) {
+        return new DMChannel(client, data);
+      }
       client;
       id;
       type;
+      /** @param data - API channel from GET /channels/{id} or GET /guilds/{id}/channels */
       constructor(client, data) {
         super();
         this.client = client;
         this.id = data.id;
         this.type = data.type;
       }
+      /**
+       * Create the appropriate channel subclass from API data.
+       * @param client - The client instance
+       * @param data - Channel data from the API
+       */
       static from(client, data) {
         const type = data.type ?? 0;
-        if (type === import_types4.ChannelType.GuildText) return new TextChannel(client, data);
-        if (type === import_types4.ChannelType.GuildCategory) return new CategoryChannel(client, data);
-        if (type === import_types4.ChannelType.GuildVoice) return new VoiceChannel(client, data);
-        if (type === import_types4.ChannelType.GuildLink) return new LinkChannel(client, data);
+        if (type === import_types3.ChannelType.GuildText) return new TextChannel(client, data);
+        if (type === import_types3.ChannelType.GuildCategory) return new CategoryChannel(client, data);
+        if (type === import_types3.ChannelType.GuildVoice) return new VoiceChannel(client, data);
+        if (type === import_types3.ChannelType.GuildLink || type === import_types3.ChannelType.GuildLinkExtended)
+          return new LinkChannel(client, data);
         return new GuildChannel(client, data);
       }
+      /**
+       * Create a channel from API data, including DM and GroupDM.
+       * Used by ChannelManager.fetch() for GET /channels/{id}.
+       */
+      static fromOrCreate(client, data) {
+        const type = data.type ?? 0;
+        if (type === import_types3.ChannelType.DM || type === import_types3.ChannelType.GroupDM)
+          return _Channel.createDM(client, data);
+        return _Channel.from(client, data);
+      }
     };
     GuildChannel = class extends Channel {
       guildId;
@@ -314,19 +389,26 @@ var init_Channel = __esm({
         this.position = data.position;
         this.parentId = data.parent_id ?? null;
       }
-      /** Create a webhook in this channel. Returns the webhook with token (required for send()). */
+      /**
+       * Create a webhook in this channel.
+       * @param options - Webhook name and optional avatar URL
+       * @returns The webhook with token (required for send()). Requires Manage Webhooks permission.
+       */
       async createWebhook(options) {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.post(import_types4.Routes.channelWebhooks(this.id), {
+        const data = await this.client.rest.post(import_types3.Routes.channelWebhooks(this.id), {
           body: options,
           auth: true
         });
         return new Webhook2(this.client, data);
       }
-      /** Fetch all webhooks in this channel. Returned webhooks do not include the token (cannot send). */
+      /**
+       * Fetch all webhooks in this channel.
+       * @returns Webhooks (includes token when listing from channel; can send via send())
+       */
       async fetchWebhooks() {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.get(import_types4.Routes.channelWebhooks(this.id));
+        const data = await this.client.rest.get(import_types3.Routes.channelWebhooks(this.id));
         const list = Array.isArray(data) ? data : Object.values(data ?? {});
         return list.map((w) => new Webhook2(this.client, w));
       }
@@ -343,12 +425,29 @@ var init_Channel = __esm({
         this.rateLimitPerUser = data.rate_limit_per_user ?? 0;
         this.lastMessageId = data.last_message_id ?? null;
       }
+      /**
+       * Send a message to this channel.
+       * @param options - Text content or object with `content` and/or `embeds`
+       */
       async send(options) {
         const body = typeof options === "string" ? { content: options } : options;
         const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-        const data = await this.client.rest.post(import_types4.Routes.channelMessages(this.id), { body });
+        const data = await this.client.rest.post(import_types3.Routes.channelMessages(this.id), { body });
         return new Message2(this.client, data);
       }
+      /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+      get messages() {
+        return new MessageManager(this.client, this.id);
+      }
+      /**
+       * Fetch a message by ID from this channel.
+       * @param messageId - Snowflake of the message
+       * @returns The message, or null if not found
+       * @deprecated Use channel.messages.fetch(messageId) instead.
+       */
+      async fetchMessage(messageId) {
+        return this.client.channels.fetchMessage(this.id, messageId);
+      }
     };
     CategoryChannel = class extends GuildChannel {
     };
@@ -370,6 +469,36 @@ var init_Channel = __esm({
         this.url = data.url ?? null;
       }
     };
+    DMChannel = class extends Channel {
+      lastMessageId;
+      constructor(client, data) {
+        super(client, data);
+        this.lastMessageId = data.last_message_id ?? null;
+      }
+      /**
+       * Send a message to this DM channel.
+       * @param options - Text content or object with `content` and/or `embeds`
+       */
+      async send(options) {
+        const body = typeof options === "string" ? { content: options } : options;
+        const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+        const data = await this.client.rest.post(import_types3.Routes.channelMessages(this.id), { body });
+        return new Message2(this.client, data);
+      }
+      /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+      get messages() {
+        return new MessageManager(this.client, this.id);
+      }
+      /**
+       * Fetch a message by ID from this DM channel.
+       * @param messageId - Snowflake of the message
+       * @returns The message, or null if not found
+       * @deprecated Use channel.messages.fetch(messageId) instead.
+       */
+      async fetchMessage(messageId) {
+        return this.client.channels.fetchMessage(this.id, messageId);
+      }
+    };
   }
 });
 
@@ -378,12 +507,12 @@ var GuildMember_exports = {};
 __export(GuildMember_exports, {
   GuildMember: () => GuildMember
 });
-var GuildMember;
+var import_types5, GuildMember;
 var init_GuildMember = __esm({
   "src/structures/GuildMember.ts"() {
     "use strict";
     init_Base();
-    init_User();
+    import_types5 = require("@fluxerjs/types");
     GuildMember = class extends Base {
       client;
       id;
@@ -393,10 +522,11 @@ var init_GuildMember = __esm({
       roles;
       joinedAt;
       communicationDisabledUntil;
+      /** @param data - API guild member from GET /guilds/{id}/members or GET /guilds/{id}/members/{user_id} */
       constructor(client, data, guild) {
         super();
         this.client = client;
-        this.user = new User(client, data.user);
+        this.user = client.getOrCreateUser(data.user);
         this.id = data.user.id;
         this.guild = guild;
         this.nick = data.nick ?? null;
@@ -404,14 +534,325 @@ var init_GuildMember = __esm({
         this.joinedAt = new Date(data.joined_at);
         this.communicationDisabledUntil = data.communication_disabled_until ? new Date(data.communication_disabled_until) : null;
       }
+      /** Nickname, or global name, or username. */
       get displayName() {
         return this.nick ?? this.user.globalName ?? this.user.username;
       }
-    };
-  }
-});
-
-// src/client/ClientUser.ts
+      /**
+       * Add a role to this member.
+       * @param roleId - The role ID to add
+       * Requires Manage Roles permission.
+       */
+      async addRole(roleId) {
+        await this.client.rest.put(import_types5.Routes.guildMemberRole(this.guild.id, this.id, roleId));
+      }
+      /**
+       * Remove a role from this member.
+       * @param roleId - The role ID to remove
+       * Requires Manage Roles permission.
+       */
+      async removeRole(roleId) {
+        await this.client.rest.delete(import_types5.Routes.guildMemberRole(this.guild.id, this.id, roleId));
+      }
+    };
+  }
+});
+
+// src/structures/Role.ts
+var Role_exports = {};
+__export(Role_exports, {
+  Role: () => Role
+});
+var Role;
+var init_Role = __esm({
+  "src/structures/Role.ts"() {
+    "use strict";
+    init_Base();
+    Role = class extends Base {
+      client;
+      id;
+      guildId;
+      name;
+      color;
+      position;
+      permissions;
+      hoist;
+      mentionable;
+      unicodeEmoji;
+      /** @param client - The client instance */
+      /** @param data - API role from GET /guilds/{id}/roles or gateway role events */
+      /** @param guildId - The guild this role belongs to */
+      constructor(client, data, guildId) {
+        super();
+        this.client = client;
+        this.id = data.id;
+        this.guildId = guildId;
+        this.name = data.name;
+        this.color = data.color;
+        this.position = data.position;
+        this.permissions = data.permissions;
+        this.hoist = !!data.hoist;
+        this.mentionable = !!data.mentionable;
+        this.unicodeEmoji = data.unicode_emoji ?? null;
+      }
+      /** Returns a mention string (e.g. `<@&123456>`). */
+      toString() {
+        return `<@&${this.id}>`;
+      }
+    };
+  }
+});
+
+// src/util/Constants.ts
+var CDN_URL;
+var init_Constants = __esm({
+  "src/util/Constants.ts"() {
+    "use strict";
+    CDN_URL = "https://fluxerusercontent.com";
+  }
+});
+
+// src/structures/Guild.ts
+var Guild_exports = {};
+__export(Guild_exports, {
+  Guild: () => Guild
+});
+var import_util, import_collection3, import_types6, Guild;
+var init_Guild = __esm({
+  "src/structures/Guild.ts"() {
+    "use strict";
+    import_util = require("@fluxerjs/util");
+    init_Base();
+    import_collection3 = require("@fluxerjs/collection");
+    init_GuildMember();
+    init_Role();
+    init_Constants();
+    import_types6 = require("@fluxerjs/types");
+    Guild = class extends Base {
+      client;
+      id;
+      name;
+      icon;
+      banner;
+      ownerId;
+      members = new import_collection3.Collection();
+      channels = new import_collection3.Collection();
+      roles = new import_collection3.Collection();
+      /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this.id = data.id;
+        this.name = data.name;
+        this.icon = data.icon ?? null;
+        this.banner = data.banner ?? null;
+        this.ownerId = data.owner_id;
+        for (const r of data.roles ?? []) {
+          this.roles.set(r.id, new Role(client, r, this.id));
+        }
+      }
+      /** Get the guild icon URL, or null if no icon. */
+      iconURL(options) {
+        if (!this.icon) return null;
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/icons/${this.id}/${this.icon}.png${size}`;
+      }
+      /** Get the guild banner URL, or null if no banner. */
+      bannerURL(options) {
+        if (!this.banner) return null;
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/banners/${this.id}/${this.banner}.png${size}`;
+      }
+      /**
+       * Add a role to a member by user ID. Does not require fetching the member first.
+       * @param userId - The user ID of the member
+       * @param roleId - The role ID to add (or use guild.resolveRoleId for mention/name resolution)
+       * Requires Manage Roles permission.
+       */
+      async addRoleToMember(userId, roleId) {
+        await this.client.rest.put(import_types6.Routes.guildMemberRole(this.id, userId, roleId));
+      }
+      /**
+       * Remove a role from a member by user ID. Does not require fetching the member first.
+       * @param userId - The user ID of the member
+       * @param roleId - The role ID to remove
+       * Requires Manage Roles permission.
+       */
+      async removeRoleFromMember(userId, roleId) {
+        await this.client.rest.delete(import_types6.Routes.guildMemberRole(this.id, userId, roleId));
+      }
+      /**
+       * Resolve a role ID from an argument (role mention, raw ID, or name).
+       * Fetches guild roles if name is provided.
+       * @param arg - Role mention (@role), role ID, or role name
+       * @returns The role ID, or null if not found
+       */
+      async resolveRoleId(arg) {
+        const parsed = (0, import_util.parseRoleMention)(arg);
+        if (parsed) return parsed;
+        if (/^\d{17,19}$/.test(arg.trim())) return arg.trim();
+        const cached = this.roles.find(
+          (r) => !!(r.name && r.name.toLowerCase() === arg.trim().toLowerCase())
+        );
+        if (cached) return cached.id;
+        const roles = await this.client.rest.get(import_types6.Routes.guildRoles(this.id));
+        const list = Array.isArray(roles) ? roles : Object.values(roles ?? {});
+        const role = list.find((r) => !!(r.name && r.name.toLowerCase() === arg.trim().toLowerCase()));
+        if (role) {
+          this.roles.set(role.id, new Role(this.client, role, this.id));
+          return role.id;
+        }
+        return null;
+      }
+      /**
+       * Fetch a guild member by user ID.
+       * @param userId - The user ID of the member to fetch
+       * @returns The guild member, or null if not found
+       */
+      async fetchMember(userId) {
+        try {
+          const data = await this.client.rest.get(
+            import_types6.Routes.guildMember(this.id, userId)
+          );
+          return new GuildMember(this.client, { ...data, guild_id: this.id }, this);
+        } catch {
+          return null;
+        }
+      }
+      /** Fetch all webhooks in this guild. Returned webhooks do not include the token (cannot send). */
+      async fetchWebhooks() {
+        const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
+        const data = await this.client.rest.get(import_types6.Routes.guildWebhooks(this.id));
+        const list = Array.isArray(data) ? data : Object.values(data ?? {});
+        return list.map((w) => new Webhook2(this.client, w));
+      }
+    };
+  }
+});
+
+// src/structures/User.ts
+var import_types8, User;
+var init_User = __esm({
+  "src/structures/User.ts"() {
+    "use strict";
+    init_Base();
+    import_types8 = require("@fluxerjs/types");
+    init_Constants();
+    User = class extends Base {
+      client;
+      id;
+      username;
+      discriminator;
+      globalName;
+      avatar;
+      bot;
+      /** @param data - API user from message author, GET /users/{id}, or GET /users/@me */
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this.id = data.id;
+        this.username = data.username;
+        this.discriminator = data.discriminator;
+        this.globalName = data.global_name ?? null;
+        this.avatar = data.avatar ?? null;
+        this.bot = !!data.bot;
+      }
+      /** Update mutable fields from fresh API data. Used by getOrCreateUser cache. */
+      _patch(data) {
+        this.username = data.username;
+        this.discriminator = data.discriminator;
+        this.globalName = data.global_name ?? null;
+        this.avatar = data.avatar ?? null;
+      }
+      /**
+       * Get the URL for this user's avatar.
+       * @param options - Optional `size` and `extension` (default: `png`)
+       */
+      avatarURL(options) {
+        if (!this.avatar) return null;
+        const ext = options?.extension ?? "png";
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/avatars/${this.id}/${this.avatar}.${ext}${size}`;
+      }
+      /** Get the avatar URL, or the default avatar if none set. */
+      displayAvatarURL(options) {
+        return this.avatarURL(options) ?? `${CDN_URL}/avatars/0/0.png`;
+      }
+      /** Returns a mention string (e.g. `<@123456>`). */
+      toString() {
+        return `<@${this.id}>`;
+      }
+      /**
+       * Create or get a DM channel with this user.
+       * Returns the DM channel; use {@link DMChannel.send} to send messages.
+       */
+      async createDM() {
+        const { DMChannel: DMChannelClass } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+        const data = await this.client.rest.post(import_types8.Routes.userMeChannels(), {
+          body: { recipient_id: this.id },
+          auth: true
+        });
+        return new DMChannelClass(this.client, data);
+      }
+      /**
+       * Send a DM to this user.
+       * Convenience method that creates the DM channel and sends the message.
+       */
+      async send(options) {
+        const dm = await this.createDM();
+        return dm.send(options);
+      }
+    };
+  }
+});
+
+// src/structures/MessageReaction.ts
+var MessageReaction_exports = {};
+__export(MessageReaction_exports, {
+  MessageReaction: () => MessageReaction
+});
+var MessageReaction;
+var init_MessageReaction = __esm({
+  "src/structures/MessageReaction.ts"() {
+    "use strict";
+    init_Base();
+    MessageReaction = class extends Base {
+      client;
+      messageId;
+      channelId;
+      guildId;
+      emoji;
+      /** Raw gateway payload for low-level access. */
+      _data;
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this._data = data;
+        this.messageId = data.message_id;
+        this.channelId = data.channel_id;
+        this.guildId = data.guild_id ?? null;
+        this.emoji = data.emoji;
+      }
+      /** Emoji as a string: unicode or "name:id" for custom. */
+      get emojiIdentifier() {
+        return this.emoji.id ? `${this.emoji.name}:${this.emoji.id}` : this.emoji.name;
+      }
+      /** Guild where this reaction was added. Resolved from cache; null for DMs or if not cached. */
+      get guild() {
+        return this.guildId ? this.client.guilds.get(this.guildId) ?? null : null;
+      }
+      /**
+       * Fetch the message this reaction belongs to.
+       * Use when you need to edit, delete, or otherwise interact with the message.
+       */
+      async fetchMessage() {
+        return this.client.channels.fetchMessage(this.channelId, this.messageId);
+      }
+    };
+  }
+});
+
+// src/client/ClientUser.ts
 var ClientUser_exports = {};
 __export(ClientUser_exports, {
   ClientUser: () => ClientUser
@@ -436,20 +877,25 @@ __export(index_exports, {
   Base: () => Base,
   CategoryChannel: () => CategoryChannel,
   Channel: () => Channel,
+  ChannelManager: () => ChannelManager,
   Client: () => Client,
   ClientUser: () => ClientUser,
+  DMChannel: () => DMChannel,
   EmbedBuilder: () => import_builders2.EmbedBuilder,
   ErrorCodes: () => ErrorCodes,
   Events: () => Events,
   FluxerError: () => FluxerError,
-  GatewayOpcodes: () => import_types6.GatewayOpcodes,
+  GatewayOpcodes: () => import_types10.GatewayOpcodes,
   Guild: () => Guild,
   GuildChannel: () => GuildChannel,
   GuildMember: () => GuildMember,
   LinkChannel: () => LinkChannel,
   Message: () => Message,
+  MessageManager: () => MessageManager,
   MessagePayload: () => import_builders2.MessagePayload,
-  Routes: () => import_types6.Routes,
+  MessageReaction: () => MessageReaction,
+  Role: () => Role,
+  Routes: () => import_types10.Routes,
   TextChannel: () => TextChannel,
   User: () => User,
   VoiceChannel: () => VoiceChannel,
@@ -461,8 +907,120 @@ module.exports = __toCommonJS(index_exports);
 var import_events = require("events");
 var import_rest = require("@fluxerjs/rest");
 var import_ws = require("@fluxerjs/ws");
-var import_types5 = require("@fluxerjs/types");
-var import_collection3 = require("@fluxerjs/collection");
+var import_types9 = require("@fluxerjs/types");
+var import_collection5 = require("@fluxerjs/collection");
+
+// src/client/ChannelManager.ts
+var import_collection2 = require("@fluxerjs/collection");
+var import_types4 = require("@fluxerjs/types");
+var ChannelManager = class extends import_collection2.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 Promise.resolve().then(() => (init_Channel(), Channel_exports));
+      const data = await this.client.rest.get(
+        import_types4.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 Promise.resolve().then(() => (init_Message(), Message_exports));
+      const data = await this.client.rest.get(
+        import_types4.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 Promise.resolve().then(() => (init_Message(), Message_exports));
+    const data = await this.client.rest.post(import_types4.Routes.channelMessages(channelId), { body });
+    return new Message2(this.client, data);
+  }
+};
+
+// src/client/GuildManager.ts
+var import_collection4 = require("@fluxerjs/collection");
+var import_types7 = require("@fluxerjs/types");
+var GuildManager = class extends import_collection4.Collection {
+  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 Promise.resolve().then(() => (init_Guild(), Guild_exports));
+      const data = await this.client.rest.get(
+        import_types7.Routes.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 = {
@@ -470,6 +1028,7 @@ var Events = {
   MessageCreate: "messageCreate",
   MessageUpdate: "messageUpdate",
   MessageDelete: "messageDelete",
+  MessageDeleteBulk: "messageDeleteBulk",
   MessageReactionAdd: "messageReactionAdd",
   MessageReactionRemove: "messageReactionRemove",
   MessageReactionRemoveAll: "messageReactionRemoveAll",
@@ -478,24 +1037,285 @@ 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
+var import_util2 = require("@fluxerjs/util");
+init_User();
+
+// src/client/EventHandlerRegistry.ts
+var handlers = /* @__PURE__ */ new Map();
+handlers.set("MESSAGE_CREATE", async (client, d) => {
+  const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+  client.emit(Events.MessageCreate, new Message2(client, d));
+});
+handlers.set("MESSAGE_UPDATE", async (client, d) => {
+  const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+  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 Promise.resolve().then(() => (init_MessageReaction(), MessageReaction_exports));
+  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 Promise.resolve().then(() => (init_MessageReaction(), MessageReaction_exports));
+  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 Promise.resolve().then(() => (init_Guild(), Guild_exports));
+  const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+  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 Promise.resolve().then(() => (init_Guild(), Guild_exports));
+  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 Promise.resolve().then(() => (init_Channel(), Channel_exports));
+  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 Promise.resolve().then(() => (init_Channel(), Channel_exports));
+  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 Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
+  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 Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
+  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 Promise.resolve().then(() => (init_Role(), Role_exports));
+    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 Promise.resolve().then(() => (init_Role(), Role_exports));
+    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 import_events.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 import_rest.REST({
       api: options.rest?.api ?? "https://api.fluxer.app",
       version: options.rest?.version ?? "1",
@@ -503,17 +1323,87 @@ var Client = class extends import_events.EventEmitter {
     });
   }
   rest;
-  guilds = new import_collection3.Collection();
-  channels = new import_collection3.Collection();
-  users = new import_collection3.Collection();
+  guilds = new GuildManager(this);
+  channels = new ChannelManager(this);
+  users = new import_collection5.Collection();
   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 (0, import_util2.formatEmoji)({ name: emoji.name, id: emoji.id, animated: emoji.animated });
+    }
+    const parsed = (0, import_util2.parseEmoji)(typeof emoji === "string" ? emoji : `:${emoji.name}:`);
+    if (!parsed) throw new Error("Invalid emoji");
+    if (parsed.id) return (0, import_util2.formatEmoji)(parsed);
+    if (guildId) {
+      const emojis = await this.rest.get(import_types9.Routes.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 (0, import_util2.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);
   }
@@ -521,158 +1411,27 @@ var Client = class extends import_events.EventEmitter {
     if (payload.op !== 0 || !payload.t) return;
     const { t: event, d } = payload;
     try {
-      switch (event) {
-        case "MESSAGE_CREATE": {
-          const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-          this.emit(Events.MessageCreate, new Message2(this, d));
-          break;
-        }
-        case "MESSAGE_UPDATE": {
-          const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-          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 Promise.resolve().then(() => (init_Guild(), Guild_exports));
-          const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
-          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 Promise.resolve().then(() => (init_Guild(), Guild_exports));
-          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 Promise.resolve().then(() => (init_Channel(), Channel_exports));
-          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 Promise.resolve().then(() => (init_Channel(), Channel_exports));
-          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 Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
-          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 Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
-          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.");
       }
@@ -687,33 +1446,44 @@ var Client = class extends import_events.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 Promise.resolve().then(() => (init_ClientUser(), ClientUser_exports));
-      const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
-      const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
-      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 Promise.resolve().then(() => (init_ClientUser(), ClientUser_exports));
+        const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
+        const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+        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();
@@ -726,32 +1496,27 @@ var Client = class extends import_events.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 import_types5.Routes;
+    return import_types9.Routes;
   }
 };
 
 // src/index.ts
+init_MessageManager();
 init_ClientUser();
 init_Base();
 init_User();
 init_Guild();
 init_Channel();
 init_Message();
+init_MessageReaction();
 init_Webhook();
 init_GuildMember();
-
-// src/errors/FluxerError.ts
-var FluxerError = class _FluxerError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FluxerError";
-    Object.setPrototypeOf(this, _FluxerError.prototype);
-  }
-};
+init_Role();
 
 // src/errors/ErrorCodes.ts
 var ErrorCodes = {
@@ -761,15 +1526,17 @@ var ErrorCodes = {
 
 // src/index.ts
 var import_builders2 = require("@fluxerjs/builders");
-var import_types6 = require("@fluxerjs/types");
+var import_types10 = require("@fluxerjs/types");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AttachmentBuilder,
   Base,
   CategoryChannel,
   Channel,
+  ChannelManager,
   Client,
   ClientUser,
+  DMChannel,
   EmbedBuilder,
   ErrorCodes,
   Events,
@@ -780,7 +1547,10 @@ var import_types6 = require("@fluxerjs/types");
   GuildMember,
   LinkChannel,
   Message,
+  MessageManager,
   MessagePayload,
+  MessageReaction,
+  Role,
   Routes,
   TextChannel,
   User,