lunibee 0.1.6 → 0.1.7

package/dist/core/index.js

@@ -107,58 +107,57 @@ var Permissions = {
   SendPolls: 1n << 49n,
   UseExternalApps: 1n << 50n
 };
-var PermissionFlagsBits;
-((PermissionFlagsBits2) => {
-  PermissionFlagsBits2["CreateInstantInvite"] = "1";
-  PermissionFlagsBits2["KickMembers"] = "2";
-  PermissionFlagsBits2["BanMembers"] = "4";
-  PermissionFlagsBits2["Administrator"] = "8";
-  PermissionFlagsBits2["ManageChannels"] = "16";
-  PermissionFlagsBits2["ManageGuild"] = "32";
-  PermissionFlagsBits2["AddReactions"] = "64";
-  PermissionFlagsBits2["ViewAuditLog"] = "128";
-  PermissionFlagsBits2["PrioritySpeaker"] = "256";
-  PermissionFlagsBits2["Stream"] = "512";
-  PermissionFlagsBits2["ViewChannel"] = "1024";
-  PermissionFlagsBits2["SendMessages"] = "2048";
-  PermissionFlagsBits2["SendTTSMessages"] = "4096";
-  PermissionFlagsBits2["ManageMessages"] = "8192";
-  PermissionFlagsBits2["EmbedLinks"] = "16384";
-  PermissionFlagsBits2["AttachFiles"] = "32768";
-  PermissionFlagsBits2["ReadMessageHistory"] = "65536";
-  PermissionFlagsBits2["MentionEveryone"] = "131072";
-  PermissionFlagsBits2["UseExternalEmojis"] = "262144";
-  PermissionFlagsBits2["ViewGuildInsights"] = "524288";
-  PermissionFlagsBits2["Connect"] = "1048576";
-  PermissionFlagsBits2["Speak"] = "2097152";
-  PermissionFlagsBits2["MuteMembers"] = "4194304";
-  PermissionFlagsBits2["DeafenMembers"] = "8388608";
-  PermissionFlagsBits2["MoveMembers"] = "16777216";
-  PermissionFlagsBits2["UseVAD"] = "33554432";
-  PermissionFlagsBits2["ChangeNickname"] = "67108864";
-  PermissionFlagsBits2["ManageNicknames"] = "134217728";
-  PermissionFlagsBits2["ManageRoles"] = "268435456";
-  PermissionFlagsBits2["ManageWebhooks"] = "536870912";
-  PermissionFlagsBits2["ManageGuildExpressions"] = "1073741824";
-  PermissionFlagsBits2["UseApplicationCommands"] = "2147483648";
-  PermissionFlagsBits2["RequestToSpeak"] = "4294967296";
-  PermissionFlagsBits2["ManageEvents"] = "8589934592";
-  PermissionFlagsBits2["ManageThreads"] = "17179869184";
-  PermissionFlagsBits2["CreatePublicThreads"] = "34359738368";
-  PermissionFlagsBits2["CreatePrivateThreads"] = "68719476736";
-  PermissionFlagsBits2["UseExternalStickers"] = "137438953472";
-  PermissionFlagsBits2["SendMessagesInThreads"] = "274877906944";
-  PermissionFlagsBits2["UseEmbeddedActivities"] = "549755813888";
-  PermissionFlagsBits2["ModerateMembers"] = "1099511627776";
-  PermissionFlagsBits2["ViewCreatorMonetizationAnalytics"] = "2199023255552";
-  PermissionFlagsBits2["UseSoundboard"] = "4398046511104";
-  PermissionFlagsBits2["CreateGuildExpressions"] = "8796093022208";
-  PermissionFlagsBits2["CreateEvents"] = "17592186044416";
-  PermissionFlagsBits2["UseExternalSounds"] = "35184372088832";
-  PermissionFlagsBits2["SendVoiceMessages"] = "70368744177664";
-  PermissionFlagsBits2["SendPolls"] = "562949953421312";
-  PermissionFlagsBits2["UseExternalApps"] = "1125899906842624";
-})(PermissionFlagsBits ||= {});
+var PermissionFlagsBits = {
+  CreateInstantInvite: 1n << 0n,
+  KickMembers: 1n << 1n,
+  BanMembers: 1n << 2n,
+  Administrator: 1n << 3n,
+  ManageChannels: 1n << 4n,
+  ManageGuild: 1n << 5n,
+  AddReactions: 1n << 6n,
+  ViewAuditLog: 1n << 7n,
+  PrioritySpeaker: 1n << 8n,
+  Stream: 1n << 9n,
+  ViewChannel: 1n << 10n,
+  SendMessages: 1n << 11n,
+  SendTTSMessages: 1n << 12n,
+  ManageMessages: 1n << 13n,
+  EmbedLinks: 1n << 14n,
+  AttachFiles: 1n << 15n,
+  ReadMessageHistory: 1n << 16n,
+  MentionEveryone: 1n << 17n,
+  UseExternalEmojis: 1n << 18n,
+  ViewGuildInsights: 1n << 19n,
+  Connect: 1n << 20n,
+  Speak: 1n << 21n,
+  MuteMembers: 1n << 22n,
+  DeafenMembers: 1n << 23n,
+  MoveMembers: 1n << 24n,
+  UseVAD: 1n << 25n,
+  ChangeNickname: 1n << 26n,
+  ManageNicknames: 1n << 27n,
+  ManageRoles: 1n << 28n,
+  ManageWebhooks: 1n << 29n,
+  ManageGuildExpressions: 1n << 30n,
+  UseApplicationCommands: 1n << 31n,
+  RequestToSpeak: 1n << 32n,
+  ManageEvents: 1n << 33n,
+  ManageThreads: 1n << 34n,
+  CreatePublicThreads: 1n << 35n,
+  CreatePrivateThreads: 1n << 36n,
+  UseExternalStickers: 1n << 37n,
+  SendMessagesInThreads: 1n << 38n,
+  UseEmbeddedActivities: 1n << 39n,
+  ModerateMembers: 1n << 40n,
+  ViewCreatorMonetizationAnalytics: 1n << 41n,
+  UseSoundboard: 1n << 42n,
+  CreateGuildExpressions: 1n << 43n,
+  CreateEvents: 1n << 44n,
+  UseExternalSounds: 1n << 45n,
+  SendVoiceMessages: 1n << 46n,
+  SendPolls: 1n << 49n,
+  UseExternalApps: 1n << 50n
+};
 
 class PermissionSet {
   bitfield;
@@ -403,7 +402,7 @@ class PermissionSet {
       if (permission in Permissions)
         return Permissions[permission];
       if (permission in PermissionFlagsBits)
-        return BigInt(PermissionFlagsBits[permission]);
+        return PermissionFlagsBits[permission];
       const lower = permission.charAt(0).toLowerCase() + permission.slice(1);
       if (lower in Permission)
         return Permission[lower];
@@ -424,6 +423,8 @@ class PermissionsBitField extends PermissionSet {
 var ClientEvent;
 ((ClientEvent2) => {
   ClientEvent2["Ready"] = "ready";
+  ClientEvent2["Resumed"] = "resumed";
+  ClientEvent2["InvalidSession"] = "invalidSession";
   ClientEvent2["Raw"] = "raw";
   ClientEvent2["Error"] = "error";
   ClientEvent2["Open"] = "open";
@@ -486,6 +487,76 @@ var ClientEvent;
   ClientEvent2["TypingStart"] = "typingStart";
   ClientEvent2["InteractionCreate"] = "interactionCreate";
 })(ClientEvent ||= {});
+// packages/core/src/collector.ts
+import { EventEmitter } from "events";
+
+class Collector extends EventEmitter {
+  collected = new Map;
+  options;
+  ended = false;
+  endReason;
+  totalProcessed = 0;
+  #timeoutTimer;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    if (options.time && options.time > 0) {
+      this.#timeoutTimer = setTimeout(() => {
+        this.stop("time");
+      }, options.time);
+    }
+  }
+  async handle(key, item) {
+    if (this.ended)
+      return false;
+    this.totalProcessed++;
+    const reachedProcessed = !!this.options.maxProcessed && this.totalProcessed >= this.options.maxProcessed;
+    let passed = true;
+    if (this.options.filter)
+      passed = !!await this.options.filter(item);
+    if (this.ended)
+      return false;
+    if (!passed) {
+      if (reachedProcessed)
+        this.stop("processedLimit");
+      return false;
+    }
+    this.collected.set(key, item);
+    this.emit("collect", item);
+    if (this.options.max && this.collected.size >= this.options.max) {
+      this.stop("limit");
+      return true;
+    }
+    if (reachedProcessed) {
+      this.stop("processedLimit");
+      return true;
+    }
+    return true;
+  }
+  stop(reason = "user") {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.endReason = reason;
+    if (this.#timeoutTimer)
+      clearTimeout(this.#timeoutTimer);
+    this.emit("end", this.collected, reason);
+    this.removeAllListeners();
+  }
+  next() {
+    return new Promise((resolve, reject) => {
+      if (this.ended) {
+        return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
+      }
+      this.once("collect", (item) => {
+        resolve(item);
+      });
+      this.once("end", (_collected, reason) => {
+        reject(new Error(`Collector ended before item was collected: ${reason}`));
+      });
+    });
+  }
+}
 // packages/types/src/index.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
@@ -716,6 +787,75 @@ class Collection extends Map {
     }
     return result;
   }
