discord-self-lite 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-self-lite",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Lightweight Discord selfbot library",
   "keywords": [
     "discord",

package/src/classes/Channel.js

@@ -2,6 +2,7 @@
  * Represents a Discord channel
  */
 const Permissions = require("./Permissions");
+const Message = require("./Message");
 
 /**
  * Safe BigInt conversion
@@ -50,10 +51,11 @@ class Channel {
   /**
    * Send a message to this channel
    * @param {string|object} payload - Message content or payload object
-   * @returns {Promise<object>} The sent message data
+   * @returns {Promise<Message>} The sent message object
    */
   async send(payload) {
-    return await this.rest.sendMessage(this.id, payload);
+    const data = await this.rest.sendMessage(this.id, payload);
+    return new Message(this.client, data);
   }
 
   /**
@@ -88,6 +90,45 @@ class Channel {
     return new Message(this.client, data);
   }
 
+  /**
+   * Fetch webhooks for this channel
+   * @returns {Promise<Array>} Array of webhook objects
+   */
+  async fetchWebhooks() {
+    const webhooks = await this.rest.fetchWebhooks(this.id);
+    if (!Array.isArray(webhooks)) return webhooks;
+
+    return webhooks.map((webhook) => {
+      const url = webhook.token
+        ? `https://discord.com/api/webhooks/${webhook.id}/${webhook.token}`
+        : null;
+
+      return {
+        ...webhook,
+        url,
+      };
+    });
+  }
+
+  /**
+   * Create a webhook in this channel
+   * @param {string} name - Webhook name
+   * @param {object} [options={}] - Webhook options
+   * @param {string} [options.avatar] - Webhook avatar payload
+   * @returns {Promise<object>} Created webhook object with `.url`
+   */
+  async createWebhook(name, options = {}) {
+    const webhook = await this.rest.createWebhook(this.id, name, options);
+    if (!webhook) return webhook;
+
+    return {
+      ...webhook,
+      url: webhook.token
+        ? `https://discord.com/api/webhooks/${webhook.id}/${webhook.token}`
+        : null,
+    };
+  }
+
   /**
    * Get the guild this channel belongs to
    * @returns {Guild|null} The guild instance or null if not a guild channel

package/src/classes/Client.js

@@ -4,6 +4,7 @@ const RestManager = require("../connection/rest/RestManager");
 const Guild = require("./Guild");
 const Channel = require("./Channel");
 const Message = require("./Message");
+const User = require("./User");
 
 /**
  * The main client for connecting to Discord
@@ -35,6 +36,7 @@ class Client extends EventEmitter {
     this.rest = null;
     this.guilds = new Map(); // Cache for Guild instances
     this.channels = new Map(); // Cache for Channel instances
+    this.users = new Map(); // Cache for User instances
     this.sessionId = null; // Will be set from WebSocket READY event
     this.user = null; // Will be set from WebSocket READY event
   }
@@ -89,10 +91,11 @@ class Client extends EventEmitter {
    * Send a message to a channel
    * @param {string} channelId - The channel ID to send to
    * @param {string|object} content - Message content or payload
-   * @returns {Promise<object>} The sent message data
+   * @returns {Promise<Message>} The sent message object
    */
   async sendMessage(channelId, content) {
-    return await this.rest.sendMessage(channelId, content);
+    const data = await this.rest.sendMessage(channelId, content);
+    return new Message(this, data);
   }
 
   /**
@@ -119,6 +122,18 @@ class Client extends EventEmitter {
     return this.guilds.get(id);
   }
 
+  /**
+   * Get user from cache, or create lightweight instance if not cached
+   * @param {string} id - The user ID
+   * @returns {User} The User instance
+   */
+  getUser(id) {
+    if (!this.users.has(id)) {
+      this.users.set(id, new User(this, { id }));
+    }
+    return this.users.get(id);
+  }
+
   /**
    * Fetch guild data from API and update cache
    * @param {string} id - The guild ID
@@ -147,6 +162,18 @@ class Client extends EventEmitter {
     return guild;
   }
 
+  /**
+   * Fetch user data from API and update cache
+   * @param {string} id - The user ID
+   * @returns {Promise<User>} The User instance with fresh data
+   */
+  async fetchUser(id) {
+    const data = await this.rest.fetchUser(id);
+    const user = new User(this, data);
+    this.users.set(id, user);
+    return user;
+  }
+
   /**
    * Fetch channel data from API and update cache
    * @param {string} id - The channel ID

package/src/classes/ClientUser.js

@@ -0,0 +1,71 @@
+const User = require("./User");
+
+/**
+ * Represents the authenticated client user
+ */
+class ClientUser extends User {
+  /**
+   * Set the user's presence/status
+   * @param {object} presence - Presence data
+   * @param {string} [presence.status] - Status: 'online', 'idle', 'dnd', 'invisible'
+   * @param {Array} [presence.activities] - Array of activity objects
+   * @param {boolean} [presence.afk] - Whether the user is AFK
+   * @param {number} [presence.since] - Unix timestamp of when the status was set
+   * @returns {void}
+   */
+  setPresence(presence) {
+    if (!this.client.ws || !this.client.ws.ready) {
+      throw new Error("Client is not connected");
+    }
+
+    const presenceData = {
+      status: presence.status || "online",
+      since: presence.since || 0,
+      activities: presence.activities || [],
+      afk: presence.afk || false,
+    };
+
+    // Send presence update via WebSocket
+    this.client.ws.send({
+      op: 3,
+      d: presenceData,
+    });
+
+    // Update client's stored presence
+    this.client.options.presence = presenceData;
+  }
+
+  /**
+   * Set the user's status (convenience method)
+   * @param {string} status - Status: 'online', 'idle', 'dnd', 'invisible'
+   * @returns {void}
+   */
+  setStatus(status) {
+    this.setPresence({
+      status: status,
+      since: this.client.options.presence.since,
+      activities: this.client.options.presence.activities,
+      afk: this.client.options.presence.afk,
+    });
+  }
+
+  /**
+   * Set the user's activity
+   * @param {object} activity - Activity data
+   * @param {string} activity.name - Activity name
+   * @param {string} [activity.type=0] - Activity type
+   * @param {string} [activity.url] - Stream URL (for type 1)
+   * @returns {void}
+   */
+  setActivity(activity) {
+    const activities = activity ? [activity] : [];
+    this.setPresence({
+      status: this.client.options.presence.status,
+      since: this.client.options.presence.since,
+      activities: activities,
+      afk: this.client.options.presence.afk,
+    });
+  }
+}
+
+module.exports = ClientUser;

package/src/classes/DiscordAPIError.js

@@ -8,12 +8,14 @@ class DiscordAPIError extends Error {
    * @param {string} message - The error message.
    * @param {number} status - The HTTP status code of the response.
    * @param {string} path - The path of the API endpoint that was requested.
+   * @param {object|null} [fullError=null] - Full Discord API error payload.
    */
-  constructor(message, status, path) {
+  constructor(message, status, path, fullError = null) {
     super(message);
     this.name = "DiscordAPIError";
     this.status = status;
     this.path = path;
+    this.fullError = fullError;
   }
 }
 

package/src/classes/Message.js

@@ -1,4 +1,5 @@
 const WebSocketError = require("./WebSocketError");
+const User = require("./User");
 
 /**
  * Represents a Discord message
@@ -20,6 +21,17 @@ class Message {
       this[camelKey] = value;
     }
 
+    // Wrap author as User instance and cache it
+    if (this.author && typeof this.author === "object") {
+      const authorId = this.author.id;
+      if (!this.client.users.has(authorId)) {
+        this.author = new User(this.client, this.author);
+        this.client.users.set(authorId, this.author);
+      } else {
+        this.author = this.client.users.get(authorId);
+      }
+    }
+
     this.components = this.components || [];
     this.attachments = this.attachments || [];
     this.embeds = this.embeds || [];
@@ -36,6 +48,33 @@ class Message {
     return this.client.getChannel(this.channelId);
   }
 
+  async edit(payload) {
+    const updatedData = await this.client.rest.editMessage(
+      this.channelId,
+      this.id,
+      payload,
+    );
+
+    // Update internal raw data
+    this.data = updatedData;
+
+    for (const [key, value] of Object.entries(updatedData)) {
+      const camelKey = key.replace(/_([a-z])/g, (_, letter) =>
+        letter.toUpperCase(),
+      );
+      this[camelKey] = value;
+    }
+
+    this.components = this.components || [];
+    this.attachments = this.attachments || [];
+    this.embeds = this.embeds || [];
+    this.mentions = this.mentions || [];
+    this.mentionRoles = this.mentionRoles || [];
+    this.reactions = this.reactions || [];
+
+    return this;
+  }
+
   /**
    * Get the guild this message was sent in
    * @returns {Guild|null} The guild instance, or null if message was sent in DM
@@ -135,6 +174,51 @@ class Message {
       messageFlags,
     );
   }
+
+  /**
+   * Backwards-compatible alias for message reference data
+   */
+
+  get reference() {
+    // If the referenced message is embedded in the payload, return a Message instance.
+    const embedded =
+      this.data?.referenced_message || this.referencedMessage || null;
+    if (embedded && typeof embedded === "object") {
+      return new Message(this.client, embedded);
+    }
+
+    // Otherwise, no embedded message is available synchronously.
+    return null;
+  }
+
+  /**
+   * Fetch the referenced message asynchronously when only IDs are present.
+   * Returns the referenced `Message` instance or `null` if not available.
+   */
+  async fetchReference() {
+    const ref = this.messageReference || this.data?.message_reference;
+    if (!ref) return null;
+
+    const messageId = ref.messageId || ref.message_id;
+    const channelId = ref.channelId || ref.channel_id || this.channelId;
+    if (!messageId || !channelId) return null;
+
+    // Try to get channel from cache or fetch from API
+    let channel = this.client.getChannel(channelId);
+    if (!channel) {
+      try {
+        channel = await this.client.fetchChannel(channelId);
+      } catch {
+        return null;
+      }
+    }
+
+    try {
+      return await channel.fetchMessage(messageId);
+    } catch {
+      return null;
+    }
+  }
 }
 
 module.exports = Message;

package/src/classes/User.js

@@ -10,6 +10,7 @@ class User {
   constructor(client, data) {
     this.client = client;
     this.data = data;
+    this._dmChannelId = null;
 
     // Copy all user properties
     for (const [key, value] of Object.entries(data)) {
@@ -19,68 +20,39 @@ class User {
       this[camelKey] = value;
     }
   }
-
   /**
-   * Set the user's presence/status
-   * @param {object} presence - Presence data
-   * @param {string} [presence.status] - Status: 'online', 'idle', 'dnd', 'invisible'
-   * @param {Array} [presence.activities] - Array of activity objects
-   * @param {boolean} [presence.afk] - Whether the user is AFK
-   * @param {number} [presence.since] - Unix timestamp of when the status was set
-   * @returns {void}
+   * Create a DM channel with this user
+   * @returns {Promise<Channel>} The DM channel instance
    */
-  setPresence(presence) {
-    if (!this.client.ws || !this.client.ws.ready) {
-      throw new Error("Client is not connected");
-    }
-
-    const presenceData = {
-      status: presence.status || "online",
-      since: presence.since || 0,
-      activities: presence.activities || [],
-      afk: presence.afk || false,
-    };
-
-    // Send presence update via WebSocket
-    this.client.ws.send({
-      op: 3,
-      d: presenceData,
-    });
-
-    // Update client's stored presence
-    this.client.options.presence = presenceData;
+  async createDM() {
+    const data = await this.client.rest.createDM(this.id);
+    const Channel = require("./Channel");
+    const channel = new Channel(this.client, this.client.rest, data);
+    this.client.channels.set(channel.id, channel);
+    this._dmChannelId = channel.id;
+    return channel;
   }
 
   /**
-   * Set the user's status (convenience method)
-   * @param {string} status - Status: 'online', 'idle', 'dnd', 'invisible'
-   * @returns {void}
+   * Get existing DM channel or create one if needed
+   * @returns {Promise<Channel>} The DM channel instance
    */
-  setStatus(status) {
-    this.setPresence({
-      status: status,
-      since: this.client.options.presence.since,
-      activities: this.client.options.presence.activities,
-      afk: this.client.options.presence.afk,
-    });
+  async getDMChannel() {
+    if (this._dmChannelId && this.client.channels.has(this._dmChannelId)) {
+      return this.client.channels.get(this._dmChannelId);
+    }
+
+    return await this.createDM();
   }
 
   /**
-   * Set the user's activity
-   * @param {object} activity - Activity data
-   * @param {string} activity.name - Activity name
-   * @param {string} [activity.type=0] - Activity type (0=Playing, 1=Streaming, 2=Listening, 3=Watching, 5=Competing)
-   * @param {string} [activity.url] - Stream URL (for type 1)
-   * @returns {void}
+   * Send a DM to this user
+   * @param {string|object} payload - Message content or payload object
+   * @returns {Promise<Message>} The sent message
    */
-  setActivity(activity) {
-    const activities = activity ? [activity] : [];
-    this.setPresence({
-      status: this.client.options.presence.status,
-      since: this.client.options.presence.since,
-      activities: activities,
-      afk: this.client.options.presence.afk,
-    });
+  async send(payload) {
+    const dmChannel = await this.getDMChannel();
+    return await dmChannel.send(payload);
   }
 }
 

package/src/connection/rest/RestManager.js

@@ -3,6 +3,8 @@ const react = require("./methods/react");
 const clickButton = require("./methods/clickButton");
 const fetchGuildMembers = require("./methods/fetchGuildMembers");
 const fetchGuildMember = require("./methods/fetchGuildMember");
+const fetchUser = require("./methods/fetchUser");
+const createDM = require("./methods/createDM");
 const DiscordAPIError = require("../../classes/DiscordAPIError");
 
 /**
@@ -23,6 +25,12 @@ class RestManager {
     this.globalRateLimit = null; // { reset }
     this.requestQueue = [];
     this.processingQueue = false;
+
+    // Circuit breaker state for heavily rate-limited routes
+    this.circuitBreakers = new Map(); // routeKey -> { failures, lastFailure, openUntil }
+
+    // Suspended routes - temporarily disabled endpoints
+    this.suspendedRoutes = new Map(); // routeKey -> { suspendedUntil, reason }
   }
 
   /**
@@ -33,7 +41,64 @@ class RestManager {
    * @throws {Error} If the request fails
    */
   async request(endpoint, options = {}) {
+    // Check rate limits before queuing the request with more aggressive logic
+    const method = options.method || "GET";
+    const routeKey = this.getRouteKey(endpoint, method);
+
+    // Check circuit breaker - reject immediately if route is temporarily disabled
+    const circuitBreaker = this.circuitBreakers.get(routeKey);
+    if (circuitBreaker && circuitBreaker.openUntil > Date.now()) {
+      const remainingTime = circuitBreaker.openUntil - Date.now();
+      console.log(
+        `🚫 Request dropped: Circuit breaker open for ${routeKey} (${Math.round(remainingTime / 1000)}s remaining)`,
+      );
+      return Promise.resolve(null);
+    }
+
+    // Check if route is suspended - silently reject to avoid spam
+    const suspendedRoute = this.suspendedRoutes.get(routeKey);
+    if (suspendedRoute && suspendedRoute.suspendedUntil > Date.now()) {
+      const remainingTime = suspendedRoute.suspendedUntil - Date.now();
+      console.log(
+        `🚫 Request dropped: Route ${routeKey} is suspended for ${Math.round(remainingTime / 1000)}s`,
+      );
+      return Promise.resolve(null);
+    }
+
+    // Check rate limits - if rate limited, suspend immediately instead of waiting
+    if (this.isRateLimited(endpoint, method)) {
+      const suspensionTime = 2 * 60 * 1000; // 2 minutes
+      this.suspendedRoutes.set(routeKey, {
+        suspendedUntil: Date.now() + suspensionTime,
+        reason: "Rate limited - pre-emptive suspension",
+      });
+
+      console.log(
+        `⏸️ Suspending route ${routeKey} for 2 minutes (pre-emptive)`,
+      );
+
+      // Clear queued requests for this route
+      const clearedCount = this.clearQueuedRequestsForRoute(routeKey);
+      if (clearedCount > 0) {
+        console.log(
+          `🗑️ Cleared ${clearedCount} queued requests for suspended route ${routeKey}`,
+        );
+      }
+
+      console.log(`🚫 Request dropped: Route suspended for ${routeKey}`);
+      return Promise.resolve(null);
+    }
+
     return new Promise((resolve, reject) => {
+      // Prevent queue from growing too large during rate limit storms
+      if (this.requestQueue.length >= 50) {
+        console.log(
+          `🚫 Request dropped: Queue full (${this.requestQueue.length} requests)`,
+        );
+        resolve(null);
+        return;
+      }
+
       this.requestQueue.push({
         endpoint,
         options,
@@ -67,6 +132,26 @@ class RestManager {
 
     this.processingQueue = true;
 
+    // Filter out suspended routes before processing any requests
+    this.requestQueue = this.requestQueue.filter((request) => {
+      const routeKey = this.getRouteKey(
+        request.endpoint,
+        request.options.method || "GET",
+      );
+      const suspendedRoute = this.suspendedRoutes.get(routeKey);
+
+      if (suspendedRoute && suspendedRoute.suspendedUntil > Date.now()) {
+        // Silently resolve suspended requests
+        console.log(
+          `🚫 Queued request dropped: Route ${routeKey} is suspended`,
+        );
+        request.resolve(null);
+        return false; // Remove from queue
+      }
+
+      return true; // Keep in queue
+    });
+
     while (this.requestQueue.length > 0) {
       // Double-check global rate limit for each request
       if (this.globalRateLimit && Date.now() < this.globalRateLimit.reset) {
@@ -80,35 +165,53 @@ class RestManager {
       const { endpoint, options, resolve, reject } = request;
 
       try {
-        // Check endpoint-specific rate limit
         const routeKey = this.getRouteKey(endpoint, options.method || "GET");
-        const rateLimit = this.rateLimits.get(routeKey);
 
+        // Check suspension status before processing
+        const suspendedRoute = this.suspendedRoutes.get(routeKey);
+        if (suspendedRoute && suspendedRoute.suspendedUntil > Date.now()) {
+          console.log(
+            `🚫 Processing request dropped: Route ${routeKey} is suspended`,
+          );
+          resolve(null);
+          continue;
+        }
+
+        // Check rate limit before processing - suspend immediately if exhausted
+        const rateLimit = this.rateLimits.get(routeKey);
         if (
           rateLimit &&
           rateLimit.remaining <= 0 &&
           Date.now() < rateLimit.reset
         ) {
-          const delay = rateLimit.reset - Date.now();
+          // Suspend instead of waiting
+          const suspensionTime = 2 * 60 * 1000; // 2 minutes
+          this.suspendedRoutes.set(routeKey, {
+            suspendedUntil: Date.now() + suspensionTime,
+            reason: "Rate limit exhausted during queue processing",
+          });
+
           console.log(
-            `⏳ Route rate limit for ${routeKey} (${endpoint}), waiting ${delay}ms`,
+            `⏸️ Suspending route ${routeKey} for 2 minutes (queue processing)`,
           );
-          await this.sleep(delay);
 
-          // After waiting, check if we still have remaining requests
-          const updatedRateLimit = this.rateLimits.get(routeKey);
-          if (updatedRateLimit && updatedRateLimit.remaining <= 0) {
-            // Still rate limited, put request back at front of queue
-            this.requestQueue.unshift(request);
-            continue;
+          // Clear remaining queued requests for this route
+          const clearedCount = this.clearQueuedRequestsForRoute(routeKey);
+          if (clearedCount > 0) {
+            console.log(
+              `🗑️ Cleared ${clearedCount} additional queued requests for ${routeKey}`,
+            );
           }
+
+          resolve(null);
+          continue;
         }
 
         const result = await this.makeRequest(endpoint, options);
         resolve(result);
 
-        // Small delay between requests to be nice to Discord
-        await this.sleep(100);
+        // Delay between requests to be conservative with rate limits
+        await this.sleep(500);
       } catch (error) {
         reject(error);
       }
@@ -147,7 +250,7 @@ class RestManager {
         // Handle rate limiting
         if (response.status === 429) {
           const retryAfter =
-            parseInt(response.headers.get("retry-after")) * 1000 + 1000;
+            parseInt(response.headers.get("retry-after")) * 1000 || 2000;
           const isGlobal =
             response.headers.get("x-ratelimit-global") === "true";
           const routeKey = this.getRouteKey(endpoint, options.method || "GET");
@@ -155,38 +258,99 @@ class RestManager {
           console.log(
             `🚫 Rate limited! ${
               isGlobal ? "Global" : `Route (${routeKey})`
-            } limit for ${endpoint}, retry after ${retryAfter}ms`,
+            } limit for ${endpoint}`,
           );
 
           if (isGlobal) {
-            this.globalRateLimit = { reset: Date.now() + retryAfter };
+            this.globalRateLimit = { reset: Date.now() + retryAfter + 2000 };
+            console.log(
+              `⏳ Global rate limit set, waiting ${retryAfter + 2000}ms`,
+            );
           } else {
-            // Update route-specific rate limit for 429 responses
+            // Immediately suspend the route for 2 minutes on first 429
+            const suspensionTime = 2 * 60 * 1000;
+            this.suspendedRoutes.set(routeKey, {
+              suspendedUntil: Date.now() + suspensionTime,
+              reason: `429 response on attempt ${attempt + 1}`,
+            });
+
+            console.log(
+              `⏸️ Suspending route ${routeKey} for 2 minutes (429 response)`,
+            );
+
+            // Clear queue for this route
+            const clearedCount = this.clearQueuedRequestsForRoute(routeKey);
+            if (clearedCount > 0) {
+              console.log(
+                `�️ Cleared ${clearedCount} queued requests for ${routeKey}`,
+              );
+            }
+
+            // Update rate limit state
             this.rateLimits.set(routeKey, {
               remaining: 0,
-              reset: Date.now() + retryAfter,
-              limit: this.rateLimits.get(routeKey)?.limit || 5, // Default limit if unknown
+              reset: Date.now() + suspensionTime,
+              limit: this.rateLimits.get(routeKey)?.limit || 5,
               updatedAt: Date.now(),
             });
+
+            // Open circuit breaker after 2 consecutive 429s
+            const breaker = this.circuitBreakers.get(routeKey) || {
+              failures: 0,
+              lastFailure: 0,
+              openUntil: 0,
+            };
+            breaker.failures++;
+            breaker.lastFailure = Date.now();
+
+            if (breaker.failures >= 2) {
+              breaker.openUntil = Date.now() + suspensionTime;
+              console.log(`🔌 Circuit breaker OPENED for ${routeKey}`);
+            }
+
+            this.circuitBreakers.set(routeKey, breaker);
+
+            // Don't retry, return null immediately
+            return null;
           }
 
-          await this.sleep(retryAfter);
-          attempt++;
-          continue;
+          // For global rate limits, wait and retry
+          if (isGlobal) {
+            await this.sleep(retryAfter + 2000);
+            attempt++;
+            continue;
+          }
+
+          // For route rate limits, don't retry
+          return null;
         }
 
         if (!response.ok) {
           const error = await response
             .json()
             .catch(() => ({ message: "Unknown error" }));
-          throw new DiscordAPIError(error.message, response.status, endpoint);
+          throw new DiscordAPIError(
+            error.message,
+            response.status,
+            endpoint,
+            error,
+          );
         }
 
         // Handle 204 No Content (successful but no body)
         if (response.status === 204) {
+          // Reset circuit breaker and suspension on successful response
+          const routeKey = this.getRouteKey(endpoint, options.method || "GET");
+          this.circuitBreakers.delete(routeKey);
+          this.suspendedRoutes.delete(routeKey);
           return null;
         }
 
+        // Reset circuit breaker and suspension on successful response
+        const routeKey = this.getRouteKey(endpoint, options.method || "GET");
+        this.circuitBreakers.delete(routeKey);
+        this.suspendedRoutes.delete(routeKey);
+
         return await response.json();
       } catch (error) {
         if (attempt === maxRetries - 1) {
@@ -258,6 +422,48 @@ class RestManager {
         this.rateLimits.delete(key);
       }
     }
+
+    // Clean up expired circuit breakers
+    for (const [key, breaker] of this.circuitBreakers.entries()) {
+      if (now > breaker.openUntil) {
+        this.circuitBreakers.delete(key);
+      }
+    }
+
+    // Clean up expired route suspensions
+    for (const [key, suspension] of this.suspendedRoutes.entries()) {
+      if (now > suspension.suspendedUntil) {
+        this.suspendedRoutes.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Sleep for a specified number of milliseconds
+   * @private
+   * @param {number} ms - Milliseconds to sleep
+   * @returns {Promise<void>}
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Clear queued requests for a specific route
+   * @private
+   * @param {string} routeKey - The route key to clear requests for
+   * @returns {number} Number of requests cleared
+   */
+  clearQueuedRequestsForRoute(routeKey) {
+    const initialLength = this.requestQueue.length;
+    this.requestQueue = this.requestQueue.filter((request) => {
+      const requestRouteKey = this.getRouteKey(
+        request.endpoint,
+        request.options.method || "GET",
+      );
+      return requestRouteKey !== routeKey;
+    });
+    return initialLength - this.requestQueue.length;
   }
 
   /**
@@ -325,6 +531,81 @@ class RestManager {
     return await sendMessage(this, channelId, payload);
   }
 
+  /**
+   * Fetch a user by ID
+   * @param {string} userId
+   * @returns {Promise<object>} User data
+   */
+  async fetchUser(userId) {
+    return await fetchUser(this, userId);
+  }
+
+  /**
+   * Create a DM channel with a user
+   * @param {string} recipientId
+   * @returns {Promise<object>} Channel data
+   */
+  async createDM(recipientId) {
+    return await createDM(this, recipientId);
+  }
+
+  /**
+   * Fetch webhooks for a channel
+   * @param {string} channelId - The channel ID
+   * @returns {Promise<Array>} Webhook data array
+   */
+  async fetchWebhooks(channelId) {
+    return await this.request(`/channels/${channelId}/webhooks`);
+  }
+
+  /**
+   * Create a webhook in a channel
+   * @param {string} channelId - The channel ID
+   * @param {string} name - Webhook name
+   * @param {object} [options={}] - Webhook options
+   * @param {string} [options.avatar] - Webhook avatar payload
+   * @param {string} [options.reason] - Audit log reason
+   * @returns {Promise<object>} Created webhook data
+   */
+  async createWebhook(channelId, name, options = {}) {
+    const headers = {};
+    if (options.reason) {
+      headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+    }
+
+    const body = { name };
+    const avatar = options.avatar || options.avatarURL;
+    if (avatar) {
+      body.avatar = avatar;
+    }
+
+    return await this.request(`/channels/${channelId}/webhooks`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Edit a message in a channel
+   * @param {string} channelId - The channel ID
+   * @param {string} messageId - The message ID
+   * @param {string|object} payload - New message content or payload object
+   * @returns {Promise<object>} The updated message data
+   */
+  async editMessage(channelId, messageId, payload) {
+    const updatedData = await this.request(
+      `/channels/${channelId}/messages/${messageId}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(
+          typeof payload === "string" ? { content: payload } : payload,
+        ),
+      },
+    );
+    return updatedData;
+  }
+
   /**
    * React to a message
    * @param {string} channelId - The channel ID

package/src/connection/rest/methods/createDM.js

@@ -0,0 +1,13 @@
+/**
+ * Create a DM channel with a recipient
+ * @param {RestManager} rest
+ * @param {string} recipientId
+ */
+async function createDM(rest, recipientId) {
+  return await rest.request(`/users/@me/channels`, {
+    method: "POST",
+    body: JSON.stringify({ recipient_id: recipientId }),
+  });
+}
+
+module.exports = createDM;

package/src/connection/rest/methods/fetchUser.js

@@ -0,0 +1,12 @@
+/**
+ * Fetch a user by ID
+ * @param {RestManager} rest
+ * @param {string} userId
+ */
+async function fetchUser(rest, userId) {
+  return await rest.request(`/users/${userId}`, {
+    method: "GET",
+  });
+}
+
+module.exports = fetchUser;

package/src/connection/ws/WebSocket.js

@@ -3,7 +3,7 @@ const { EventEmitter } = require("events");
 const Message = require("../../classes/Message");
 const Guild = require("../../classes/Guild");
 const Channel = require("../../classes/Channel");
-const User = require("../../classes/User");
+const ClientUser = require("../../classes/ClientUser");
 const WebSocketError = require("../../classes/WebSocketError");
 
 class DiscordWebSocket extends EventEmitter {
@@ -81,8 +81,7 @@ class DiscordWebSocket extends EventEmitter {
         this.startHeartbeat(message.d.heartbeat_interval);
         this.sendIdentify();
         break;
-      case 11: // Heartbeat ACK
-        // Heartbeat acknowledged
+      case 11: // Heartbeat acknowledged
         break;
       case 0: // Dispatch
         this.handleDispatch(message);
@@ -130,7 +129,7 @@ class DiscordWebSocket extends EventEmitter {
       case "READY":
         this.sessionId = message.d.session_id;
         this.client.sessionId = message.d.session_id;
-        this.client.user = new User(this.client, message.d.user);
+        this.client.user = new ClientUser(this.client, message.d.user);
 
         // Process guilds from READY payload
         if (message.d.guilds) {