@fluxerjs/core 1.0.7 → 1.0.8

package/dist/index.js

@@ -20,6 +20,28 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/client/MessageManager.ts
+var MessageManager;
+var init_MessageManager = __esm({
+  "src/client/MessageManager.ts"() {
+    "use strict";
+    MessageManager = class {
+      constructor(client, channelId) {
+        this.client = client;
+        this.channelId = channelId;
+      }
+      /**
+       * 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/Base.ts
 var Base;
 var init_Base = __esm({
@@ -30,15 +52,6 @@ var init_Base = __esm({
   }
 });
 
-// src/util/Constants.ts
-var CDN_URL;
-var init_Constants = __esm({
-  "src/util/Constants.ts"() {
-    "use strict";
-    CDN_URL = "https://fluxerusercontent.com";
-  }
-});
-
 // src/structures/Webhook.ts
 var Webhook_exports = {};
 __export(Webhook_exports, {
@@ -80,7 +93,9 @@ 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_types.Routes.webhookExecute(this.id, this.token), {
@@ -120,6 +135,178 @@ var init_Webhook = __esm({
   }
 });
 
+// src/structures/Message.ts
+var Message_exports = {};
+__export(Message_exports, {
+  Message: () => Message
+});
+var import_collection, import_types2, import_builders, Message;
+var init_Message = __esm({
+  "src/structures/Message.ts"() {
+    "use strict";
+    init_Base();
+    import_collection = require("@fluxerjs/collection");
+    import_types2 = require("@fluxerjs/types");
+    import_builders = require("@fluxerjs/builders");
+    Message = class _Message extends Base {
+      client;
+      id;
+      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.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);
+      }
+      /**
+       * 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);
+      }
+      /**
+       * 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);
+      }
+      /**
+       * 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));
+      }
+    };
+  }
+});
+
 // src/structures/Channel.ts
 var Channel_exports = {};
 __export(Channel_exports, {
@@ -131,13 +318,26 @@ __export(Channel_exports, {
   TextChannel: () => TextChannel,
   VoiceChannel: () => VoiceChannel
 });
-var import_types2, Channel, GuildChannel, TextChannel, CategoryChannel, VoiceChannel, LinkChannel, DMChannel;
+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_types2 = 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);
@@ -159,12 +359,23 @@ var init_Channel = __esm({
        */
       static from(client, data) {
         const type = data.type ?? 0;
-        if (type === import_types2.ChannelType.GuildText) return new TextChannel(client, data);
-        if (type === import_types2.ChannelType.GuildCategory) return new CategoryChannel(client, data);
-        if (type === import_types2.ChannelType.GuildVoice) return new VoiceChannel(client, data);
-        if (type === import_types2.ChannelType.GuildLink || type === import_types2.ChannelType.GuildLinkExtended) 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;
@@ -185,7 +396,7 @@ var init_Channel = __esm({
        */
       async createWebhook(options) {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.post(import_types2.Routes.channelWebhooks(this.id), {
+        const data = await this.client.rest.post(import_types3.Routes.channelWebhooks(this.id), {
           body: options,
           auth: true
         });
@@ -197,7 +408,7 @@ var init_Channel = __esm({
        */
       async fetchWebhooks() {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.get(import_types2.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));
       }
@@ -221,9 +432,22 @@ var init_Channel = __esm({
       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_types2.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 {
     };
@@ -258,249 +482,133 @@ var init_Channel = __esm({
       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_types2.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 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);
+      }
     };
   }
 });
 
-// src/structures/User.ts
-var import_types3, User;
-var init_User = __esm({
-  "src/structures/User.ts"() {
+// src/structures/GuildMember.ts
+var GuildMember_exports = {};
+__export(GuildMember_exports, {
+  GuildMember: () => GuildMember
+});
+var import_types5, GuildMember;
+var init_GuildMember = __esm({
+  "src/structures/GuildMember.ts"() {
     "use strict";
     init_Base();
-    import_types3 = require("@fluxerjs/types");
-    init_Constants();
-    User = class extends Base {
+    import_types5 = require("@fluxerjs/types");
+    GuildMember = 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) {
+      user;
+      guild;
+      nick;
+      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.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;
-      }
-      /**
-       * 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`;
+        this.user = client.getOrCreateUser(data.user);
+        this.id = data.user.id;
+        this.guild = guild;
+        this.nick = data.nick ?? null;
+        this.roles = data.roles ?? [];
+        this.joinedAt = new Date(data.joined_at);
+        this.communicationDisabledUntil = data.communication_disabled_until ? new Date(data.communication_disabled_until) : null;
       }
-      /** Returns a mention string (e.g. `<@123456>`). */
-      toString() {
-        return `<@${this.id}>`;
+      /** Nickname, or global name, or username. */
+      get displayName() {
+        return this.nick ?? this.user.globalName ?? this.user.username;
       }
       /**
-       * Create or get a DM channel with this user.
-       * Returns the DM channel; use {@link DMChannel.send} to send messages.
+       * Add a role to this member.
+       * @param roleId - The role ID to add
+       * Requires Manage Roles permission.
        */
-      async createDM() {
-        const { DMChannel: DMChannelClass } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
-        const data = await this.client.rest.post(import_types3.Routes.userMeChannels(), {
-          body: { recipient_id: this.id },
-          auth: true
-        });
-        return new DMChannelClass(this.client, data);
+      async addRole(roleId) {
+        await this.client.rest.put(import_types5.Routes.guildMemberRole(this.guild.id, this.id, roleId));
       }
       /**
-       * Send a DM to this user.
-       * Convenience method that creates the DM channel and sends the message.
+       * Remove a role from this member.
+       * @param roleId - The role ID to remove
+       * Requires Manage Roles permission.
        */
-      async send(options) {
-        const dm = await this.createDM();
-        return dm.send(options);
+      async removeRole(roleId) {
+        await this.client.rest.delete(import_types5.Routes.guildMemberRole(this.guild.id, this.id, roleId));
       }
     };
   }
 });
 
-// src/structures/Message.ts
-var Message_exports = {};
-__export(Message_exports, {
-  Message: () => Message
+// src/structures/Role.ts
+var Role_exports = {};
+__export(Role_exports, {
+  Role: () => Role
 });
-var import_collection, import_types4, import_builders, Message;
-var init_Message = __esm({
-  "src/structures/Message.ts"() {
+var Role;
+var init_Role = __esm({
+  "src/structures/Role.ts"() {
     "use strict";
     init_Base();
-    import_collection = require("@fluxerjs/collection");
-    import_types4 = require("@fluxerjs/types");
-    import_builders = require("@fluxerjs/builders");
-    init_User();
-    Message = class _Message extends Base {
+    Role = class extends Base {
       client;
       id;
-      channelId;
       guildId;
-      author;
-      content;
-      createdAt;
-      editedAt;
-      pinned;
-      attachments;
-      channel;
-      /** @param data - API message from POST/PATCH /channels/{id}/messages or gateway MESSAGE_CREATE */
-      constructor(client, data) {
+      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.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);
-      }
-      /**
-       * 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_types4.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_types4.Routes.channelMessage(this.channelId, this.id), { body });
-        return new _Message(this.client, data);
-      }
-      /** Delete this message. */
-      async delete() {
-        await this.client.rest.delete(import_types4.Routes.channelMessage(this.channelId, this.id));
-      }
-      /**
-       * Format emoji for reaction API: unicode string or "name:id" for custom.
-       * @param emoji - Unicode emoji (e.g. "👍") or custom { name, id } or "name:id" string
-       */
-      static formatEmoji(emoji) {
-        if (typeof emoji === "string") return emoji;
-        return `${emoji.name}:${emoji.id}`;
-      }
-      /**
-       * Add a reaction to this message (as the bot).
-       * @param emoji - Unicode emoji (e.g. `👍`) or custom emoji `{ name, id }`
-       */
-      async react(emoji) {
-        const emojiStr = _Message.formatEmoji(emoji);
-        const route = `${import_types4.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 or custom `{ name, id }`
-       * @param userId - If provided, removes that user's reaction (requires moderator permissions)
-       */
-      async removeReaction(emoji, userId) {
-        const emojiStr = _Message.formatEmoji(emoji);
-        const route = `${import_types4.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_types4.Routes.channelMessageReactions(this.channelId, this.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;
       }
-      /**
-       * Remove all reactions of a specific emoji from this message.
-       * @param emoji - Unicode emoji or custom `{ name, id }`. Requires moderator permissions.
-       */
-      async removeReactionEmoji(emoji) {
-        const emojiStr = _Message.formatEmoji(emoji);
-        await this.client.rest.delete(import_types4.Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
+      /** Returns a mention string (e.g. `<@&123456>`). */
+      toString() {
+        return `<@&${this.id}>`;
       }
     };
   }
 });
 
-// src/structures/GuildMember.ts
-var GuildMember_exports = {};
-__export(GuildMember_exports, {
-  GuildMember: () => GuildMember
-});
-var import_types5, GuildMember;
-var init_GuildMember = __esm({
-  "src/structures/GuildMember.ts"() {
+// src/util/Constants.ts
+var CDN_URL;
+var init_Constants = __esm({
+  "src/util/Constants.ts"() {
     "use strict";
-    init_Base();
-    init_User();
-    import_types5 = require("@fluxerjs/types");
-    GuildMember = class extends Base {
-      client;
-      id;
-      user;
-      guild;
-      nick;
-      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.id = data.user.id;
-        this.guild = guild;
-        this.nick = data.nick ?? null;
-        this.roles = data.roles ?? [];
-        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;
-      }
-      /**
-       * 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));
-      }
-    };
+    CDN_URL = "https://fluxerusercontent.com";
   }
 });
 
@@ -509,13 +617,15 @@ var Guild_exports = {};
 __export(Guild_exports, {
   Guild: () => Guild
 });
-var import_collection2, import_types6, 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_collection2 = require("@fluxerjs/collection");
+    import_collection3 = require("@fluxerjs/collection");
     init_GuildMember();
+    init_Role();
     init_Constants();
     import_types6 = require("@fluxerjs/types");
     Guild = class extends Base {
@@ -525,8 +635,9 @@ var init_Guild = __esm({
       icon;
       banner;
       ownerId;
-      members = new import_collection2.Collection();
-      channels = new import_collection2.Collection();
+      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();
@@ -536,6 +647,9 @@ var init_Guild = __esm({
         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) {
@@ -549,6 +663,47 @@ var init_Guild = __esm({
         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
@@ -575,6 +730,128 @@ var init_Guild = __esm({
   }
 });
 
+// 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, {
@@ -600,6 +877,7 @@ __export(index_exports, {
   Base: () => Base,
   CategoryChannel: () => CategoryChannel,
   Channel: () => Channel,
+  ChannelManager: () => ChannelManager,
   Client: () => Client,
   ClientUser: () => ClientUser,
   DMChannel: () => DMChannel,
@@ -607,14 +885,17 @@ __export(index_exports, {
   ErrorCodes: () => ErrorCodes,
   Events: () => Events,
   FluxerError: () => FluxerError,
-  GatewayOpcodes: () => import_types8.GatewayOpcodes,
+  GatewayOpcodes: () => import_types10.GatewayOpcodes,
   Guild: () => Guild,
   GuildChannel: () => GuildChannel,
   GuildMember: () => GuildMember,
   LinkChannel: () => LinkChannel,
   Message: () => Message,
+  MessageManager: () => MessageManager,
   MessagePayload: () => import_builders2.MessagePayload,
-  Routes: () => import_types8.Routes,
+  MessageReaction: () => MessageReaction,
+  Role: () => Role,
+  Routes: () => import_types10.Routes,
   TextChannel: () => TextChannel,
   User: () => User,
   VoiceChannel: () => VoiceChannel,
@@ -626,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_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 import_collection3 = require("@fluxerjs/collection");
+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 = {
@@ -635,6 +1028,7 @@ var Events = {
   MessageCreate: "messageCreate",
   MessageUpdate: "messageUpdate",
   MessageDelete: "messageDelete",
+  MessageDeleteBulk: "messageDeleteBulk",
   MessageReactionAdd: "messageReactionAdd",
   MessageReactionRemove: "messageReactionRemove",
   MessageReactionRemoveAll: "messageReactionRemoveAll",
@@ -643,25 +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",
@@ -669,12 +1323,77 @@ 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");
@@ -692,145 +1411,8 @@ 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)));
     }
@@ -840,14 +1422,16 @@ var Client = class extends import_events.EventEmitter {
    * @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.");
       }
@@ -862,28 +1446,38 @@ 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();
@@ -907,28 +1501,22 @@ var Client = class extends import_events.EventEmitter {
     return this.readyAt !== null && this.user !== null;
   }
   static get Routes() {
-    return import_types7.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 = {
@@ -938,13 +1526,14 @@ var ErrorCodes = {
 
 // src/index.ts
 var import_builders2 = require("@fluxerjs/builders");
-var import_types8 = 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,
@@ -958,7 +1547,10 @@ var import_types8 = require("@fluxerjs/types");
   GuildMember,
   LinkChannel,
   Message,
+  MessageManager,
   MessagePayload,
+  MessageReaction,
+  Role,
   Routes,
   TextChannel,
   User,