+  partition(predicate) {
+    const pass = new Collection;
+    const fail = new Collection;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        pass.set(key, value);
+      else
+        fail.set(key, value);
+    }
+    return [pass, fail];
+  }
+  tap(fn) {
+    fn(this);
+    return this;
+  }
+  flatMap(transform) {
+    const result = [];
+    for (const [key, value] of this) {
+      for (const item of transform(value, key, this))
+        result.push(item);
+    }
+    return result;
+  }
+  reduce(fn, initialValue) {
+    let acc = initialValue;
+    for (const [key, value] of this)
+      acc = fn(acc, value, key, this);
+    return acc;
+  }
+  sorted(comparator) {
+    const decorated = [...this.entries()].map((entry, index) => ({
+      entry,
+      index
+    }));
+    if (comparator)
+      decorated.sort((x, y) => {
+        const comparison = comparator(x.entry[1], y.entry[1], x.entry[0], y.entry[0]);
+        return comparison !== 0 ? comparison : x.index - y.index;
+      });
+    const result = new Collection;
+    for (const { entry } of decorated)
+      result.set(entry[0], entry[1]);
+    return result;
+  }
+  random() {
+    const arr = [...this.values()];
+    if (!arr.length)
+      return;
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  randomKey() {
+    const arr = [...this.keys()];
+    if (!arr.length)
+      return;
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  at(index) {
+    const arr = [...this.values()];
+    const i = index < 0 ? arr.length + index : index;
+    return arr[i];
+  }
+  keyAt(index) {
+    const arr = [...this.keys()];
+    const i = index < 0 ? arr.length + index : index;
+    return arr[i];
+  }
+  toJSON() {
+    return [...this.entries()];
+  }
 }
 
 // packages/managers/src/base.ts
@@ -787,7 +927,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.6",
+  version: "0.1.7",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -796,6 +936,45 @@ var package_default = {
   }
 };
 
