lunibee 0.1.6 → 0.1.7

package/dist/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,
@@ -587,6 +658,14 @@ var ChannelType = {
   GuildForum: 15,
   GuildMedia: 16
 };
+var ButtonStyle = {
+  Primary: 1,
+  Secondary: 2,
+  Success: 3,
+  Danger: 4,
+  Link: 5,
+  Premium: 6
+};
 var InteractionResponseType = {
   Pong: 1,
   ChannelMessage: 4,
@@ -687,10 +766,14 @@ class Cache {
     const expiresAt = this.#ttl > 0 ? Date.now() + this.#ttl : 0;
     this.#entries.delete(key);
     this.#entries.set(key, { value, expiresAt });
-    while (this.#entries.size > this.#maxSize) {
-      const oldest = this.#entries.firstKey();
-      if (oldest !== undefined)
-        this.#entries.delete(oldest);
+    if (this.#maxSize !== Infinity) {
+      while (this.#entries.size > this.#maxSize) {
+        const oldest = this.#entries.firstKey();
+        if (oldest !== undefined)
+          this.#entries.delete(oldest);
+        else
+          break;
+      }
     }
     return this;
   }
@@ -874,6 +957,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
@@ -945,7 +1097,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",
@@ -954,6 +1106,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",
@@ -999,13 +1190,122 @@ 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))
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
   return value;
 }
+// packages/rest/src/redis.ts
+class RedisRateLimitStore {
+  #client;
+  #prefix;
+  #onErrorCallback;
+  #lastError;
+  constructor(options) {
+    this.#client = options.client;
+    this.#prefix = options.prefix ?? "lunibee:rest:";
+    this.#onErrorCallback = options.onError;
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  isHealthy() {
+    return this.#lastError === undefined;
+  }
+  #onError(operation, error) {
+    this.#lastError = error;
+    console.warn(`[lunibee/rest] Redis rate-limit store ${operation} failed; ` + `falling back to local limiting for this call.`, error);
+    try {
+      this.#onErrorCallback?.(operation, error);
+    } catch {}
+  }
+  #markHealthy() {
+    this.#lastError = undefined;
+  }
+  async getBucketHash(route) {
+    try {
+      const hash = await this.#client.get(`${this.#prefix}route:${route}`);
+      this.#markHealthy();
+      return hash ?? undefined;
+    } catch (error) {
+      this.#onError("getBucketHash", error);
+      return;
+    }
+  }
+  async setBucketHash(route, hash) {
+    try {
+      await this.#client.set(`${this.#prefix}route:${route}`, hash, "EX", 604800);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("setBucketHash", error);
+    }
+  }
+  async getBucket(key) {
+    try {
+      const data = await this.#client.get(`${this.#prefix}bucket:${key}`);
+      this.#markHealthy();
+      if (!data)
+        return;
+      return JSON.parse(data);
+    } catch (error) {
+      this.#onError("getBucket", error);
+      return;
+    }
+  }
+  async updateBucket(key, state) {
+    const bucketKey = `${this.#prefix}bucket:${key}`;
+    const ttl = Math.ceil((state.resetAt - Date.now()) / 1000);
+    try {
+      if (ttl <= 0) {
+        await this.#client.del(bucketKey);
+        this.#markHealthy();
+        return;
+      }
+      await this.#client.set(bucketKey, JSON.stringify(state), "EX", ttl);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("updateBucket", error);
+    }
+  }
+  async getGlobalReset() {
+    try {
+      const resetAt = await this.#client.get(`${this.#prefix}global`);
+      this.#markHealthy();
+      return resetAt ? Number(resetAt) : 0;
+    } catch (error) {
+      this.#onError("getGlobalReset", error);
+      return 0;
+    }
+  }
+  async setGlobalReset(resetAt) {
+    const globalKey = `${this.#prefix}global`;
+    const ttl = Math.ceil((resetAt - Date.now()) / 1000);
+    try {
+      if (ttl <= 0) {
+        await this.#client.del(globalKey);
+        this.#markHealthy();
+        return;
+      }
+      await this.#client.set(globalKey, String(resetAt), "EX", ttl);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("setGlobalReset", error);
+    }
+  }
+}
 // packages/rest/src/webhook.ts
 class WebhookClient {
   id;
@@ -1030,7 +1330,7 @@ class WebhookClient {
     const payload = typeof options === "string" ? { content: options } : options;
     const { thread_id, ...body } = payload;
     const query = thread_id ? `?thread_id=${thread_id}&wait=true` : `?wait=true`;
-    const formattedEmbeds = body.embeds?.map((e) => typeof e === "object" && e !== null && ("toJSON" in e) ? e.toJSON() : e);
+    const formattedEmbeds = body.embeds?.map((e) => ("toJSON" in e) ? e.toJSON() : e);
     return this.#rest.post(`${Routes.webhook(this.id, this.token)}${query}`, {
       ...body,
       embeds: formattedEmbeds
@@ -1065,6 +1365,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.");
@@ -1087,14 +1430,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())
@@ -1107,56 +1457,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 });
@@ -1179,22 +1564,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;
@@ -1214,13 +1606,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);
   }
@@ -1284,16 +1685,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"));
@@ -1308,12 +1710,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;
   }
 }
 
@@ -1459,6 +1864,13 @@ class Guild extends BaseStructure {
   vanityUrlCode;
   nsfwLevel;
   discoverySplash;
+  rulesChannelId;
+  systemChannelId;
+  systemChannelFlags;
+  maxMembers;
+  mfaLevel;
+  explicitContentFilter;
+  defaultMessageNotifications;
   constructor(data) {
     super(data.id);
     if (!data.name)
@@ -1480,6 +1892,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)
@@ -1501,12 +1921,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;
   }