+// packages/rest/src/store.ts
+class MemoryRateLimitStore {
+  #buckets = new Map;
+  #routeBuckets = new Map;
+  #globalResetAt = 0;
+  static #PRUNE_INTERVAL = 60000;
+  #lastPruneAt = 0;
+  getBucketHash(route) {
+    return this.#routeBuckets.get(route);
+  }
+  setBucketHash(route, hash) {
+    this.#routeBuckets.set(route, hash);
+  }
+  getBucket(key) {
+    return this.#buckets.get(key);
+  }
+  updateBucket(key, state) {
+    this.#buckets.set(key, state);
+    const now = Date.now();
+    if (now - this.#lastPruneAt >= MemoryRateLimitStore.#PRUNE_INTERVAL) {
+      this.#lastPruneAt = now;
+      this.prune();
+    }
+  }
+  prune(maxAge = 0) {
+    const cutoff = Date.now() - Math.max(0, maxAge);
+    for (const [key, state] of this.#buckets) {
+      if (state.resetAt <= cutoff)
+        this.#buckets.delete(key);
+    }
+  }
+  getGlobalReset() {
+    return this.#globalResetAt;
+  }
+  setGlobalReset(resetAt) {
+    this.#globalResetAt = resetAt;
+  }
+}
+
 // packages/rest/src/routes.ts
 var Routes = {
   user: () => "/users/@me",
@@ -841,7 +1020,18 @@ var Routes = {
   guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
   voiceRegions: () => "/voice/regions",
   gateway: () => "/gateway",
-  gatewayBot: () => "/gateway/bot"
+  gatewayBot: () => "/gateway/bot",
+  guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
+  guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
+  guildWelcomeScreen: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/welcome-screen`,
+  guildOnboarding: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/onboarding`,
+  guildPrune: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/prune`,
+  stageInstances: () => "/stage-instances",
+  stageInstanceByChannel: (channelId) => `/stage-instances/${snowflake(channelId, "Channel ID")}`,
+  invite: (code) => `/invites/${encodeURIComponent(code)}`,
+  guildVanity: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/vanity-url`,
+  guildEmoji: (guildId, emojiId) => emojiId ? `/guilds/${snowflake(guildId, "Guild ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/emojis`,
+  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`
 };
 function snowflake(value, field) {
   if (!/^\d{1,20}$/.test(value))
@@ -869,6 +1059,49 @@ class RESTError extends Error {
 var LIBRARY_VERSION = package_default.version;
 var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
 var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
+var REQUEST_DATA_KEYS = new Set([
+  "body",
+  "files",
+  "query",
+  "headers",
+  "reason",
+  "auth",
+  "signal"
+]);
+function isRequestData(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData)
+    return false;
+  if (value instanceof Blob || value instanceof Uint8Array || value instanceof ArrayBuffer)
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return false;
+  return keys.every((key) => REQUEST_DATA_KEYS.has(key));
+}
+function serializeQuery(query) {
+  if (query === undefined)
+    return "";
+  if (typeof query === "string")
+    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
+  const serialized = params.toString();
+  return serialized.length === 0 ? "" : `?${serialized}`;
+}
+function majorParameter(path) {
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  if (!match)
+    return "@none";
+  if (match[1] === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${match[3]}`;
+  return match[2];
+}
+function scopeBucket(hashOrRoute, major) {
+  return `${hashOrRoute}|${major}`;
+}
 function createRetryPolicy(maxRetries = 2) {
   if (!Number.isFinite(maxRetries) || maxRetries < 0)
     throw new TypeError("maxRetries must be a non-negative finite number.");
@@ -891,14 +1124,21 @@ class REST {
   #timeout;
   #retryPolicy;
   #token;
-  #globalResetAt = 0;
-  #buckets = new Map;
-  #routeBuckets = new Map;
+  #store;
+  #localQueues = new Map;
+  #hooks = {};
   constructor(options = {}) {
     this.#token = options.token;
     this.#timeout = Math.max(1, options.timeout ?? 15000);
     this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
     this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    this.#store = options.store ?? new MemoryRateLimitStore;
+    if (options.hooks)
+      this.#hooks = options.hooks;
+  }
+  setHooks(hooks) {
+    this.#hooks = hooks;
+    return this;
   }
   setToken(token) {
     if (!token.trim())
@@ -911,56 +1151,91 @@ class REST {
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    const files = options.files;
+    if (files && files.length > 0 && !(body instanceof FormData))
+      body = this.#fileForm(body, files);
+    const query = serializeQuery(options.query);
+    const finalPath = query ? `${path}${query}` : path;
     const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    let bucketKey = this.#routeBuckets.get(route) ?? route;
-    let bucket = this.#buckets.get(bucketKey) ?? {
-      remaining: 1,
-      resetAt: 0,
-      queue: Promise.resolve()
-    };
-    this.#buckets.set(bucketKey, bucket);
-    const previous = bucket.queue;
+    const major = majorParameter(path);
+    let bucketKey = scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
+    const queueKey = bucketKey;
+    const previous = this.#localQueues.get(queueKey) ?? Promise.resolve();
     let release;
-    bucket.queue = new Promise((resolve) => {
+    const gate = new Promise((resolve) => {
       release = resolve;
     });
+    this.#localQueues.set(queueKey, gate);
     await this.#abortable(previous, options.signal, path);
     try {
       for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucket, options.signal, path);
+        await this.#wait(bucketKey, options.signal, path);
         await this.#waitGlobal(options.signal, path);
         const controller = new AbortController;
         const onAbort = () => controller.abort(options.signal?.reason);
         if (options.signal?.aborted)
           throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, { once: true });
+        options.signal?.addEventListener("abort", onAbort, {
+          once: true
+        });
         const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
         const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
-        const headers = {
-          ...this.#token ? { Authorization: `Bot ${this.#token}` } : {},
-          "User-Agent": USER_AGENT
-        };
+        const headers = { ...options.headers };
+        if (options.auth !== false && this.#token)
+          headers["Authorization"] = `Bot ${this.#token}`;
+        headers["User-Agent"] = USER_AGENT;
+        if (options.reason !== undefined)
+          headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
         if (!isFormData)
           headers["Content-Type"] = "application/json";
         const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
         try {
-          const response = await fetch(`${this.#baseURL}${path}`, {
+          this.#emit(this.#hooks.onRequest, {
+            method: normalizedMethod,
+            path,
+            attempt
+          });
+          const requestStart = Date.now();
+          const response = await fetch(`${this.#baseURL}${finalPath}`, {
             method: normalizedMethod,
             headers,
             body: fetchBody,
             signal: controller.signal
           });
-          bucket = this.#update(response, bucket, route, bucketKey);
-          bucketKey = this.#routeBuckets.get(route) ?? bucketKey;
+          this.#emit(this.#hooks.onResponse, {
+            method: normalizedMethod,
+            path,
+            status: response.status,
+            durationMs: Date.now() - requestStart
+          });
+          bucketKey = await this.#update(response, bucketKey, route, major);
           const payload = await this.#readPayload(response);
           if (response.ok)
             return response.status === 204 ? undefined : payload;
           const data = this.#errorData(payload);
           const retryAfter = response.status === 429 ? this.#retryAfter(response, data) : undefined;
-          if (data.global && retryAfter !== undefined)
-            this.#globalResetAt = Date.now() + retryAfter * 1000;
+          if (data.global && retryAfter !== undefined) {
+            const currentGlobal = await this.#store.getGlobalReset();
+            await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+          }
+          if (response.status === 429)
+            this.#emit(this.#hooks.onRateLimit, {
+              method: normalizedMethod,
+              path,
+              retryAfterMs: (retryAfter ?? 1) * 1000,
+              global: data.global ?? false,
+              bucket: await this.#store.getBucketHash(route)
+            });
           if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt, retryAfter), options.signal, path);
+            const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
+            this.#emit(this.#hooks.onRetry, {
+              method: normalizedMethod,
+              path,
+              attempt,
+              status: response.status,
+              delayMs: delay
+            });
+            await this.#sleep(delay, options.signal, path);
             continue;
           }
           throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method: normalizedMethod, path });
@@ -983,22 +1258,29 @@ class REST {
       throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method: normalizedMethod, path });
     } finally {
       release();
+      if (this.#localQueues.get(queueKey) === gate)
+        this.#localQueues.delete(queueKey);
     }
   }
+  #dispatch(method, path, bodyOrOptions, options) {
+    if (options === undefined && isRequestData(bodyOrOptions))
+      return this.request(method, path, bodyOrOptions.body, bodyOrOptions);
+    return this.request(method, path, bodyOrOptions, options);
+  }
   get(path, options) {
-    return this.request("GET", path, undefined, options);
+    return this.request("GET", path, options?.body, options);
   }
   post(path, body, options) {
-    return this.request("POST", path, body, options);
+    return this.#dispatch("POST", path, body, options);
   }
   patch(path, body, options) {
-    return this.request("PATCH", path, body, options);
+    return this.#dispatch("PATCH", path, body, options);
   }
   put(path, body, options) {
-    return this.request("PUT", path, body, options);
+    return this.#dispatch("PUT", path, body, options);
   }
   delete(path, options) {
-    return this.request("DELETE", path, undefined, options);
+    return this.request("DELETE", path, options?.body, options);
   }
   #fileForm(payload, files) {
     const form = new FormData;
@@ -1018,13 +1300,22 @@ class REST {
   patchWithFiles(path, payload, files, options) {
     return this.request("PATCH", path, this.#fileForm(payload, files), options);
   }
-  async#wait(bucket, signal, path) {
+  #emit(hook, ctx) {
+    if (!hook)
+      return;
+    Promise.resolve().then(() => hook(ctx)).catch(() => {});
+  }
+  async#wait(bucketKey, signal, path) {
+    const bucket = await this.#store.getBucket(bucketKey);
+    if (!bucket)
+      return;
     const delay = bucket.resetAt - Date.now();
     if (bucket.remaining <= 0 && delay > 0)
       await this.#sleep(delay, signal, path);
   }
   async#waitGlobal(signal, path) {
-    const delay = this.#globalResetAt - Date.now();
+    const globalResetAt = await this.#store.getGlobalReset();
+    const delay = globalResetAt - Date.now();
     if (delay > 0)
       await this.#sleep(delay, signal, path);
   }
@@ -1088,16 +1379,17 @@ class REST {
     const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
     return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
   }
-  #update(response, bucket, route, bucketKey) {
+  async#update(response, bucketKey, route, major) {
+    let currentKey = bucketKey;
     const serverBucket = response.headers.get("X-RateLimit-Bucket");
     if (serverBucket) {
-      this.#routeBuckets.set(route, serverBucket);
-      if (serverBucket !== bucketKey) {
-        const shared = this.#buckets.get(serverBucket) ?? bucket;
-        this.#buckets.set(serverBucket, shared);
-        bucket = shared;
-      }
+      await this.#store.setBucketHash(route, serverBucket);
+      currentKey = scopeBucket(serverBucket, major);
     }
+    let bucket = await this.#store.getBucket(currentKey) ?? {
+      remaining: 1,
+      resetAt: 0
+    };
     const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
     const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
     const reset = Number(response.headers.get("X-RateLimit-Reset"));
@@ -1112,12 +1404,15 @@ class REST {
       if (Number.isFinite(retryAfter))
         bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
     }
+    await this.#store.updateBucket(currentKey, bucket);
     if (response.headers.get("X-RateLimit-Global") === "true") {
       const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        this.#globalResetAt = Math.max(this.#globalResetAt, Date.now() + retryAfter * 1000);
+      if (Number.isFinite(retryAfter)) {
+        const currentGlobal = await this.#store.getGlobalReset();
+        await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+      }
     }
-    return bucket;
+    return currentKey;
   }
 }
 