@@ -1517,141 +1952,14 @@ 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
-};
-
-class PermissionSet2 {
-  bitfield;
-  constructor(value = 0n) {
-    try {
-      if (Array.isArray(value)) {
-        let bit = 0n;
-        for (const item of value)
-          bit |= this.#resolve(item);
-        this.bitfield = bit;
-      } else if (value instanceof PermissionSet2) {
-        this.bitfield = value.bitfield;
-      } else {
-        const bitfield = this.#resolve(value);
-        if (bitfield < 0n)
-          throw new RangeError("Permission bitfield cannot be negative.");
-        this.bitfield = bitfield;
-      }
-    } catch (error) {
-      if (error instanceof RangeError)
-        throw error;
-      throw new TypeError("Permission bitfield must be a valid non-negative integer.", { cause: error });
-    }
-  }
-  has(...permissions) {
-    return permissions.every((permission) => (this.bitfield & this.#resolve(permission)) === this.#resolve(permission));
-  }
-  any(...permissions) {
-    return permissions.some((permission) => (this.bitfield & this.#resolve(permission)) !== 0n);
-  }
-  add(...permissions) {
-    let bitfield = this.bitfield;
-    for (const permission of permissions)
-      bitfield |= this.#resolve(permission);
-    return new PermissionSet2(bitfield);
-  }
-  remove(...permissions) {
-    let bitfield = this.bitfield;
-    for (const permission of permissions)
-      bitfield &= ~this.#resolve(permission);
-    return new PermissionSet2(bitfield);
-  }
-  equals(other) {
-    return this.bitfield === (other instanceof PermissionSet2 ? other.bitfield : new PermissionSet2(other).bitfield);
-  }
-  toString() {
-    return this.bitfield.toString();
-  }
-  toArray() {
-    return Object.keys(Permissions2).filter((permission) => this.has(permission));
-  }
-  #resolve(permission) {
-    if (permission instanceof PermissionSet2)
-      return permission.bitfield;
-    if (typeof permission === "bigint")
-      return permission;
-    if (typeof permission === "number")
-      return BigInt(permission);
-    if (Array.isArray(permission)) {
-      let bit = 0n;
-      for (const p of permission)
-        bit |= this.#resolve(p);
-      return bit;
-    }
-    if (typeof permission === "string") {
-      if (permission in Permissions2)
-        return Permissions2[permission];
-      const matchedKey = Object.keys(Permissions2).find((k) => k.toLowerCase() === permission.toLowerCase());
-      if (matchedKey)
-        return Permissions2[matchedKey];
-      return BigInt(permission);
-    }
-    return 0n;
-  }
-}
-
-class PermissionsBitField2 extends PermissionSet2 {
-  constructor(value = 0n) {
-    super(value);
-  }
+// packages/structures/src/resources.ts
+function toDateOrNull(value) {
+  if (!value)
+    return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
 }
 
-// packages/structures/src/resources.ts
 class GuildMember {
   user;
   guildId;
@@ -1660,6 +1968,10 @@ class GuildMember {
   pending;
   joinedAt;
   permissions;
+  avatarHash;
+  premiumSince;
+  timedOutUntil;
+  flags;
   constructor(data) {
     this.user = new User(data.user);
     if (!/^\d{1,20}$/.test(data.guild_id))
@@ -1671,11 +1983,26 @@ class GuildMember {
     this.joinedAt = data.joined_at ? new Date(data.joined_at) : undefined;
     if (this.joinedAt?.toString() === "Invalid Date")
       throw new RangeError("Member joined_at must be a valid date.");
-    this.permissions = new PermissionsBitField2(data.permissions ?? 0n);
+    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
+    this.avatarHash = data.avatar ?? null;
+    this.premiumSince = toDateOrNull(data.premium_since);
+    this.timedOutUntil = toDateOrNull(data.communication_disabled_until);
+    this.flags = data.flags ?? 0;
   }
   get displayName() {
     return this.nickname ?? this.user.displayName;
   }
+  get isTimedOut() {
+    return this.timedOutUntil !== null && this.timedOutUntil > new Date;
+  }
+  avatarURL(options = {}) {
+    if (this.avatarHash)
+      return cdnURL(`/guilds/${this.guildId}/users/${this.user.id}/avatars`, this.avatarHash, options);
+    return this.user.avatarURL(options);
+  }
+  displayAvatarURL(options = {}) {
+    return this.avatarURL(options) ?? this.user.displayAvatarURL(options);
+  }
   toString() {
     return this.user.toString();
   }
@@ -1688,6 +2015,10 @@ class Role extends BaseStructure {
   permissions;
   managed;
   mentionable;
+  position;
+  unicodeEmoji;
+  iconHash;
+  tags;
   constructor(data) {
     super(data.id);
     if (!data.name)
@@ -1695,9 +2026,24 @@ class Role extends BaseStructure {
     this.name = data.name;
     this.color = data.color ?? 0;
     this.hoist = data.hoist ?? false;
-    this.permissions = new PermissionsBitField2(data.permissions ?? 0n);
+    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
     this.managed = data.managed ?? false;
     this.mentionable = data.mentionable ?? false;
+    this.position = data.position ?? 0;
+    this.unicodeEmoji = data.unicode_emoji ?? null;
+    this.iconHash = data.icon ?? null;
+    this.tags = data.tags ?? null;
+  }
+  get colorHex() {
+    return `#${this.color.toString(16).padStart(6, "0").toUpperCase()}`;
+  }
+  iconURL(options = {}) {
+    if (!this.iconHash)
+      return null;
+    return cdnURL(`/role-icons/${this.id}`, this.iconHash, options);
+  }
+  isEveryone(guildId) {
+    return this.id === guildId;
   }
   toString() {
     return `<@&${this.id}>`;
@@ -1712,6 +2058,218 @@ class TextChannel extends Channel {
     return `<#${this.id}>`;
   }
 }
+
+class Invite {
+  code;
+  guildId;
+  channelId;
+  inviter;
+  uses;
+  maxUses;
+  maxAge;
+  temporary;
+  createdAt;
+  expiresAt;
+  constructor(data) {
+    if (!data.code)
+      throw new TypeError("An invite requires a code.");
+    this.code = data.code;
+    this.guildId = data.guild?.id ?? null;
+    this.channelId = data.channel?.id ?? null;
+    this.inviter = data.inviter ? new User(data.inviter) : null;
+    this.uses = data.uses ?? 0;
+    this.maxUses = data.max_uses ?? 0;
+    this.maxAge = data.max_age ?? 0;
+    this.temporary = data.temporary ?? false;
+    this.createdAt = data.created_at ? new Date(data.created_at) : null;
+    this.expiresAt = data.expires_at ? new Date(data.expires_at) : null;
+  }
+  get url() {
+    return `https://discord.gg/${this.code}`;
+  }
+  toString() {
+    return this.url;
+  }
+}
+var WebhookType = {
+  Incoming: 1,
+  ChannelFollower: 2,
+  Application: 3
+};
+
+class Webhook extends BaseStructure {
+  type;
+  name;
+  avatarHash;
+  channelId;
+  guildId;
+  applicationId;
+  token;
+  constructor(data) {
+    super(data.id);
+    this.type = data.type ?? WebhookType.Incoming;
+    this.name = data.name ?? null;
+    this.avatarHash = data.avatar ?? null;
+    this.channelId = data.channel_id ?? null;
+    this.guildId = data.guild_id ?? null;
+    this.applicationId = data.application_id ?? null;
+    this.token = data.token ?? null;
+  }
+  avatarURL(options = {}) {
+    if (!this.avatarHash)
+      return null;
+    return cdnURL(`/avatars/${this.id}`, this.avatarHash, options);
+  }
+  get url() {
+    return this.token ? `https://discord.com/api/webhooks/${this.id}/${this.token}` : null;
+  }
+  toString() {
+    return this.url ?? this.id;
+  }
+}
+
+class Emoji extends BaseStructure {
+  name;
+  roleIds;
+  user;
+  requireColons;
+  managed;
+  animated;
+  available;
+  constructor(data) {
+    super(data.id ?? "unicode");
+    this.name = data.name;
+    this.roleIds = data.roles ?? [];
+    this.user = data.user ? new User(data.user) : null;
+    this.requireColons = data.require_colons ?? false;
+    this.managed = data.managed ?? false;
+    this.animated = data.animated ?? false;
+    this.available = data.available ?? true;
+  }
+  url(options = {}) {
+    if (!this.id || this.id === "unicode")
+      return null;
+    const ext = options.extension ?? (this.animated ? "gif" : "png");
+    const size = options.size ? `?size=${options.size}` : "";
+    return `${CDN_BASE}/emojis/${this.id}.${ext}${size}`;
+  }
+  toString() {
+    return this.id !== "unicode" ? `<${this.animated ? "a" : ""}:${this.name}:${this.id}>` : this.name ?? "";
+  }
+}
+
+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
+    };
+  }
+}
+
+class WelcomeScreenChannel {
+  channelId;
+  description;
+  emojiId;
+  emojiName;
+  constructor(data) {
+    this.channelId = data.channel_id;
+    this.description = data.description;
+    this.emojiId = data.emoji_id;
+    this.emojiName = data.emoji_name;
+  }
+}
+
+class GuildWelcomeScreen {
+  description;
+  channels;
+  constructor(data) {
+    this.description = data.description;
+    this.channels = data.welcome_channels.map((c) => new WelcomeScreenChannel(c));
+  }
+}
+
+class OnboardingPromptOption extends BaseStructure {
+  channelIds;
+  roleIds;
+  emoji;
+  title;
+  description;
+  constructor(data) {
+    super(data.id);
+    this.channelIds = data.channel_ids;
+    this.roleIds = data.role_ids;
+    this.emoji = data.emoji;
+    this.title = data.title;
+    this.description = data.description;
+  }
+}
+
+class OnboardingPrompt extends BaseStructure {
+  type;
+  options;
+  title;
+  singleSelect;
+  required;
+  inOnboarding;
+  constructor(data) {
+    super(data.id);
+    this.type = data.type;
+    this.options = data.options.map((o) => new OnboardingPromptOption(o));
+    this.title = data.title;
+    this.singleSelect = data.single_select;
+    this.required = data.required;
+    this.inOnboarding = data.in_onboarding;
+  }
+}
+
+class GuildOnboarding extends BaseStructure {
+  prompts;
+  defaultChannelIds;
+  enabled;
+  mode;
+  constructor(data) {
+    super(data.guild_id);
+    this.prompts = data.prompts.map((p) => new OnboardingPrompt(p));
+    this.defaultChannelIds = data.default_channel_ids;
+    this.enabled = data.enabled;
+    this.mode = data.mode;
+  }
+}
 // packages/structures/src/interactions.ts
 var InteractionType = {
   Ping: 1,
@@ -2002,8 +2560,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);
   }
 }
 
@@ -2233,8 +2790,38 @@ class Embed {
     return new Embed(data);
   }
 }
+// packages/structures/src/audit-log.ts
+class AuditLogEntry extends BaseStructure {
+  targetId;
+  userId;
+  actionType;
+  changes;
+  options;
+  reason;
+  constructor(data) {
+    super(data.id);
+    this.targetId = data.target_id;
+    this.userId = data.user_id;
+    this.actionType = data.action_type;
+    this.changes = data.changes ?? [];
+    this.options = data.options ?? null;
+    this.reason = data.reason ?? null;
+  }
+}
+
+class AuditLog {
+  entries;
+  constructor(data) {
+    this.entries = new Map;
+    for (const entryData of data.audit_log_entries) {
+      this.entries.set(entryData.id, new AuditLogEntry(entryData));
+    }
+  }
+}
 
 // packages/structures/src/index.ts
+var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
+
 class Message extends BaseStructure {
   content;
   author;
@@ -2280,6 +2867,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.");
@@ -2334,6 +2927,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
@@ -2425,6 +3063,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) {
@@ -2454,7 +3097,101 @@ 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));
+  }
 }