@@ -1263,6 +1558,13 @@ class Guild extends BaseStructure {
   vanityUrlCode;
   nsfwLevel;
   discoverySplash;
+  rulesChannelId;
+  systemChannelId;
+  systemChannelFlags;
+  maxMembers;
+  mfaLevel;
+  explicitContentFilter;
+  defaultMessageNotifications;
   constructor(data) {
     super(data.id);
     if (!data.name)
@@ -1284,6 +1586,14 @@ class Guild extends BaseStructure {
     this.vanityUrlCode = data.vanity_url_code ?? null;
     this.nsfwLevel = data.nsfw_level ?? 0;
     this.discoverySplash = data.discovery_splash ?? null;
+    const d = data;
+    this.rulesChannelId = d.rules_channel_id ?? null;
+    this.systemChannelId = d.system_channel_id ?? null;
+    this.systemChannelFlags = d.system_channel_flags ?? 0;
+    this.maxMembers = d.max_members ?? 0;
+    this.mfaLevel = d.mfa_level ?? 0;
+    this.explicitContentFilter = d.explicit_content_filter ?? 0;
+    this.defaultMessageNotifications = d.default_message_notifications ?? 0;
   }
   iconURL(options = {}) {
     if (!this.icon)
@@ -1305,12 +1615,27 @@ class Guild extends BaseStructure {
       return null;
     return cdnURL(`/discovery-splashes/${this.id}`, this.discoverySplash, options);
   }
+  widgetImageURL(style = "shield") {
+    return `https://discord.com/api/guilds/${this.id}/widget.png?style=${style}`;
+  }
   hasFeature(feature) {
     return this.features.includes(feature);
   }
   get isCommunity() {
     return this.hasFeature("COMMUNITY");
   }
+  get isPartnered() {
+    return this.hasFeature("PARTNERED");
+  }
+  get isVerified() {
+    return this.hasFeature("VERIFIED");
+  }
+  get isBoosted() {
+    return this.premiumSubscriptionCount > 0;
+  }
+  get boostLevel() {
+    return this.premiumTier;
+  }
   get hasVanityUrl() {
     return this.vanityUrlCode !== null;
   }
@@ -1321,58 +1646,49 @@ class Guild extends BaseStructure {
     return this.name;
   }
 }
-// packages/structures/src/permissions.ts
-var Permissions2 = {
-  CreateInstantInvite: 1n << 0n,
-  KickMembers: 1n << 1n,
-  BanMembers: 1n << 2n,
-  Administrator: 1n << 3n,
-  ManageChannels: 1n << 4n,
-  ManageGuild: 1n << 5n,
-  AddReactions: 1n << 6n,
-  ViewAuditLog: 1n << 7n,
-  PrioritySpeaker: 1n << 8n,
-  Stream: 1n << 9n,
-  ViewChannel: 1n << 10n,
-  SendMessages: 1n << 11n,
-  SendTTSMessages: 1n << 12n,
-  ManageMessages: 1n << 13n,
-  EmbedLinks: 1n << 14n,
-  AttachFiles: 1n << 15n,
-  ReadMessageHistory: 1n << 16n,
-  MentionEveryone: 1n << 17n,
-  UseExternalEmojis: 1n << 18n,
-  ViewGuildInsights: 1n << 19n,
-  Connect: 1n << 20n,
-  Speak: 1n << 21n,
-  MuteMembers: 1n << 22n,
-  DeafenMembers: 1n << 23n,
-  MoveMembers: 1n << 24n,
-  UseVAD: 1n << 25n,
-  ChangeNickname: 1n << 26n,
-  ManageNicknames: 1n << 27n,
-  ManageRoles: 1n << 28n,
-  ManageWebhooks: 1n << 29n,
-  ManageGuildExpressions: 1n << 30n,
-  UseApplicationCommands: 1n << 31n,
-  RequestToSpeak: 1n << 32n,
-  ManageEvents: 1n << 33n,
-  ManageThreads: 1n << 34n,
-  CreatePublicThreads: 1n << 35n,
-  CreatePrivateThreads: 1n << 36n,
-  UseExternalStickers: 1n << 37n,
-  SendMessagesInThreads: 1n << 38n,
-  UseEmbeddedActivities: 1n << 39n,
-  ModerateMembers: 1n << 40n,
-  ViewCreatorMonetizationAnalytics: 1n << 41n,
-  UseSoundboard: 1n << 42n,
-  CreateGuildExpressions: 1n << 43n,
-  CreateEvents: 1n << 44n,
-  UseExternalSounds: 1n << 45n,
-  SendVoiceMessages: 1n << 46n,
-  SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
-};
+// packages/structures/src/resources.ts
+class AutoModerationRule extends BaseStructure {
+  guildId;
+  name;
+  creatorId;
+  eventType;
+  triggerType;
+  triggerMetadata;
+  actions;
+  enabled;
+  exemptRoles;
+  exemptChannels;
+  constructor(data) {
+    super(data.id);
+    if (!/^\d{1,20}$/.test(data.guild_id))
+      throw new TypeError("AutoModerationRule guild_id must be a valid snowflake.");
+    this.guildId = data.guild_id;
+    this.name = data.name;
+    this.creatorId = data.creator_id;
+    this.eventType = data.event_type;
+    this.triggerType = data.trigger_type;
+    this.triggerMetadata = data.trigger_metadata;
+    this.actions = data.actions;
+    this.enabled = data.enabled;
+    this.exemptRoles = data.exempt_roles;
+    this.exemptChannels = data.exempt_channels;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      guildId: this.guildId,
+      name: this.name,
+      creatorId: this.creatorId,
+      eventType: this.eventType,
+      triggerType: this.triggerType,
+      triggerMetadata: this.triggerMetadata,
+      actions: this.actions,
+      enabled: this.enabled,
+      exemptRoles: this.exemptRoles,
+      exemptChannels: this.exemptChannels
+    };
+  }
+}
 // packages/structures/src/interactions.ts
 var InteractionType = {
   Ping: 1,
@@ -1663,8 +1979,7 @@ class CommandInteraction extends Interaction {
     super(client, data);
     const rawOptions = data.data?.options ?? [];
     const resolved = data.data?.resolved ?? {};
-    const sub = rawOptions.find((o) => o.type === 1 || o.type === 2);
-    this.options = new CommandOptions(sub?.options ?? rawOptions, resolved);
+    this.options = new CommandOptions(rawOptions, resolved);
   }
 }
 
@@ -1758,6 +2073,8 @@ function createInteraction(client, data) {
 }
 
 // packages/structures/src/index.ts
+var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
+
 class Message extends BaseStructure {
   content;
   author;
@@ -1803,6 +2120,12 @@ class Message extends BaseStructure {
   get embedsSuppressed() {
     return (this.flags & 4) !== 0;
   }
+  get createdTimestamp() {
+    return this.timestamp.getTime();
+  }
+  get createdAt() {
+    return this.timestamp;
+  }
   edit(options) {
     if (!this.#context)
       throw new Error("This message is not attached to a client.");
@@ -1857,6 +2180,51 @@ class Message extends BaseStructure {
       throw new Error("This message is not attached to a client.");
     return this.#context.unpinMessage(this.channelId, this.id);
   }
+  get isEphemeral() {
+    return (this.flags & 64) !== 0;
+  }
+  get isPinned() {
+    return this.pinned;
+  }
+  get isSystemMessage() {
+    return !NON_SYSTEM_MESSAGE_TYPES.has(this.type);
+  }
+  get isCrosspost() {
+    return (this.flags & 2) !== 0;
+  }
+  get hasAttachments() {
+    return this.attachments.length > 0;
+  }
+  get hasEmbeds() {
+    return this.embeds.length > 0;
+  }
+  get hasComponents() {
+    return this.components.length > 0;
+  }
+  suppressEmbeds() {
+    return this.edit({ flags: this.flags | 4 });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      content: this.content,
+      channelId: this.channelId,
+      guildId: this.guildId,
+      flags: this.flags,
+      pinned: this.pinned,
+      mentionEveryone: this.mentionEveryone,
+      type: this.type,
+      timestamp: this.timestamp.toISOString(),
+      author: { id: this.author.id, username: this.author.username },
+      attachments: [...this.attachments],
+      embeds: [...this.embeds],
+      components: [...this.components],
+      mentions: this.mentions.map((u) => u.id),
+      mentionRoles: [...this.mentionRoles],
+      reference: this.reference,
+      referencedMessage: this.referencedMessage ? this.referencedMessage.id : this.referencedMessage
+    };
+  }
 }
 
 // packages/managers/src/message.ts
@@ -1948,6 +2316,11 @@ class UserManager extends ResourceManager {
   }
 }
 // packages/managers/src/guild.ts
+function withQuery(path, params) {
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
 class GuildManager extends ResourceManager {
   #rest;
   constructor(rest) {
@@ -1977,6 +2350,47 @@ class GuildManager extends ResourceManager {
   async fetchInvites(id) {
     return this.#rest.get(Routes.guildInvites(id));
   }
+  async fetchAuditLog(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.userId)
+      params.set("user_id", options.userId);
+    if (options.actionType !== undefined)
+      params.set("action_type", String(options.actionType));
+    if (options.before)
+      params.set("before", options.before);
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    return this.#rest.get(withQuery(Routes.guildAuditLog(guildId), params));
+  }
+  async fetchMembers(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
+    if (options.after)
+      params.set("after", options.after);
+    return this.#rest.get(withQuery(Routes.guildMembers(guildId), params));
+  }
+  async fetchAutoModerationRules(guildId) {
+    const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
+    return rules.map((r) => new AutoModerationRule(r));
+  }
+  async fetchAutoModerationRule(guildId, ruleId) {
+    const rule = await this.#rest.get(Routes.guildAutoModerationRule(guildId, ruleId));
+    return new AutoModerationRule(rule);
+  }
+  async createAutoModerationRule(guildId, options) {
+    const rule = await this.#rest.post(Routes.guildAutoModerationRules(guildId), options);
+    return new AutoModerationRule(rule);
+  }
+  async editAutoModerationRule(guildId, ruleId, options) {
+    const rule = await this.#rest.patch(Routes.guildAutoModerationRule(guildId, ruleId), options);
+    return new AutoModerationRule(rule);
+  }
+  async deleteAutoModerationRule(guildId, ruleId) {
+    await this.#rest.delete(Routes.guildAutoModerationRule(guildId, ruleId));
+  }
 }
 // packages/managers/src/application.ts
 class ApplicationCommandManager {
@@ -2079,8 +2493,11 @@ class ChannelManager extends Manager {
   }
   async deleteChannel(channelId) {
     await this.#rest.delete(Routes.channel(channelId));
+    this.delete(channelId);
+  }
+  delete(channelId) {
     this.#messageManagers.delete(channelId);
-    super.delete(channelId);
+    return super.delete(channelId);
   }
   send(channelId, options) {
     return this.messages(channelId).send(options);
@@ -2125,6 +2542,8 @@ class ChannelManager extends Manager {
   }
   async bulkDeleteMessages(channelId, messageIds) {
     const ids = [...messageIds];
+    if (ids.length < 2 || ids.length > 100)
+      throw new RangeError("bulkDelete requires between 2 and 100 message IDs.");
     await this.#rest.post(Routes.channelBulkDelete(channelId), {
       messages: ids
     });
@@ -2132,7 +2551,7 @@ class ChannelManager extends Manager {
       this.messages(channelId).delete(id);
   }
   async addReaction(channelId, messageId, emoji) {
-    await this.#rest.put(Routes.messageReactions(channelId, messageId, emoji));
+    await this.#rest.put(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
   }
   async fetchReactions(channelId, messageId, emoji, options = {}) {
     const params = new URLSearchParams;
@@ -2166,9 +2585,21 @@ class ChannelManager extends Manager {
   createThreadFromMessage(channelId, messageId, options) {
     return this.threads(channelId).createFromMessage(messageId, options);
   }
-  delete(channelId) {
-    this.#messageManagers.delete(channelId);
-    return super.delete(channelId);
+  async fetchPage(channelId, options = {}) {
+    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+    const messages = await this.fetchMessages(channelId, {
+      ...options,
+      limit
+    });
+    return {
+      messages,
+      before: messages[0]?.id,
+      after: messages[messages.length - 1]?.id,
+      hasMore: messages.length === limit
+    };
+  }
+  async bulkDelete(channelId, messageIds) {
+    return this.bulkDeleteMessages(channelId, messageIds);
   }
   clear() {
     this.#messageManagers.clear();
@@ -2193,6 +2624,22 @@ var GatewayOpcodes = {
   Hello: 10,
   HeartbeatAck: 11
 };
+var GatewayCloseCodes = {
+  UnknownError: 4000,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSeq: 4007,
+  RateLimited: 4008,
+  SessionTimedOut: 4009,
+  InvalidShard: 4010,
+  ShardingRequired: 4011,
+  InvalidAPIVersion: 4012,
+  InvalidIntents: 4013,
+  DisallowedIntents: 4014
+};
 class GatewayError extends Error {
   code;
   constructor(message, code, options) {
@@ -2226,6 +2673,8 @@ class Gateway {
   #rejectConnect;
   #listeners = new Map;
   #sendTimestamps = [];
+  ping = -1;
+  #decompressor;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Gateway token is required.");
@@ -2246,7 +2695,12 @@ class Gateway {
         browser: "Discord Android",
         device: "Discord Android"
       },
-      presence: { status: "online", activities: [], afk: false, since: null },
+      presence: {
+        status: "online",
+        activities: [],
+        afk: false,
+        since: null
+      },
       ...options
     };
     if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
@@ -2261,10 +2715,13 @@ class Gateway {
       return this.#connectPromise;
     this.#closed = false;
     this.#setState("CONNECT" /* Connect */);
+    const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}&compress=zlib-stream` : url;
+    if (this.#options.compress)
+      this.#initDecompressor();
     this.#connectPromise = new Promise((resolve, reject) => {
       this.#resolveConnect = resolve;
       this.#rejectConnect = reject;
-      this.#open(url);
+      this.#open(connectURL);
     });
     return this.#connectPromise;
   }
@@ -2300,12 +2757,15 @@ class Gateway {
   send(payload) {
     if (!payload || !Number.isInteger(payload.op))
       throw new TypeError("Gateway payload must contain an integer opcode.");
+    return this.#dispatch(payload, false);
+  }
+  #dispatch(payload, privileged) {
     if (this.#ws?.readyState !== WebSocket.OPEN)
       return false;
     const now = Date.now();
     while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
       this.#sendTimestamps.shift();
-    if (this.#sendTimestamps.length >= 115) {
+    if (!privileged && this.#sendTimestamps.length >= 115) {
       this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
       return false;
     }
@@ -2376,7 +2836,11 @@ class Gateway {
     ws.addEventListener("message", (event) => {
       this.#lastMessageAt = Date.now();
       this.#zombieReported = false;
-      this.#message(ws, String(event.data));
+      if (this.#options.compress && event.data instanceof ArrayBuffer) {
+        this.#decompress(new Uint8Array(event.data)).then((text) => this.#message(ws, text)).catch((err) => this.#emitError(err));
+      } else {
+        this.#message(ws, String(event.data));
+      }
     });
     ws.addEventListener("close", (event) => this.#close(ws, event.code));
     ws.addEventListener("error", () => this.#emitError(new GatewayError("Gateway WebSocket error")));
@@ -2384,7 +2848,7 @@ class Gateway {
   #startZombieDetection() {
     if (this.#zombieTimer)
       clearInterval(this.#zombieTimer);
-    const interval = Math.max(1, Math.min(250, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
+    const interval = Math.max(1, Math.min(1000, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
     this.#zombieTimer = setInterval(() => {
       if (this.#closed || this.#ws?.readyState !== WebSocket.OPEN || this.#lastMessageAt === 0)
         return;
@@ -2435,18 +2899,24 @@ class Gateway {
         break;
       case GatewayOpcodes.HeartbeatAck:
         this.#heartbeatACK = true;
+        this.ping = Date.now() - this.#heartbeatSentAt;
         this.#clearHeartbeatAckTimer();
         this.#emit("heartbeatAck", payload.d);
         break;
       case GatewayOpcodes.Reconnect:
         ws.close(1001, "Server requested reconnect");
         break;
-      case GatewayOpcodes.InvalidSession:
-        this.#sessionId = undefined;
-        this.#sequence = null;
-        this.#emit("invalidSession", payload.d);
-        ws.close(1000, "Invalid session");
+      case GatewayOpcodes.InvalidSession: {
+        const resumable = payload.d === true;
+        if (!resumable) {
+          this.#sessionId = undefined;
+          this.#sequence = null;
+          this.#resumeURL = undefined;
+        }
+        this.#emit("invalidSession", resumable);
+        ws.close(resumable ? GatewayCloseCodes.UnknownError : 1000, resumable ? "Invalid session (resumable)" : "Invalid session");
         break;
+      }
     }
   }
   #handleDispatch(event, data) {
@@ -2461,6 +2931,10 @@ class Gateway {
       this.#attempt = 0;
       this.#setState("READY" /* Ready */);
       this.#emit("ready", data);
+    } else if (event === "RESUMED") {
+      this.#attempt = 0;
+      this.#setState("READY" /* Ready */);
+      this.#emit("resumed", data);
     }
     this.#emit("RAW", { event: event ?? "UNKNOWN", data });
     if (this.#closed)
@@ -2538,12 +3012,12 @@ class Gateway {
   #sendHeartbeat() {
     this.#heartbeatACK = false;
     this.#heartbeatSentAt = Date.now();
-    if (!this.send({
+    if (!this.#dispatch({
       op: GatewayOpcodes.Heartbeat,
       d: this.#sequence,
       s: null,
       t: null
-    })) {
+    }, true)) {
       this.#emitError(new GatewayError("Unable to send Gateway heartbeat because the WebSocket is not open."));
       return;
     }
@@ -2576,14 +3050,23 @@ class Gateway {
     if (action === "identify") {
       this.#sequence = null;
       this.#sessionId = undefined;
+      this.#resumeURL = undefined;
     }
     this.#setState("RECONNECT" /* Reconnect */);
     this.#scheduleReconnect();
   }
   #closeAction(code) {
-    if ([4004, 4010, 4011, 4012, 4013, 4014].includes(code))
+    const fatal = [
+      GatewayCloseCodes.AuthenticationFailed,
+      GatewayCloseCodes.InvalidShard,
+      GatewayCloseCodes.ShardingRequired,
+      GatewayCloseCodes.InvalidAPIVersion,
+      GatewayCloseCodes.InvalidIntents,
+      GatewayCloseCodes.DisallowedIntents
+    ];
+    if (fatal.includes(code))
       return "stop";
-    if ([4007, 4009].includes(code))
+    if (code === GatewayCloseCodes.InvalidSeq || code === GatewayCloseCodes.SessionTimedOut)
       return "identify";
     return this.#sessionId && this.#sequence !== null ? "resume" : "identify";
   }
@@ -2596,7 +3079,7 @@ class Gateway {
       return;
     }
     const delay = Math.min(this.#options.reconnectMaxDelay, this.#options.reconnectBaseDelay * 2 ** this.#attempt++);
-    const jitter = Math.random() * Math.min(250, Math.max(1, delay * 0.25));
+    const jitter = Math.random() * Math.max(1, delay * 0.25);
     this.#reconnectTimer = setTimeout(() => {
       this.#reconnectTimer = undefined;
       this.#open(this.#resumeURL ?? "wss://gateway.discord.gg/?v=10&encoding=json");
@@ -2666,10 +3149,41 @@ class Gateway {
     this.state = next;
     this.#emit("stateChange", { previous, next });
   }
+  #initDecompressor() {
+    const ds = new DecompressionStream("deflate-raw");
+    this.#decompressor = {
+      writer: ds.writable.getWriter(),
+      reader: ds.readable.getReader()
+    };
+  }
+  async#decompress(chunk) {
+    if (!this.#decompressor)
+      this.#initDecompressor();
+    const { writer, reader } = this.#decompressor;
+    await writer.write(chunk);
+    const parts = [];
+    while (true) {
+      const { done, value } = await Promise.race([
+        reader.read(),
+        new Promise((resolve) => setTimeout(() => resolve({ done: true, value: undefined }), 50))
+      ]);
+      if (done || !value)
+        break;
+      parts.push(value);
+    }
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+      merged.set(p, offset);
+      offset += p.length;
+    }
+    return new TextDecoder().decode(merged);
+  }
 }
 
 // packages/core/src/index.ts
-class EventEmitter {
+class EventEmitter2 {
   #listeners = new Map;
   on(event, listener) {
     if (typeof listener !== "function")
@@ -2691,6 +3205,9 @@ class EventEmitter {
     this.#listeners.get(event)?.delete(listener);
     return this;
   }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
   removeAllListeners(event) {
     if (event === undefined)
       this.#listeners.clear();
@@ -2727,7 +3244,7 @@ class EventEmitter {
   }
 }
 
-class Client extends EventEmitter {
+class Client extends EventEmitter2 {
   options;
   rest;
   users;
@@ -2743,14 +3260,26 @@ class Client extends EventEmitter {
   user;
   readyAt;
   state = "idle";
+  get token() {
+    return this.state === "destroyed" ? null : this.options.token ?? null;
+  }
   get uptime() {
     return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
   }
+  get ping() {
+    return this.#gateway.ping;
+  }
   isReady() {
     return this.state === "ready";
   }
   setPresence(data) {
-    return this.#gateway.setPresence?.(data) ?? false;
+    return this.#gateway.setPresence(data);
+  }
+  setVoiceState(data) {
+    return this.#gateway.setVoiceState(data);
+  }
+  requestGuildMembers(data) {
+    return this.#gateway.requestGuildMembers(data);
   }
   #gateway;
   #resourceContext;
@@ -2794,6 +3323,13 @@ class Client extends EventEmitter {
       this.application.commands = new ApplicationCommandManager(this.rest, appId);
       this.emit("ready" /* Ready */, this.user);
     });
+    this.#gateway.on("RESUMED", () => {
+      this.state = "ready";
+      this.emit("resumed" /* Resumed */);
+    });
+    this.#gateway.on("invalidSession", (isRecoverable) => {
+      this.emit("invalidSession" /* InvalidSession */, isRecoverable);
+    });
     this.#gateway.on("open", () => this.emit("open" /* Open */));
     this.#gateway.on("close", (data) => {
       if (this.state !== "destroyed")
@@ -2826,6 +3362,7 @@ class Client extends EventEmitter {
         this.emit("guildUnavailable" /* GuildUnavailable */, payload);
         return;
       }
+      const wasCached = this.guilds.has(payload.id);
       const guild = new Guild(payload);
       this.guilds.set(guild.id, guild);
       for (const member of payload.members ?? [])
@@ -2835,7 +3372,7 @@ class Client extends EventEmitter {
         ...payload.threads ?? []
       ])
         this.channels.set(channelData.id, new Channel(channelData, this.#resourceContext));
-      this.emit("guildCreate" /* GuildCreate */, payload);
+      this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
     });
     this.#gateway.on("GUILD_UPDATE", (data) => {
       const guild = new Guild(data);
@@ -2964,10 +3501,52 @@ class Client extends EventEmitter {
       return Promise.reject(new Error("Client is unauthenticated."));
     return this.rest.post(`/webhooks/${this.user.id}/${token}`, data);
   }
+  fetchWebhook(id, token) {
+    return this.rest.get(token ? `/webhooks/${id}/${token}` : `/webhooks/${id}`);
+  }
+  fetchGuildPreview(guildId) {
+    return this.rest.get(`/guilds/${guildId}/preview`);
+  }
+  fetchVoiceRegions() {
+    return this.rest.get("/voice/regions");
+  }
+  fetchInvite(code, options) {
+    const query = new URLSearchParams;
+    if (options?.withCounts)
+      query.set("with_counts", "true");
+    if (options?.withExpiration)
+      query.set("with_expiration", "true");
+    if (options?.guildScheduledEventId)
+      query.set("guild_scheduled_event_id", options.guildScheduledEventId);
+    const qs = query.toString();
+    return this.rest.get(`/invites/${code}${qs ? `?${qs}` : ""}`);
+  }
+  fetchSticker(id) {
+    return this.rest.get(`/stickers/${id}`);
+  }
+  fetchPremiumStickerPacks() {
+    return this.rest.get(`/sticker-packs`);
+  }
+  fetchGuildTemplate(code) {
+    return this.rest.get(`/guilds/templates/${code}`);
+  }
+  generateInvite(options) {
+    if (!this.user)
+      throw new Error("Client must be ready to generate invite.");
+    const params = new URLSearchParams({
+      client_id: this.user.id,
+      scopes: (options?.scopes ?? ["bot"]).join(" ")
+    });
+    if (options?.permissions) {
+      params.set("permissions", String(options.permissions));
+    }
+    return `https://discord.com/api/oauth2/authorize?${params.toString()}`;
+  }
 }
 export {
   Client,
   ClientEvent,
+  Collector,
   GatewayIntentBits,
   IntentBits,
   Intents,
@@ -2980,4 +3559,4 @@ export {
   resolveGatewayIntents
 };
 
-//# debugId=813519968046205864756E2164756E21
+//# debugId=5F8825194034E27864756E2164756E21