+var AuditLogEvent = {
+  GuildUpdate: 1,
+  ChannelCreate: 10,
+  ChannelUpdate: 11,
+  ChannelDelete: 12,
+  ChannelOverwriteCreate: 13,
+  ChannelOverwriteUpdate: 14,
+  ChannelOverwriteDelete: 15,
+  MemberKick: 20,
+  MemberPrune: 21,
+  MemberBanAdd: 22,
+  MemberBanRemove: 23,
+  MemberUpdate: 24,
+  MemberRoleUpdate: 25,
+  MemberMove: 26,
+  MemberDisconnect: 27,
+  BotAdd: 28,
+  RoleCreate: 30,
+  RoleUpdate: 31,
+  RoleDelete: 32,
+  InviteCreate: 40,
+  InviteUpdate: 41,
+  InviteDelete: 42,
+  WebhookCreate: 50,
+  WebhookUpdate: 51,
+  WebhookDelete: 52,
+  EmojiCreate: 60,
+  EmojiUpdate: 61,
+  EmojiDelete: 62,
+  MessageDelete: 72,
+  MessageBulkDelete: 73,
+  MessagePin: 74,
+  MessageUnpin: 75,
+  IntegrationCreate: 80,
+  IntegrationUpdate: 81,
+  IntegrationDelete: 82,
+  StageInstanceCreate: 83,
+  StageInstanceUpdate: 84,
+  StageInstanceDelete: 85,
+  StickerCreate: 90,
+  StickerUpdate: 91,
+  StickerDelete: 92,
+  ScheduledEventCreate: 100,
+  ScheduledEventUpdate: 101,
+  ScheduledEventDelete: 102,
+  ThreadCreate: 110,
+  ThreadUpdate: 111,
+  ThreadDelete: 112,
+  AutoModerationRuleCreate: 140,
+  AutoModerationRuleUpdate: 141,
+  AutoModerationRuleDelete: 142,
+  AutoModerationBlockMessage: 143
+};
 // packages/managers/src/role.ts
 class RoleManager extends ResourceManager {
   #rest;
@@ -2575,6 +3312,44 @@ class ApplicationCommandManager {
     await this.#rest.delete(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId));
   }
 }
+// packages/managers/src/emoji.ts
+class EmojiManager extends Manager {
+  #rest;
+  #guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.#guildId = guildId;
+  }
+  async fetch(emojiId) {
+    return this.upsert(await this.#rest.get(Routes.guildEmoji(this.#guildId, emojiId)));
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes.guildEmoji(this.#guildId));
+    return data.map((item) => this.upsert(item));
+  }
+  async create(options) {
+    return this.upsert(await this.#rest.post(Routes.guildEmoji(this.#guildId), options));
+  }
+  async edit(emojiId, options) {
+    return this.upsert(await this.#rest.patch(Routes.guildEmoji(this.#guildId, emojiId), options));
+  }
+  async deleteEmoji(emojiId) {
+    await this.#rest.delete(Routes.guildEmoji(this.#guildId, emojiId));
+    this.delete(emojiId);
+  }
+  upsert(data) {
+    const key = data.id != null ? data.id : `unicode:${data.name ?? ""}`;
+    const existing = this.get(key);
+    const emoji = new Emoji(data);
+    if (existing) {
+      Object.assign(existing, emoji);
+      return existing;
+    }
+    this.set(key, emoji);
+    return emoji;
+  }
+}
 
 // packages/managers/src/index.ts
 class ChannelManager extends Manager {
@@ -2637,8 +3412,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);
@@ -2683,6 +3461,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
     });
@@ -2690,7 +3470,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;
@@ -2724,9 +3504,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();
@@ -2751,6 +3543,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
+};
 var GatewayState;
 ((GatewayState2) => {
   GatewayState2["Connect"] = "CONNECT";
@@ -2763,7 +3571,6 @@ var GatewayState;
   GatewayState2["Reconnect"] = "RECONNECT";
   GatewayState2["Closed"] = "CLOSED";
 })(GatewayState ||= {});
-
 class GatewayError extends Error {
   code;
   constructor(message, code, options) {
@@ -2797,6 +3604,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.");
@@ -2817,7 +3626,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)
@@ -2832,10 +3646,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;
   }
@@ -2871,12 +3688,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;
     }
@@ -2947,7 +3767,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")));
@@ -2955,7 +3779,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;
@@ -3006,18 +3830,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) {
@@ -3032,6 +3862,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)
@@ -3109,12 +3943,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;
     }
@@ -3147,14 +3981,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";
   }
@@ -3167,7 +4010,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");
@@ -3237,10 +4080,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")
@@ -3262,6 +4136,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();
@@ -3298,7 +4175,7 @@ class EventEmitter {
   }
 }
 
-class Client extends EventEmitter {
+class Client extends EventEmitter2 {
   options;
   rest;
   users;
@@ -3314,14 +4191,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;
@@ -3365,6 +4254,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")
@@ -3397,6 +4293,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 ?? [])
@@ -3406,7 +4303,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);
@@ -3535,6 +4432,47 @@ 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()}`;
+  }
 }
 // packages/formatters/src/index.ts
 function userMention(id) {
@@ -3553,6 +4491,55 @@ function timestamp(unixSeconds, style) {
     throw new RangeError("Invalid Discord timestamp style.");
   return `<t:${Math.floor(unixSeconds)}${style ? `:${style}` : ""}>`;
 }
+function bold(text) {
+  return `**${text}**`;
+}
+function italic(text) {
+  return `_${text}_`;
+}
+function underline(text) {
+  return `__${text}__`;
+}
+function strikethrough(text) {
+  return `~~${text}~~`;
+}
+function spoiler(text) {
+  return `||${text}||`;
+}
+function masked(text) {
+  return spoiler(text);
+}
+function inlineCode(text) {
+  return `\`${text}\``;
+}
+function codeBlock(text, language = "") {
+  return `\`\`\`${language}
+${text}
+\`\`\``;
+}
+function link(label, url, title) {
+  const titlePart = title ? ` "${title}"` : "";
+  return `[${label}](${url}${titlePart})`;
+}
+function blockQuote(text) {
+  return text.split(`
+`).map((line) => `> ${line}`).join(`
+`);
+}
+function heading(text, level = 1) {
+  return `${"#".repeat(level)} ${text}`;
+}
+function subtext(text) {
+  return `-# ${text}`;
+}
+function orderedList(...items) {
+  return items.map((item, i) => `${i + 1}. ${item}`).join(`
+`);
+}
+function bulletList(...items) {
+  return items.map((item) => `- ${item}`).join(`
+`);
+}
 function escapeMarkdown(value) {
   return value.replace(/[\\*_`~|>]/g, "\\$&");
 }
@@ -3673,8 +4660,155 @@ class ShardBus {
     }
   }
 }
+// packages/sharding/src/cluster.ts
+import { fork } from "child_process";
+import { cpus } from "os";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class ClusterManager {
+  clusters = new Map;
+  shardCount = 0;
+  #options;
+  #auto;
+  #autoScaleTimer;
+  #spawned = false;
+  constructor(options) {
+    if (!options.token?.trim())
+      throw new TypeError("A Discord bot token is required.");
+    if (!options.script?.trim())
+      throw new TypeError("A script path is required for clustering.");
+    if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000)) {
+      throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
+    }
+    this.#auto = options.shardCount === "auto";
+    this.#options = { ...options };
+  }
+  async fetchRecommendedShardCount() {
+    const response = await fetch("https://discord.com/api/v10/gateway/bot", {
+      headers: {
+        Authorization: `Bot ${this.#options.token}`,
+        "User-Agent": "Lunibee/0.1.0"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Gateway discovery failed with status ${response.status}`);
+    }
+    const data = await response.json();
+    if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1) {
+      throw new Error("Gateway discovery returned an invalid shard count.");
+    }
+    return data.shards;
+  }
+  async spawn() {
+    if (this.#spawned)
+      return;
+    if (typeof process?.versions?.bun === "string") {
+      throw new Error("ClusterManager requires the Node.js runtime; Bun does not support child_process.fork() for this clustering mode.");
+    }
+    this.#spawned = true;
+    const count = this.#options.shardCount === "auto" || this.#options.shardCount === undefined ? await this.fetchRecommendedShardCount() : this.#options.shardCount;
+    this.shardCount = count;
+    const clusterCount = this.#options.clusterCount ?? cpus().length;
+    const chunks = Array.from({ length: clusterCount }, () => []);
+    for (let i = 0;i < count; i++) {
+      chunks[i % clusterCount].push(i);
+    }
+    for (let i = 0;i < clusterCount; i++) {
+      if (chunks[i].length === 0)
+        continue;
+      const child = fork(this.#options.script, [], {
+        env: {
+          ...process.env,
+          SHARD_LIST: chunks[i].join(","),
+          SHARD_COUNT: count.toString(),
+          CLUSTER_ID: i.toString()
+        }
+      });
+      this.clusters.set(i, {
+        id: i,
+        process: child,
+        shards: chunks[i]
+      });
+      await sleep(500);
+    }
+    if (this.#options.autoScaleInterval && this.#options.autoScaleInterval > 0) {
+      this.#autoScaleTimer = setInterval(() => {
+        this.checkAutoScale();
+      }, this.#options.autoScaleInterval);
+    }
+  }
+  async checkAutoScale() {
+    if (!this.#auto)
+      return;
+    try {
+      const recommended = await this.fetchRecommendedShardCount();
+      if (recommended !== this.shardCount) {
+        await this.respawn(recommended);
+      }
+    } catch (error) {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      this.#options.onAutoScaleError?.(normalized);
+    }
+  }
+  async respawn(newShardCount) {
+    this.#options.shardCount = newShardCount;
+    await this.shutdownAll();
+    this.#spawned = false;
+    await this.spawn();
+  }
+  async shutdownAll(timeoutMs = this.#options.shutdownTimeout ?? 5000) {
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
+    await Promise.all([...this.clusters.values()].map((cluster) => this.#shutdownCluster(cluster, timeoutMs)));
+    this.clusters.clear();
+    this.#spawned = false;
+  }
+  async#shutdownCluster(cluster, timeoutMs) {
+    const child = cluster.process;
+    if (child.exitCode !== null || child.signalCode !== null)
+      return;
+    await new Promise((resolve) => {
+      let timer;
+      const finish = () => {
+        if (timer)
+          clearTimeout(timer);
+        resolve();
+      };
+      child.once("exit", finish);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        child.off("exit", finish);
+        finish();
+        return;
+      }
+      timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }, timeoutMs);
+    });
+  }
+  killAll() {
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
+    for (const cluster of this.clusters.values()) {
+      try {
+        cluster.process.kill();
+      } catch {}
+    }
+    this.clusters.clear();
+    this.#spawned = false;
+  }
+}
 
 // packages/sharding/src/index.ts
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
 class ShardManager {
   shards = new Map;
   get shardCount() {
@@ -3683,6 +4817,8 @@ class ShardManager {
   #options;
   #resolved = false;
   #destroyed = false;
+  #auto;
+  #autoScaleTimer;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
@@ -3691,6 +4827,9 @@ class ShardManager {
     const count = options.shardCount === "auto" || options.shardCount === undefined ? 1 : options.shardCount;
     if (!Number.isInteger(count) || count < 1)
       throw new RangeError("Shard count must be a positive integer.");
+    if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000))
+      throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
+    this.#auto = options.shardCount === "auto";
     this.#options = { ...options };
     if (options.shardCount !== "auto")
       this.#initialize(count);
@@ -3710,24 +4849,56 @@ class ShardManager {
     return data.shards;
   }
   async connect() {
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
     await this.#ensureInitialized();
     for (const [id, shard] of this.shards) {
       try {
         await shard.connect();
       } catch (error) {
         this.destroy();
-        throw new Error(`Failed to connect shard ${id}.`, { cause: error });
+        throw new Error(`Failed to connect shard ${id}.`, {
+          cause: error
+        });
       }
       if (id + 1 < this.shardCount && this.#options.spawnDelay && this.#options.spawnDelay > 0)
-        await Bun.sleep(this.#options.spawnDelay);
+        await sleep2(this.#options.spawnDelay);
+    }
+    if (this.#options.autoScaleInterval && !this.#autoScaleTimer) {
+      this.#autoScaleTimer = setInterval(() => {
+        this.checkAutoScale();
+      }, this.#options.autoScaleInterval);
+    }
+  }
+  async checkAutoScale() {
+    if (!this.#auto)
+      return;
+    try {
+      const recommended = await this.fetchRecommendedShardCount();
+      if (recommended !== this.shardCount) {
+        await this.reshard(recommended);
+      }
+    } catch (error) {
+      this.#options.onAutoScaleError?.(error);
     }
   }
+  async reshard(count) {
+    this.#options.shardCount = count;
+    this.destroy();
+    await this.connect();
+  }
   destroy() {
     for (const shard of this.shards.values())
       shard.close();
     this.shards.clear();
     this.#resolved = false;
     this.#destroyed = true;
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
   }
   getShardIdForGuild(guildId) {
     const id = BigInt(guildId);
@@ -3765,7 +4936,7 @@ class ShardManager {
   }
 }
 // packages/utils/src/index.ts
-function sleep(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function randomInt(min, max) {
@@ -3804,6 +4975,7 @@ class VoiceConnection {
   gateway;
   udp;
   #listeners = new Map;
+  receiver;
   constructor(options) {
     const resolved = typeof options === "string" ? { guildId: options } : options;
     if (!resolved.guildId?.trim()) {
@@ -3813,6 +4985,7 @@ class VoiceConnection {
     this.channelId = resolved.channelId;
     this.selfMute = resolved.selfMute ?? false;
     this.selfDeaf = resolved.selfDeaf ?? false;
+    this.receiver = new VoiceReceiver(this);
   }
   on(event, listener) {
     if (typeof listener !== "function")
@@ -3835,6 +5008,13 @@ class VoiceConnection {
       this.#closeTransports();
     this.gateway = gateway;
     this.udp = udp;
+    const attachedUdp = udp;
+    if (attachedUdp.onMessage) {
+      attachedUdp.onMessage((packet) => {
+        if (this.udp === attachedUdp)
+          this.receiver.onPacket(packet);
+      });
+    }
     return this;
   }
   connect() {
@@ -3890,12 +5070,16 @@ class VoiceConnection {
     try {
       this.gateway?.close(1000, "Voice connection replaced or closed");
     } catch (error) {
-      this.#emit("error", error instanceof VoiceError ? error : new VoiceError("Voice gateway cleanup failed.", { cause: error }));
+      this.#emit("error", error instanceof VoiceError ? error : new VoiceError("Voice gateway cleanup failed.", {
+        cause: error
+      }));
     }
     try {
       this.udp?.close();
     } catch (error) {
-      this.#emit("error", error instanceof VoiceError ? error : new VoiceError("Voice UDP cleanup failed.", { cause: error }));
+      this.#emit("error", error instanceof VoiceError ? error : new VoiceError("Voice UDP cleanup failed.", {
+        cause: error
+      }));
     }
     this.gateway = undefined;
     this.udp = undefined;
@@ -3909,7 +5093,9 @@ class VoiceConnection {
       try {
         listener(next, previous);
       } catch (error) {
-        this.#emit("error", error instanceof VoiceError ? error : new VoiceError("Voice event listener failed.", { cause: error }));
+        this.#emit("error", error instanceof VoiceError ? error : new VoiceError("Voice event listener failed.", {
+          cause: error
+        }));
       }
       if (this.state !== next && next !== "destroyed" /* Destroyed */)
         return;
@@ -3926,6 +5112,187 @@ class VoiceConnection {
     this.#assertUsable();
   }
 }
+
+class AudioStream {
+  stream;
+  title;
+  duration;
+  constructor(stream, metadata) {
+    this.stream = stream;
+    this.title = metadata?.title;
+    this.duration = metadata?.duration;
+  }
+}
+
+class AudioPlayer {
+  #state = "idle";
+  #stream;
+  #reader;
+  #resumeSignal;
+  #listeners = new Map;
+  get state() {
+    return this.#state;
+  }
+  get current() {
+    return this.#stream;
+  }
+  async play(audioStream) {
+    if (this.#state === "playing" || this.#state === "paused")
+      await this.stop();
+    this.#stream = audioStream;
+    this.#reader = audioStream.stream.getReader();
+    this.#transition("playing");
+    this.#pump().catch((err) => this.#emitError(err));
+  }
+  pause() {
+    if (this.#state !== "playing")
+      return;
+    this.#transition("paused");
+  }
+  resume() {
+    if (this.#state !== "paused")
+      return;
+    this.#transition("playing");
+    const signal = this.#resumeSignal;
+    this.#resumeSignal = undefined;
+    signal?.();
+  }
+  async stop() {
+    if (this.#state === "idle" || this.#state === "stopped")
+      return;
+    const reader = this.#reader;
+    this.#reader = undefined;
+    this.#stream = undefined;
+    this.#transition("stopped");
+    const signal = this.#resumeSignal;
+    this.#resumeSignal = undefined;
+    signal?.();
+    if (reader) {
+      try {
+        await reader.cancel();
+      } catch {}
+    }
+  }
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set) {
+      this.#listeners.set(event, set = new Set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  onChunk(chunk) {}
+  async#pump() {
+    const reader = this.#reader;
+    if (!reader)
+      return;
+    while (true) {
+      if (this.#state === "paused") {
+        await new Promise((resolve) => {
+          this.#resumeSignal = resolve;
+        });
+      }
+      if (this.#state !== "playing")
+        return;
+      const { done, value } = await reader.read();
+      if (done) {
+        if (this.#state === "playing" || this.#state === "paused") {
+          this.#transition("idle");
+          this.#stream = undefined;
+          this.#reader = undefined;
+          this.#emit("finish");
+        }
+        return;
+      }
+      if (this.#state !== "playing" && this.#state !== "paused")
+        return;
+      this.onChunk(value);
+    }
+  }
+  #transition(next) {
+    if (this.#state === next)
+      return;
+    const from = this.#state;
+    this.#state = next;
+    this.#emit("stateChange", from, next);
+  }
+  #emitError(err) {
+    this.#emit("error", err instanceof Error ? err : new VoiceError(String(err)));
+  }
+  #emit(event, ...args) {
+    for (const listener of this.#listeners.get(event) ?? []) {
+      try {
+        listener(...args);
+      } catch {}
+    }
+  }
+}
+
+class VoiceReceiver {
+  connection;
+  #ssrcMap = new Map;
+  #streams = new Map;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  mapSsrc(ssrc, userId) {
+    this.#ssrcMap.set(ssrc, userId);
+  }
+  subscribe(userId) {
+    let controllerRef;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        controllerRef = controller;
+        let set = this.#streams.get(userId);
+        if (!set)
+          this.#streams.set(userId, set = new Set);
+        set.add(controller);
+      },
+      cancel: () => {
+        const set = this.#streams.get(userId);
+        if (set) {
+          set.delete(controllerRef);
+          if (set.size === 0)
+            this.#streams.delete(userId);
+        }
+      }
+    });
+    return new AudioStream(stream, { title: `User ${userId} Audio` });
+  }
+  onPacket(packet) {
+    if (packet.length < 12)
+      return;
+    const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const ssrc = view.getUint32(8, false);
+    const userId = this.#ssrcMap.get(ssrc);
+    if (!userId)
+      return;
+    const controllers = this.#streams.get(userId);
+    if (!controllers || controllers.size === 0)
+      return;
+    const csrcCount = packet[0] & 15;
+    let offset = 12 + csrcCount * 4;
+    const hasExtension = (packet[0] & 16) !== 0;
+    if (hasExtension) {
+      if (packet.length < offset + 4)
+        return;
+      const extWords = view.getUint16(offset + 2, false);
+      offset += 4 + extWords * 4;
+    }
+    if (packet.length < offset)
+      return;
+    const payload = packet.slice(offset);
+    for (const controller of controllers) {
+      try {
+        controller.enqueue(payload);
+      } catch {}
+    }
+  }
+}
 // packages/builders/src/embed.ts
 class EmbedBuilder {
   #data = {};
@@ -3980,16 +5347,20 @@ class EmbedBuilder {
     return this;
   }
   addFields(...fields) {
-    if (!fields.length)
+    const resolved = fields.length === 1 && Array.isArray(fields[0]) ? fields[0] : fields;
+    if (!resolved.length)
       throw new TypeError("At least one embed field is required.");
     const current = this.#data.fields ?? [];
-    if (current.length + fields.length > 25)
+    if (current.length + resolved.length > 25)
       throw new RangeError("An embed cannot contain more than 25 fields.");
-    for (const field of fields) {
+    for (const field of resolved) {
       validate(field.name, 256, "Embed field name");
       validate(field.value, 1024, "Embed field value");
     }
-    this.#data.fields = [...current, ...fields.map((field) => ({ ...field }))];
+    this.#data.fields = [
+      ...current,
+      ...resolved.map((field) => ({ ...field }))
+    ];
     return this;
   }
   setFields(fields) {
@@ -4056,13 +5427,6 @@ var ComponentType = {
   ContentInventoryEntry: 16,
   Container: 17
 };
-var ButtonStyle = {
-  Primary: 1,
-  Secondary: 2,
-  Success: 3,
-  Danger: 4,
-  Link: 5
-};
 var TextInputStyle = { Short: 1, Paragraph: 2 };
 
 class ActionRowBuilder {
@@ -4171,7 +5535,9 @@ class ButtonBuilder {
     try {
       url2 = new URL(value);
     } catch (error) {
-      throw new TypeError("Button URL must be a valid URL.", { cause: error });
+      throw new TypeError("Button URL must be a valid URL.", {
+        cause: error
+      });
     }
     this.#data.style = ButtonStyle.Link;
     delete this.#data.custom_id;
@@ -4227,7 +5593,7 @@ class EntitySelectBuilder {
     return this;
   }
   setDefaultValues(...values) {
-    this.#data.default_values = values;
+    this.#data.default_values = values.map((value) => ({ ...value }));
     return this;
   }
   toJSON() {
@@ -4318,6 +5684,7 @@ class TextInputBuilder {
 class ContainerBuilder {
   #components = [];
   #accentColor;
+  #spoiler;
   addComponents(...components) {
     if (!components.length)
       throw new TypeError("At least one component is required.");
@@ -4331,12 +5698,20 @@ class ContainerBuilder {
     this.#accentColor = color;
     return this;
   }
+  setSpoiler(spoiler2 = true) {
+    this.#spoiler = spoiler2;
+    return this;
+  }
   toJSON() {
-    return {
+    const data = {
       type: ComponentType.Container,
-      components: this.#components.map((c) => c.toJSON()),
-      accent_color: this.#accentColor
+      components: this.#components.map((c) => c.toJSON())
     };
+    if (this.#accentColor !== undefined)
+      data.accent_color = this.#accentColor;
+    if (this.#spoiler !== undefined)
+      data.spoiler = this.#spoiler;
+    return data;
   }
 }
 
@@ -4405,8 +5780,8 @@ class FileComponentBuilder {
     this.#url = url2;
     return this;
   }
-  setSpoiler(spoiler = true) {
-    this.#spoiler = spoiler;
+  setSpoiler(spoiler2 = true) {
+    this.#spoiler = spoiler2;
     return this;
   }
   toJSON() {
@@ -4447,16 +5822,32 @@ class SeparatorBuilder {
 
 class ThumbnailBuilder {
   #url = "";
+  #description;
+  #spoiler;
   setUrl(url2) {
     validateText(url2, 2048, "Thumbnail URL");
     this.#url = url2;
     return this;
   }
+  setDescription(description) {
+    validateText(description, 1024, "Thumbnail description");
+    this.#description = description;
+    return this;
+  }
+  setSpoiler(spoiler2 = true) {
+    this.#spoiler = spoiler2;
+    return this;
+  }
   toJSON() {
-    return {
+    const data = {
       type: ComponentType.Thumbnail,
       url: this.#url
     };
+    if (this.#description !== undefined)
+      data.description = this.#description;
+    if (this.#spoiler !== undefined)
+      data.spoiler = this.#spoiler;
+    return data;
   }
 }
 
@@ -4845,6 +6236,46 @@ function validateNumberRange(value, minimum, maximum, field, integerOnly = true)
   if (!Number.isFinite(value) || integerOnly && !Number.isInteger(value) || value < minimum || value > maximum)
     throw new RangeError(`${field} must be ${integerOnly ? "an integer" : "a number"} between ${minimum} and ${maximum}.`);
 }
+
+class ContextMenuCommandBuilder {
+  data;
+  constructor(type) {
+    this.data = { type };
+  }
+  setName(name) {
+    if (typeof name !== "string" || name.trim().length < 1 || name.length > 32)
+      throw new RangeError("Command name must contain 1-32 characters.");
+    this.data.name = name;
+    return this;
+  }
+  setDefaultMemberPermissions(permissions) {
+    this.data.default_member_permissions = permissions === null ? null : BigInt(permissions).toString();
+    return this;
+  }
+  setDMPermission(enabled) {
+    this.data.dm_permission = enabled;
+    return this;
+  }
+  setIntegrationTypes(...types) {
+    this.data.integration_types = [...types];
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.data);
+  }
+}
+
+class UserCommandBuilder extends ContextMenuCommandBuilder {
+  constructor() {
+    super(2);
+  }
+}
+
+class MessageCommandBuilder extends ContextMenuCommandBuilder {
+  constructor() {
+    super(3);
+  }
+}
 // packages/builders/src/attachment.ts
 import { readFile } from "fs/promises";
 import { basename } from "path";
@@ -4890,7 +6321,7 @@ class AttachmentBuilder {
     if (typeof Buffer !== "undefined" && Buffer.isBuffer(this.file)) {
       return new Uint8Array(this.file);
     }
-    return new Uint8Array;
+    throw new TypeError("Attachment file must be a supported binary value or file path.");
   }
 }
 export {
@@ -4900,6 +6331,12 @@ export {
   ApplicationCommandType,
   AttachmentBuilder,
   AttachmentOptionBuilder,
+  AudioPlayer,
+  AudioStream,
+  AuditLog,
+  AuditLogEntry,
+  AuditLogEvent,
+  AutoModerationRule,
   AutocompleteInteraction,
   BaseStructure,
   BooleanOptionBuilder,
@@ -4912,18 +6349,24 @@ export {
   ChannelType,
   Client,
   ClientEvent,
+  ClusterManager,
   Collection,
+  Collector,
   CommandInteraction,
   CommandOptions,
   ComponentInteraction,
   ComponentType,
   ContainerBuilder,
   ContentInventoryEntryBuilder,
+  RESTError as DiscordAPIError,
   Embed,
   EmbedBuilder,
+  Emoji,
+  EmojiManager,
   EntitySelectBuilder,
   FileComponentBuilder,
   Gateway,
+  GatewayCloseCodes,
   GatewayError,
   GatewayIntentBits,
   GatewayOpcodes,
@@ -4932,6 +6375,8 @@ export {
   GuildManager,
   GuildMember,
   GuildMemberManager,
+  GuildOnboarding,
+  GuildWelcomeScreen,
   HandlerRegistry,
   IntegerOptionBuilder,
   IntentBits,
@@ -4940,15 +6385,20 @@ export {
   InteractionResponse,
   InteractionResponseType,
   InteractionType,
+  Invite,
   Manager,
   MediaGalleryBuilder,
+  MemoryRateLimitStore,
   MentionableOptionBuilder,
   Message,
+  MessageCommandBuilder,
   MessageFlags,
   MessageManager,
   ModalBuilder,
   ModalSubmitInteraction,
   NumberOptionBuilder,
+  OnboardingPrompt,
+  OnboardingPromptOption,
   Permission,
   PermissionFlagsBits,
   PermissionOverwriteType,
@@ -4958,6 +6408,7 @@ export {
   PremiumTier,
   REST,
   RESTError,
+  RedisRateLimitStore,
   ResourceManager,
   Role,
   RoleManager,
@@ -4969,6 +6420,7 @@ export {
   ShardManager,
   SlashCommandBuilder,
   SpeakingFlags,
+  GatewayState as Status,
   StickerFormatType,
   StickerType,
   StringOptionBuilder,
@@ -4982,24 +6434,43 @@ export {
   ThreadManager,
   ThumbnailBuilder,
   User,
+  UserCommandBuilder,
   UserManager,
   UserOptionBuilder,
   VerificationLevel,
   VoiceConnection,
   VoiceConnectionState,
   VoiceError,
+  VoiceReceiver,
+  Webhook,
   WebhookClient,
+  WebhookType,
+  WelcomeScreenChannel,
+  blockQuote,
+  bold,
+  bulletList,
   channelMention,
+  codeBlock,
   createInteraction,
   createRetryPolicy,
   escapeMarkdown,
+  heading,
+  inlineCode,
   isSnowflake,
+  italic,
+  link,
+  masked,
+  orderedList,
   randomInt,
   resolveGatewayIntents,
   roleMention,
-  sleep,
+  sleep3 as sleep,
+  spoiler,
+  strikethrough,
+  subtext,
   timestamp,
+  underline,
   userMention
 };
 
-//# debugId=0DD3C15D8E81668964756E2164756E21
+//# debugId=CB787B7E0E4365B464756E2164756E21