lunibee 0.1.8 → 0.2.0

package/dist/index.js

@@ -53,8 +53,11 @@ var Permission = {
   createEvents: 1n << 44n,
   useExternalSounds: 1n << 45n,
   sendVoiceMessages: 1n << 46n,
+  setVoiceChannelStatus: 1n << 48n,
   sendPolls: 1n << 49n,
-  useExternalApps: 1n << 50n
+  useExternalApps: 1n << 50n,
+  pinMessages: 1n << 51n,
+  bypassSlowmode: 1n << 52n
 };
 var Permissions = {
   CreateInstantInvite: 1n << 0n,
@@ -104,8 +107,11 @@ var Permissions = {
   CreateEvents: 1n << 44n,
   UseExternalSounds: 1n << 45n,
   SendVoiceMessages: 1n << 46n,
+  SetVoiceChannelStatus: 1n << 48n,
   SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
+  UseExternalApps: 1n << 50n,
+  PinMessages: 1n << 51n,
+  BypassSlowmode: 1n << 52n
 };
 var PermissionFlagsBits = {
   CreateInstantInvite: 1n << 0n,
@@ -155,8 +161,11 @@ var PermissionFlagsBits = {
   CreateEvents: 1n << 44n,
   UseExternalSounds: 1n << 45n,
   SendVoiceMessages: 1n << 46n,
+  SetVoiceChannelStatus: 1n << 48n,
   SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
+  UseExternalApps: 1n << 50n,
+  PinMessages: 1n << 51n,
+  BypassSlowmode: 1n << 52n
 };
 
 class PermissionSet {
@@ -358,6 +367,10 @@ class PermissionSet {
     }
     return false;
   }
+  missing(...permissions) {
+    const wanted = new PermissionSet(permissions);
+    return wanted.toArray().filter((name) => !this.has(name));
+  }
   add(...permissions) {
     let bitfield = this.bitfield;
     for (let i = 0;i < permissions.length; i++) {
@@ -419,6 +432,35 @@ class PermissionsBitField extends PermissionSet {
     super(value);
   }
 }
+var ALL_PERMISSIONS = Object.values(Permission).reduce((bits, bit) => bits | bit, 0n);
+var bits = (value) => new PermissionSet(value).bitfield;
+function computePermissions(context) {
+  if (context.ownerId !== undefined && context.ownerId === context.memberId)
+    return new PermissionSet(ALL_PERMISSIONS);
+  const roles = new Map(context.roles.map((role) => [role.id, role]));
+  let base = bits(roles.get(context.guildId)?.permissions ?? 0n);
+  for (const id of context.memberRoleIds)
+    base |= bits(roles.get(id)?.permissions ?? 0n);
+  if (base & Permission.administrator)
+    return new PermissionSet(ALL_PERMISSIONS);
+  const overwrites = context.overwrites ?? [];
+  const everyone = overwrites.find((o) => o.id === context.guildId);
+  if (everyone)
+    base = base & ~bits(everyone.deny) | bits(everyone.allow);
+  const memberRoles = new Set(context.memberRoleIds);
+  let allow = 0n;
+  let deny = 0n;
+  for (const overwrite of overwrites)
+    if (overwrite.type === 0 /* Role */ && overwrite.id !== context.guildId && memberRoles.has(overwrite.id)) {
+      allow |= bits(overwrite.allow);
+      deny |= bits(overwrite.deny);
+    }
+  base = base & ~deny | allow;
+  const member = overwrites.find((o) => o.type === 1 /* Member */ && o.id === context.memberId);
+  if (member)
+    base = base & ~bits(member.deny) | bits(member.allow);
+  return new PermissionSet(base);
+}
 // packages/core/src/events.ts
 var ClientEvent;
 ((ClientEvent) => {
@@ -455,6 +497,13 @@ var ClientEvent;
   ClientEvent["GuildRoleDelete"] = "guildRoleDelete";
   ClientEvent["GuildEmojisUpdate"] = "guildEmojisUpdate";
   ClientEvent["GuildStickersUpdate"] = "guildStickersUpdate";
+  ClientEvent["EntitlementCreate"] = "entitlementCreate";
+  ClientEvent["EntitlementUpdate"] = "entitlementUpdate";
+  ClientEvent["EntitlementDelete"] = "entitlementDelete";
+  ClientEvent["SoundboardSoundCreate"] = "soundboardSoundCreate";
+  ClientEvent["SoundboardSoundUpdate"] = "soundboardSoundUpdate";
+  ClientEvent["SoundboardSoundDelete"] = "soundboardSoundDelete";
+  ClientEvent["SoundboardSoundsUpdate"] = "soundboardSoundsUpdate";
   ClientEvent["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
   ClientEvent["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
   ClientEvent["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
@@ -497,6 +546,9 @@ class Collector extends EventEmitter {
   endReason;
   totalProcessed = 0;
   #timeoutTimer;
+  #idleTimer;
+  #onAbort = () => this.stop("abort");
+  #cleanup = [];
   constructor(options = {}) {
     super();
     this.options = options;
@@ -505,6 +557,27 @@ class Collector extends EventEmitter {
         this.stop("time");
       }, options.time);
     }
+    this.#resetIdle();
+    if (options.signal?.aborted)
+      this.stop("abort");
+    else
+      options.signal?.addEventListener("abort", this.#onAbort, {
+        once: true
+      });
+  }
+  onDispose(cleanup) {
+    if (this.ended)
+      cleanup();
+    else
+      this.#cleanup.push(cleanup);
+    return this;
+  }
+  #resetIdle() {
+    if (!this.options.idle || this.options.idle <= 0)
+      return;
+    if (this.#idleTimer)
+      clearTimeout(this.#idleTimer);
+    this.#idleTimer = setTimeout(() => this.stop("idle"), this.options.idle);
   }
   async handle(key, item) {
     if (this.ended)
@@ -522,6 +595,7 @@ class Collector extends EventEmitter {
       return false;
     }
     this.collected.set(key, item);
+    this.#resetIdle();
     this.emit("collect", item);
     if (this.options.max && this.collected.size >= this.options.max) {
       this.stop("limit");
@@ -540,9 +614,53 @@ class Collector extends EventEmitter {
     this.endReason = reason;
     if (this.#timeoutTimer)
       clearTimeout(this.#timeoutTimer);
+    if (this.#idleTimer)
+      clearTimeout(this.#idleTimer);
+    this.options.signal?.removeEventListener("abort", this.#onAbort);
+    for (const cleanup of this.#cleanup.splice(0)) {
+      try {
+        cleanup();
+      } catch {}
+    }
     this.emit("end", this.collected, reason);
     this.removeAllListeners();
   }
+  wait() {
+    if (this.ended)
+      return Promise.resolve(this.collected);
+    return new Promise((resolve) => this.once("end", (collected) => resolve(collected)));
+  }
+  async* [Symbol.asyncIterator]() {
+    const queue = [];
+    let wake;
+    const onCollect = (item) => {
+      queue.push(item);
+      wake?.();
+    };
+    const onEnd = () => wake?.();
+    if (!this.ended) {
+      this.on("collect", onCollect);
+      this.on("end", onEnd);
+    }
+    try {
+      for (;; ) {
+        if (queue.length > 0) {
+          yield queue.shift();
+          continue;
+        }
+        if (this.ended)
+          return;
+        await new Promise((resolve) => wake = resolve);
+        wake = undefined;
+      }
+    } finally {
+      this.off("collect", onCollect);
+      this.off("end", onEnd);
+    }
+  }
+  [Symbol.dispose]() {
+    this.stop("disposed");
+  }
   next() {
     return new Promise((resolve, reject) => {
       if (this.ended) {
@@ -858,7 +976,340 @@ class Cache {
 }
 
 // packages/collection/src/index.ts
+class RecencyList {
+  #nodes = new Map;
+  #oldest;
+  #newest;
+  get size() {
+    return this.#nodes.size;
+  }
+  oldest() {
+    return this.#oldest?.key;
+  }
+  touch(key) {
+    const node = this.#nodes.get(key);
+    if (node)
+      return this.#moveNewest(node);
+    const created = { key, older: this.#newest };
+    if (this.#newest)
+      this.#newest.newer = created;
+    else
+      this.#oldest = created;
+    this.#newest = created;
+    this.#nodes.set(key, created);
+  }
+  promote(key) {
+    const node = this.#nodes.get(key);
+    if (node)
+      this.#moveNewest(node);
+  }
+  delete(key) {
+    const node = this.#nodes.get(key);
+    if (!node)
+      return false;
+    this.#unlink(node);
+    this.#nodes.delete(key);
+    return true;
+  }
+  clear() {
+    this.#nodes.clear();
+    this.#oldest = this.#newest = undefined;
+  }
+  #unlink(node) {
+    if (node.older)
+      node.older.newer = node.newer;
+    else
+      this.#oldest = node.newer;
+    if (node.newer)
+      node.newer.older = node.older;
+    else
+      this.#newest = node.older;
+    node.older = node.newer = undefined;
+  }
+  #moveNewest(node) {
+    if (node === this.#newest)
+      return;
+    this.#unlink(node);
+    node.older = this.#newest;
+    if (this.#newest)
+      this.#newest.newer = node;
+    else
+      this.#oldest = node;
+    this.#newest = node;
+  }
+}
+function assertTTL(ttl) {
+  if (ttl !== undefined && (!Number.isFinite(ttl) || ttl <= 0))
+    throw new RangeError("TTL must be a positive number, or omitted.");
+}
+
 class Collection extends Map {
+  #ttl;
+  #maxSize;
+  #onEvict;
+  #expiry = new Map;
+  #lru = new RecencyList;
+  #stats = {
+    hits: 0,
+    misses: 0,
+    expired: 0,
+    evicted: 0
+  };
+  #heap = [];
+  #timer;
+  #armedFor = Infinity;
+  constructor(entries, options = {}) {
+    super();
+    assertTTL(options.ttl);
+    if (options.maxSize !== undefined && (!Number.isInteger(options.maxSize) || options.maxSize <= 0))
+      throw new RangeError("maxSize must be a positive integer.");
+    this.#ttl = options.ttl;
+    this.#maxSize = options.maxSize;
+    this.#onEvict = options.onEvict;
+    if (entries)
+      for (const [key, value] of entries)
+        this.set(key, value);
+  }
+  set(key, value, ttl) {
+    assertTTL(ttl);
+    const window = ttl ?? this.#ttl;
+    if (this.#maxSize !== undefined) {
+      this.#lru.touch(key);
+    }
+    super.set(key, value);
+    if (window !== undefined)
+      this.#schedule(key, window);
+    else if (this.#expiry.size > 0)
+      this.#expiry.delete(key);
+    this.#enforceCap();
+    return this;
+  }
+  setWithoutTTL(key, value) {
+    if (this.#expiry.size > 0)
+      this.#expiry.delete(key);
+    if (this.#lru.size > 0)
+      this.#lru.delete(key);
+    super.set(key, value);
+    return this;
+  }
+  get(key) {
+    if (this.#expireIfDue(key)) {
+      this.#stats.misses++;
+      return;
+    }
+    const value = super.get(key);
+    if (value === undefined && !super.has(key)) {
+      this.#stats.misses++;
+      return;
+    }
+    this.#stats.hits++;
+    const expiry = this.#expiry.get(key);
+    if (expiry)
+      expiry.deadline = Date.now() + expiry.window;
+    this.#lru.promote(key);
+    return value;
+  }
+  peek(key) {
+    if (!this.#expireIfDue(key) && super.has(key)) {
+      this.#stats.hits++;
+      return super.get(key);
+    }
+    this.#stats.misses++;
+    return;
+  }
+  get stats() {
+    return { ...this.#stats };
+  }
+  has(key) {
+    return !this.#expireIfDue(key) && super.has(key);
+  }
+  delete(key) {
+    if (this.#expireIfDue(key))
+      return false;
+    this.#expiry.delete(key);
+    this.#lru.delete(key);
+    return super.delete(key);
+  }
+  clear() {
+    super.clear();
+    this.#expiry.clear();
+    this.#lru.clear();
+    this.#heap.length = 0;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    this.#armedFor = Infinity;
+  }
+  get size() {
+    this.purge();
+    return super.size;
+  }
+  entries() {
+    this.purge();
+    return super.entries();
+  }
+  keys() {
+    this.purge();
+    return super.keys();
+  }
+  values() {
+    this.purge();
+    return super.values();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(callback, thisArg) {
+    this.purge();
+    super.forEach(callback, thisArg);
+  }
+  ttlRemaining(key) {
+    if (this.#expireIfDue(key))
+      return;
+    const expiry = this.#expiry.get(key);
+    return expiry && Math.max(0, expiry.deadline - Date.now());
+  }
+  purge() {
+    if (this.#expiry.size === 0)
+      return 0;
+    const now = Date.now();
+    let removed = 0;
+    const dropped = [];
+    while (this.#nextDeadline() <= now) {
+      const due = this.#heapPop();
+      dropped.push([due.key, super.get(due.key)]);
+      this.#remove(due.key);
+      removed++;
+    }
+    this.#stats.expired += removed;
+    this.#rearm();
+    for (const [key, value] of dropped)
+      this.#notify(key, value, "expired");
+    return removed;
+  }
+  #expireIfDue(key) {
+    const expiry = this.#expiry.get(key);
+    if (!expiry || expiry.deadline > Date.now())
+      return false;
+    const value = super.get(key);
+    this.#remove(key);
+    this.#stats.expired++;
+    this.#notify(key, value, "expired");
+    return true;
+  }
+  #remove(key) {
+    this.#expiry.delete(key);
+    this.#lru.delete(key);
+    super.delete(key);
+  }
+  #notify(key, value, reason) {
+    if (!this.#onEvict)
+      return;
+    try {
+      this.#onEvict(key, value, reason);
+    } catch {}
+  }
+  #enforceCap() {
+    if (this.#maxSize === undefined)
+      return;
+    while (this.#lru.size > this.#maxSize) {
+      const oldest = this.#lru.oldest();
+      const value = super.get(oldest);
+      this.#remove(oldest);
+      this.#stats.evicted++;
+      this.#notify(oldest, value, "evicted");
+    }
+  }
+  #schedule(key, window) {
+    const deadline = Date.now() + window;
+    const expiry = this.#expiry.get(key);
+    if (expiry) {
+      expiry.deadline = deadline;
+      expiry.window = window;
+      if (deadline >= expiry.filed)
+        return;
+      expiry.filed = deadline;
+    } else
+      this.#expiry.set(key, { deadline, window, filed: deadline });
+    this.#heapPush({ key, deadline });
+    if (this.#heap.length > 2 * this.#expiry.size + 8)
+      this.#compact();
+    this.#rearm();
+  }
+  #nextDeadline() {
+    for (;; ) {
+      const top = this.#heap[0];
+      if (top === undefined)
+        return Infinity;
+      const expiry = this.#expiry.get(top.key);
+      if (!expiry || expiry.filed !== top.deadline) {
+        this.#heapPop();
+        continue;
+      }
+      if (expiry.deadline === top.deadline)
+        return top.deadline;
+      this.#heapPop();
+      expiry.filed = expiry.deadline;
+      this.#heapPush({ key: top.key, deadline: expiry.deadline });
+    }
+  }
+  #compact() {
+    const live = this.#heap.filter((record) => this.#expiry.get(record.key)?.filed === record.deadline);
+    this.#heap.length = 0;
+    for (const record of live)
+      this.#heapPush(record);
+  }
+  #rearm() {
+    const deadline = this.#nextDeadline();
+    if (this.#timer !== undefined && deadline >= this.#armedFor)
+      return;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    this.#armedFor = deadline;
+    if (deadline === Infinity)
+      return;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      this.#armedFor = Infinity;
+      this.purge();
+    }, Math.max(0, deadline - Date.now()));
+    this.#timer.unref?.();
+  }
+  #heapPush(record) {
+    const heap = this.#heap;
+    heap.push(record);
+    let i = heap.length - 1;
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (heap[parent].deadline <= heap[i].deadline)
+        break;
+      [heap[parent], heap[i]] = [heap[i], heap[parent]];
+      i = parent;
+    }
+  }
+  #heapPop() {
+    const heap = this.#heap;
+    const top = heap[0];
+    const last = heap.pop();
+    if (top === undefined || heap.length === 0)
+      return top;
+    heap[0] = last;
+    for (let i = 0;; ) {
+      const left = 2 * i + 1;
+      const right = left + 1;
+      let smallest = i;
+      if (left < heap.length && heap[left].deadline < heap[smallest].deadline)
+        smallest = left;
+      if (right < heap.length && heap[right].deadline < heap[smallest].deadline)
+        smallest = right;
+      if (smallest === i)
+        break;
+      [heap[smallest], heap[i]] = [heap[i], heap[smallest]];
+      i = smallest;
+    }
+    return top;
+  }
   first() {
     for (const value of this.values())
       return value;
@@ -1083,11 +1534,40 @@ class Manager {
   has(id) {
     return this.cache.has(id);
   }
+  #inflight = new Map;
+  fetchOnce(id, load, store = (value) => {
+    this.set(id, value);
+    return value;
+  }) {
+    const pending = this.#inflight.get(id);
+    if (pending)
+      return pending.promise;
+    const entry = {
+      promise: new Promise((resolve) => resolve(load())),
+      dirty: false
+    };
+    this.#inflight.set(id, entry);
+    entry.promise = entry.promise.then((value) => {
+      this.#inflight.delete(id);
+      return entry.dirty ? this.get(id) ?? value : store(value);
+    }, (error) => {
+      this.#inflight.delete(id);
+      throw error;
+    });
+    return entry.promise;
+  }
+  #markDirty(id) {
+    const pending = this.#inflight.get(id);
+    if (pending)
+      pending.dirty = true;
+  }
   set(id, value) {
-    this.cache.set(id, value);
+    this.#markDirty(id);
+    this.cache.setWithoutTTL(id, value);
     return this;
   }
   delete(id) {
+    this.#markDirty(id);
     return this.cache.delete(id);
   }
   clear() {
@@ -1123,16 +1603,20 @@ class ResourceManager extends Manager {
   async resolve(id) {
     return this.get(id) ?? this.fetch(id);
   }
-  async fetch(id) {
-    const resource = await this.#fetcher(id);
-    this.set(id, resource);
-    return resource;
+  fetch(id) {
+    return this.fetchOnce(id, () => this.#fetcher(id));
   }
   async fetchMany(ids) {
     return Promise.all([...ids].map((id) => this.resolve(id)));
   }
   upsert(resource) {
     const key = this.#key(resource);
+    const existing = this.get(key);
+    if (existing !== undefined && existing !== resource && typeof existing === "object" && existing !== null) {
+      Object.assign(existing, resource);
+      this.set(key, existing);
+      return existing;
+    }
     this.set(key, resource);
     return resource;
   }
@@ -1143,7 +1627,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.8",
+  version: "0.2.0",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -1203,7 +1687,29 @@ class MemoryRateLimitStore {
 }
 
 // packages/rest/src/errors.ts
+function kindFromStatus(status) {
+  if (status === 429)
+    return "rateLimited";
+  if (status === 401)
+    return "authentication";
+  if (status === 403)
+    return "permission";
+  if (status === 404)
+    return "notFound";
+  if (status === 400 || status === 422)
+    return "validation";
+  if (status >= 500)
+    return "server";
+  if (status === 0)
+    return "network";
+  return "client";
+}
+function redactPath(path) {
+  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/, "$1:token");
+}
+
 class RESTError extends Error {
+  kind;
   status;
   code;
   errors;
@@ -1213,14 +1719,18 @@ class RESTError extends Error {
     super(message, options.cause === undefined ? undefined : { cause: options.cause });
     this.name = "RESTError";
     this.status = status;
+    this.kind = options.kind ?? kindFromStatus(status);
     this.code = code;
     this.errors = errors;
     this.method = options.method;
-    this.path = options.path;
+    this.path = options.path === undefined ? undefined : redactPath(options.path);
+  }
+  get retryable() {
+    return this.kind === "rateLimited" || this.kind === "server" || this.kind === "network" || this.kind === "timeout";
   }
 }
 function abortError(path, reason) {
-  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason, kind: "aborted" });
 }
 async function sleep(delay, signal, path) {
   if (delay <= 0)
@@ -1555,8 +2065,23 @@ var Routes = {
   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`
+  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`,
+  pollExpire: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/polls/${snowflake(messageId, "Message ID")}/expire`,
+  pollAnswerVoters: (channelId, messageId, answerId) => `/channels/${snowflake(channelId, "Channel ID")}/polls/${snowflake(messageId, "Message ID")}/answers/${integer(answerId, "Answer ID")}`,
+  guildSticker: (guildId, stickerId) => stickerId ? `/guilds/${snowflake(guildId, "Guild ID")}/stickers/${snowflake(stickerId, "Sticker ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/stickers`,
+  sendSoundboardSound: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/send-soundboard-sound`,
+  soundboardDefaultSounds: () => "/soundboard-default-sounds",
+  guildSoundboardSound: (guildId, soundId) => soundId ? `/guilds/${snowflake(guildId, "Guild ID")}/soundboard-sounds/${snowflake(soundId, "Sound ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/soundboard-sounds`,
+  applicationSkus: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/skus`,
+  applicationEntitlement: (applicationId, entitlementId) => entitlementId ? `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/entitlements`,
+  consumeEntitlement: (applicationId, entitlementId) => `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}/consume`,
+  skuSubscription: (skuId, subscriptionId) => subscriptionId ? `/skus/${snowflake(skuId, "SKU ID")}/subscriptions/${snowflake(subscriptionId, "Subscription ID")}` : `/skus/${snowflake(skuId, "SKU ID")}/subscriptions`
 };
+function integer(value, field) {
+  if (!Number.isInteger(value) || value < 0)
+    throw new TypeError(`${field} must be a non-negative integer.`);
+  return String(value);
+}
 function snowflake(value, field) {
   if (!/^\d{1,20}$/.test(value))
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
@@ -1870,7 +2395,8 @@ class REST {
         throw new RESTError(failure.message, 0, undefined, undefined, {
           method,
           path,
-          cause: failure.cause ?? failure
+          cause: failure.cause ?? failure,
+          kind: failure.timedOut ? "timeout" : "network"
         });
       }
       this.#emit(this.#hooks.onResponse, {
@@ -1969,6 +2495,9 @@ class REST {
   #emit(hook, ctx) {
     if (!hook)
       return;
+    const withPath = ctx;
+    if (typeof withPath.path === "string")
+      ctx = { ...ctx, path: redactPath(withPath.path) };
     Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
 }
@@ -2045,6 +2574,7 @@ class Channel extends BaseStructure {
   nsfw;
   rateLimitPerUser;
   position;
+  permissionOverwrites;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -2058,6 +2588,7 @@ class Channel extends BaseStructure {
     this.nsfw = data.nsfw;
     this.rateLimitPerUser = data.rate_limit_per_user;
     this.position = data.position;
+    this.permissionOverwrites = (data.permission_overwrites ?? []).map((overwrite) => ({ ...overwrite }));
     this.#context = context;
   }
   sendMessage(options) {
@@ -2810,6 +3341,17 @@ var InteractionType = {
   ApplicationCommandAutocomplete: 4,
   ModalSubmit: 5
 };
+var EPHEMERAL = 64;
+var TOKEN_LIFETIME_MS = 15 * 60000;
+var DISCORD_EPOCH = 1420070400000n;
+function toMessageData(options) {
+  if (typeof options === "string")
+    return { content: options };
+  const { ephemeral, ...data } = options;
+  if (ephemeral)
+    data.flags = (typeof data.flags === "number" ? data.flags : 0) | EPHEMERAL;
+  return data;
+}
 
 class InteractionResponse {
   type;
@@ -2824,14 +3366,10 @@ class InteractionResponse {
     return this.data === undefined ? { type: this.type } : { type: this.type, data: this.data };
   }
   static message(options) {
-    const data = { ...options };
-    if (options.ephemeral) {
-      data.flags = (typeof options.flags === "number" ? options.flags : 0) | 64;
-    }
-    return new InteractionResponse(InteractionResponseType.ChannelMessage, data);
+    return new InteractionResponse(InteractionResponseType.ChannelMessage, toMessageData(options));
   }
   static defer(ephemeral = false) {
-    return new InteractionResponse(InteractionResponseType.DeferredChannelMessage, ephemeral ? { flags: 64 } : undefined);
+    return new InteractionResponse(InteractionResponseType.DeferredChannelMessage, ephemeral ? { flags: EPHEMERAL } : undefined);
   }
   static pong() {
     return new InteractionResponse(InteractionResponseType.Pong);
@@ -2849,6 +3387,7 @@ class Interaction {
   replied = false;
   deferred = false;
   #client;
+  #acknowledging = false;
   constructor(client, data) {
     if (!data.id || !data.token)
       throw new TypeError("Interaction ID and token are required.");
@@ -2898,9 +3437,57 @@ class Interaction {
     return [3, 5, 6, 7, 8].includes(this.#componentType());
   }
   assertUnacknowledged() {
-    if (this.replied || this.deferred)
+    if (this.replied || this.deferred || this.#acknowledging)
       throw new Error("Interaction has already been acknowledged.");
   }
+  async acknowledge(response, state) {
+    this.assertUnacknowledged();
+    this.#acknowledging = true;
+    try {
+      const result = await this.postResponse(response);
+      this[state] = true;
+      return result;
+    } finally {
+      this.#acknowledging = false;
+    }
+  }
+  get user() {
+    const raw = this.data.member?.user ?? this.data.user;
+    return raw ? new User(raw) : null;
+  }
+  get member() {
+    const raw = this.data.member;
+    if (!raw || !this.guildId)
+      return null;
+    return new GuildMember({
+      ...raw,
+      guild_id: this.guildId
+    });
+  }
+  get createdTimestamp() {
+    return Number((BigInt(this.id) >> 22n) + DISCORD_EPOCH);
+  }
+  get expiresAt() {
+    return new Date(this.createdTimestamp + TOKEN_LIFETIME_MS);
+  }
+  get isExpired() {
+    return Date.now() >= this.createdTimestamp + TOKEN_LIFETIME_MS;
+  }
+  #webhookMessage(method, messageId, data) {
+    if (!this.#client.interactionWebhookMessage)
+      return Promise.reject(new Error("This interaction client does not support webhook message access."));
+    return this.#client.interactionWebhookMessage(method, this.applicationId, this.token, messageId, data);
+  }
+  fetchReply() {
+    this.assertAcknowledged();
+    return this.#webhookMessage("GET", "@original");
+  }
+  editFollowUp(messageId, options) {
+    return this.#webhookMessage("PATCH", messageId, toMessageData(options));
+  }
+  async deleteFollowUp(messageId) {
+    await this.#webhookMessage("DELETE", messageId);
+  }
   assertAcknowledged() {
     if (!this.replied && !this.deferred)
       throw new Error("Interaction has not been acknowledged.");
@@ -2909,41 +3496,27 @@ class Interaction {
     return this.#client.postInteractionResponse(this.id, this.token, response);
   }
   async reply(options) {
-    this.assertUnacknowledged();
-    const payload = typeof options === "string" ? { content: options } : options;
-    const result = await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.message(payload));
-    this.replied = true;
-    return result;
+    return this.acknowledge(InteractionResponse.message(toMessageData(options)), "replied");
   }
   async deferReply(ephemeral = false) {
-    this.assertUnacknowledged();
-    await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.defer(ephemeral));
-    this.deferred = true;
+    await this.acknowledge(InteractionResponse.defer(ephemeral), "deferred");
   }
   editReply(options) {
     this.assertAcknowledged();
-    return this.#client.editInteractionReply(this.token, options);
+    return this.#client.editInteractionReply(this.token, toMessageData(options));
   }
   deleteReply() {
     this.assertAcknowledged();
     return this.#client.deleteInteractionReply(this.token);
   }
   followUp(options) {
-    const payload = typeof options === "string" ? { content: options } : options;
-    return this.#client.followUpInteraction(this.token, payload);
+    return this.#client.followUpInteraction(this.token, toMessageData(options));
   }
   async update(options) {
-    this.assertUnacknowledged();
-    const payload = typeof options === "string" ? { content: options } : options;
-    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
-    this.replied = true;
-    return result;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.MessageUpdate, toMessageData(options)), "replied");
   }
   async showModal(modal) {
-    this.assertUnacknowledged();
-    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.Modal, modal));
-    this.replied = true;
-    return result;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.Modal, modal), "replied");
   }
 }
 
@@ -2971,16 +3544,10 @@ class ComponentInteraction extends Interaction {
     return this.data?.data?.values ?? [];
   }
   async deferUpdate() {
-    this.assertUnacknowledged();
-    await this.postResponse(new InteractionResponse(InteractionResponseType.DeferredMessageUpdate));
-    this.deferred = true;
+    await this.acknowledge(new InteractionResponse(InteractionResponseType.DeferredMessageUpdate), "deferred");
   }
   async update(options) {
-    this.assertUnacknowledged();
-    const payload = typeof options === "string" ? { content: options } : options;
-    const result = await this.postResponse(new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
-    this.replied = true;
-    return result;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.MessageUpdate, toMessageData(options)), "replied");
   }
 }
 
@@ -3023,8 +3590,7 @@ class AutocompleteInteraction extends Interaction {
     if (!Array.isArray(choices))
       throw new TypeError("Autocomplete choices must be an array.");
     const response = new InteractionResponse(InteractionResponseType.Autocomplete, { choices });
-    await this.postResponse(response);
-    this.replied = true;
+    await this.acknowledge(response, "replied");
   }
 }
 function findFocused(options) {
@@ -3377,16 +3943,22 @@ class Message extends BaseStructure {
 
 // packages/managers/src/message.ts
 class MessageManager {
-  cache = new Collection;
+  cache;
+  #caching;
   #rest;
   #context;
   #channelId;
-  constructor(rest, context, channelId) {
+  constructor(rest, context, channelId, cache) {
     if (!channelId)
       throw new TypeError("Channel ID is required.");
     this.#rest = rest;
     this.#context = context;
     this.#channelId = channelId;
+    this.#caching = cache !== undefined;
+    this.cache = new Collection(null, {
+      ttl: cache?.ttl,
+      maxSize: cache ? cache.maxSize ?? 100 : undefined
+    });
   }
   async resolve(messageId) {
     return this.cache.get(messageId) ?? this.fetch(messageId);
@@ -3403,13 +3975,14 @@ class MessageManager {
     return Promise.all(Array.from(messageIds, (messageId) => this.fetch(messageId)));
   }
   upsert(data) {
-    const existing = this.cache.get(data.id);
+    const existing = this.cache.peek(data.id);
     const message = new Message(data, this.#context);
     if (existing) {
       Object.assign(existing, message);
       return existing;
     }
-    this.cache.set(message.id, message);
+    if (this.#caching)
+      this.cache.set(message.id, message);
     return message;
   }
   delete(messageId) {
@@ -3463,8 +4036,295 @@ class UserManager extends ResourceManager {
     });
   }
 }
+// packages/managers/src/emoji.ts
+class EmojiManager extends Manager {
+  #rest;
+  #guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.#guildId = guildId;
+  }
+  fetch(emojiId) {
+    return this.fetchOnce(emojiId, async () => new Emoji(await this.#rest.get(Routes.guildEmoji(this.#guildId, emojiId))), (emoji) => this.#merge(emojiId, emoji));
+  }
+  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 ?? ""}`;
+    return this.#merge(key, new Emoji(data));
+  }
+  #merge(key, emoji) {
+    const existing = this.get(key);
+    if (existing) {
+      Object.assign(existing, emoji);
+      return existing;
+    }
+    this.set(key, emoji);
+    return emoji;
+  }
+}
+
+// packages/managers/src/advanced.ts
+function withQuery(path, query) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(query))
+    if (value !== undefined)
+      params.set(key, String(value));
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildStickerManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(sticker) {
+    this.set(sticker.id, sticker);
+    return sticker;
+  }
+  async fetchAll() {
+    const stickers = await this.#rest.get(Routes.guildSticker(this.guildId));
+    this.clear();
+    return stickers.map((sticker) => this.#store(sticker));
+  }
+  async fetch(stickerId) {
+    return this.#store(await this.#rest.get(Routes.guildSticker(this.guildId, stickerId)));
+  }
+  async create(options) {
+    const form = new FormData;
+    form.set("name", options.name);
+    form.set("description", options.description);
+    form.set("tags", options.tags);
+    form.set("file", options.file);
+    return this.#store(await this.#rest.post(Routes.guildSticker(this.guildId), form, { reason: options.reason }));
+  }
+  async edit(stickerId, options) {
+    const { reason, ...body } = options;
+    return this.#store(await this.#rest.patch(Routes.guildSticker(this.guildId, stickerId), body, { reason }));
+  }
+  async remove(stickerId, reason) {
+    await this.#rest.delete(Routes.guildSticker(this.guildId, stickerId), {
+      reason
+    });
+    this.delete(stickerId);
+  }
+  sync(stickers) {
+    this.clear();
+    for (const sticker of stickers)
+      this.#store(sticker);
+  }
+}
+
+class GuildSoundboardManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(sound) {
+    this.set(sound.sound_id, sound);
+    return sound;
+  }
+  async fetchAll() {
+    const { items } = await this.#rest.get(Routes.guildSoundboardSound(this.guildId));
+    this.clear();
+    return items.map((sound) => this.#store(sound));
+  }
+  async fetch(soundId) {
+    return this.#store(await this.#rest.get(Routes.guildSoundboardSound(this.guildId, soundId)));
+  }
+  async create(options) {
+    if (options.volume !== undefined && (options.volume < 0 || options.volume > 1))
+      throw new RangeError("Soundboard volume must be between 0 and 1.");
+    return this.#store(await this.#rest.post(Routes.guildSoundboardSound(this.guildId), {
+      name: options.name,
+      sound: options.sound,
+      volume: options.volume,
+      emoji_id: options.emojiId,
+      emoji_name: options.emojiName
+    }, { reason: options.reason }));
+  }
+  async edit(soundId, options) {
+    return this.#store(await this.#rest.patch(Routes.guildSoundboardSound(this.guildId, soundId), {
+      name: options.name,
+      volume: options.volume,
+      emoji_id: options.emojiId,
+      emoji_name: options.emojiName
+    }, { reason: options.reason }));
+  }
+  async remove(soundId, reason) {
+    await this.#rest.delete(Routes.guildSoundboardSound(this.guildId, soundId), { reason });
+    this.delete(soundId);
+  }
+}
+
+class MonetizationManager extends Manager {
+  #rest;
+  applicationId;
+  constructor(rest, applicationId) {
+    super();
+    this.#rest = rest;
+    this.applicationId = applicationId;
+  }
+  fetchSkus() {
+    return this.#rest.get(Routes.applicationSkus(this.applicationId));
+  }
+  async fetchEntitlements(query = {}) {
+    if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100))
+      throw new RangeError("Entitlement limit must be 1-100.");
+    const entitlements = await this.#rest.get(withQuery(Routes.applicationEntitlement(this.applicationId), {
+      user_id: query.userId,
+      sku_ids: query.skuIds?.join(","),
+      guild_id: query.guildId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit,
+      exclude_ended: query.excludeEnded,
+      exclude_deleted: query.excludeDeleted
+    }));
+    for (const entitlement of entitlements)
+      this.set(entitlement.id, entitlement);
+    return entitlements;
+  }
+  async fetch(entitlementId) {
+    const entitlement = await this.#rest.get(Routes.applicationEntitlement(this.applicationId, entitlementId));
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async consume(entitlementId) {
+    await this.#rest.post(Routes.consumeEntitlement(this.applicationId, entitlementId));
+    const cached = this.get(entitlementId);
+    if (cached)
+      cached.consumed = true;
+  }
+  async createTestEntitlement(options) {
+    const entitlement = await this.#rest.post(Routes.applicationEntitlement(this.applicationId), {
+      sku_id: options.skuId,
+      owner_id: options.ownerId,
+      owner_type: options.ownerType
+    });
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async deleteTestEntitlement(entitlementId) {
+    await this.#rest.delete(Routes.applicationEntitlement(this.applicationId, entitlementId));
+    this.delete(entitlementId);
+  }
+  fetchSubscriptions(skuId, query = {}) {
+    return this.#rest.get(withQuery(Routes.skuSubscription(skuId), {
+      user_id: query.userId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit
+    }));
+  }
+  fetchSubscription(skuId, subscriptionId) {
+    return this.#rest.get(Routes.skuSubscription(skuId, subscriptionId));
+  }
+}
+
+// packages/managers/src/member.ts
+class GuildMemberManager extends ResourceManager {
+  #rest;
+  guildId;
+  constructor(guildId, rest) {
+    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId })), (member) => member.user.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+  }
+  async kick(userId) {
+    await this.#rest.delete(Routes.guildMember(this.guildId, userId));
+    this.delete(userId);
+  }
+  async ban(userId, options = {}) {
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+    this.delete(userId);
+  }
+  async unban(userId) {
+    await this.#rest.delete(Routes.guildBan(this.guildId, userId));
+  }
+  async edit(userId, options) {
+    const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), options);
+    const member = new GuildMember({ ...data, guild_id: this.guildId });
+    this.set(member.user.id, member);
+    return member;
+  }
+  async addRole(userId, roleId) {
+    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId));
+  }
+  async removeRole(userId, roleId) {
+    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId));
+  }
+  async timeout(userId, milliseconds) {
+    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
+    return this.edit(userId, { communication_disabled_until: timeoutDate });
+  }
+}
+
+// packages/managers/src/role.ts
+class RoleManager extends ResourceManager {
+  #rest;
+  guildId;
+  constructor(guildId, rest) {
+    super((id) => rest.get(Routes.guildRole(guildId, id)).then((data) => new Role(data)), (role) => role.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes.guildRoles(this.guildId));
+    return data.map((item) => {
+      const role = new Role(item);
+      this.set(role.id, role);
+      return role;
+    });
+  }
+  async create(options) {
+    const { reason, ...payload } = options;
+    const data = await this.#rest.post(Routes.guildRoles(this.guildId), {
+      ...payload,
+      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
+    });
+    const role = new Role(data);
+    this.set(role.id, role);
+    return role;
+  }
+  async edit(roleId, options) {
+    const { reason, ...payload } = options;
+    const data = await this.#rest.patch(Routes.guildRole(this.guildId, roleId), {
+      ...payload,
+      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
+    });
+    const role = new Role(data);
+    this.set(role.id, role);
+    return role;
+  }
+  async deleteRole(roleId) {
+    await this.#rest.delete(Routes.guildRole(this.guildId, roleId));
+    this.delete(roleId);
+  }
+}
+
 // packages/managers/src/guild-resources.ts
-function withQuery(path, params) {
+function withQuery2(path, params) {
   const query = new URLSearchParams;
   for (const [key, value] of Object.entries(params))
     if (value !== undefined)
@@ -3488,7 +4348,7 @@ class GuildBanManager extends Manager {
   }
   async fetchAll(options = {}) {
     const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
-    const bans = await this.#rest.get(withQuery(Routes.guildBans(this.guildId), {
+    const bans = await this.#rest.get(withQuery2(Routes.guildBans(this.guildId), {
       limit,
       before: options.before,
       after: options.after
@@ -3521,12 +4381,12 @@ class GuildScheduledEventManager extends Manager {
     return event;
   }
   async fetch(eventId, options = {}) {
-    return this.#store(await this.#rest.get(withQuery(Routes.guildScheduledEvent(this.guildId, eventId), {
+    return this.#store(await this.#rest.get(withQuery2(Routes.guildScheduledEvent(this.guildId, eventId), {
       with_user_count: options.withUserCount
     })));
   }
   async fetchAll(options = {}) {
-    const events = await this.#rest.get(withQuery(Routes.guildScheduledEvents(this.guildId), {
+    const events = await this.#rest.get(withQuery2(Routes.guildScheduledEvents(this.guildId), {
       with_user_count: options.withUserCount
     }));
     return events.map((event) => this.#store(event));
@@ -3543,7 +4403,7 @@ class GuildScheduledEventManager extends Manager {
   }
   async fetchSubscribers(eventId, options = {}) {
     const limit = options.limit === undefined ? undefined : Math.min(100, Math.max(1, options.limit));
-    return this.#rest.get(withQuery(Routes.guildScheduledEventUsers(this.guildId, eventId), {
+    return this.#rest.get(withQuery2(Routes.guildScheduledEventUsers(this.guildId, eventId), {
       limit,
       with_member: options.withMember,
       before: options.before,
@@ -3605,7 +4465,7 @@ class PermissionOverwriteManager {
 }
 
 // packages/managers/src/guild.ts
-function withQuery2(path, params) {
+function withQuery3(path, params) {
   const suffix = params.toString();
   return suffix ? `${path}?${suffix}` : path;
 }
@@ -3614,22 +4474,98 @@ class GuildManager extends ResourceManager {
   #rest;
   #bans = new Map;
   #scheduledEvents = new Map;
+  #members = new Map;
+  #roles = new Map;
+  #emojis = new Map;
+  #stickers = new Map;
+  #soundboard = new Map;
+  #voiceStates = new Map;
+  #autoModerationRules = new Map;
+  #invites = new Map;
+  #perGuild(map, guildId, create) {
+    let manager = map.get(guildId);
+    if (!manager)
+      map.set(guildId, manager = create());
+    return manager;
+  }
   constructor(rest) {
     super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
     this.#rest = rest;
   }
-  bans(guildId) {
-    let manager = this.#bans.get(guildId);
+  bans(guildId) {
+    let manager = this.#bans.get(guildId);
+    if (!manager)
+      this.#bans.set(guildId, manager = new GuildBanManager(this.#rest, guildId));
+    return manager;
+  }
+  scheduledEvents(guildId) {
+    let manager = this.#scheduledEvents.get(guildId);
+    if (!manager)
+      this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager(this.#rest, guildId));
+    return manager;
+  }
+  members(guildId) {
+    let manager = this.#members.get(guildId);
+    if (!manager)
+      this.#members.set(guildId, manager = new GuildMemberManager(guildId, this.#rest));
+    return manager;
+  }
+  roles(guildId) {
+    let manager = this.#roles.get(guildId);
     if (!manager)
-      this.#bans.set(guildId, manager = new GuildBanManager(this.#rest, guildId));
+      this.#roles.set(guildId, manager = new RoleManager(guildId, this.#rest));
     return manager;
   }
-  scheduledEvents(guildId) {
-    let manager = this.#scheduledEvents.get(guildId);
+  emojis(guildId) {
+    let manager = this.#emojis.get(guildId);
     if (!manager)
-      this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager(this.#rest, guildId));
+      this.#emojis.set(guildId, manager = new EmojiManager(this.#rest, guildId));
     return manager;
   }
+  stickers(guildId) {
+    let manager = this.#stickers.get(guildId);
+    if (!manager)
+      this.#stickers.set(guildId, manager = new GuildStickerManager(this.#rest, guildId));
+    return manager;
+  }
+  soundboard(guildId) {
+    let manager = this.#soundboard.get(guildId);
+    if (!manager)
+      this.#soundboard.set(guildId, manager = new GuildSoundboardManager(this.#rest, guildId));
+    return manager;
+  }
+  voiceStates(guildId) {
+    return this.#perGuild(this.#voiceStates, guildId, () => new Manager);
+  }
+  autoModerationRules(guildId) {
+    return this.#perGuild(this.#autoModerationRules, guildId, () => new Manager);
+  }
+  invites(guildId) {
+    return this.#perGuild(this.#invites, guildId, () => new Manager);
+  }
+  patch(data) {
+    const guild = new Guild(data);
+    const existing = this.get(guild.id);
+    if (!existing)
+      return this.upsert(guild);
+    for (const [key, value] of Object.entries(guild))
+      if (value !== undefined)
+        existing[key] = value;
+    return existing;
+  }
+  delete(id) {
+    this.#bans.delete(id);
+    this.#scheduledEvents.delete(id);
+    this.#members.delete(id);
+    this.#roles.delete(id);
+    this.#emojis.delete(id);
+    this.#stickers.delete(id);
+    this.#soundboard.delete(id);
+    this.#voiceStates.delete(id);
+    this.#autoModerationRules.delete(id);
+    this.#invites.delete(id);
+    return super.delete(id);
+  }
   async create(options) {
     const data = await this.#rest.post("/guilds", options);
     return this.upsert(new Guild(data));
@@ -3665,7 +4601,7 @@ class GuildManager extends ResourceManager {
       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(withQuery2(Routes.guildAuditLog(guildId), params));
+    return this.#rest.get(withQuery3(Routes.guildAuditLog(guildId), params));
   }
   async fetchMembers(guildId, options = {}) {
     const params = new URLSearchParams;
@@ -3673,7 +4609,7 @@ class GuildManager extends ResourceManager {
       params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
     if (options.after)
       params.set("after", options.after);
-    return this.#rest.get(withQuery2(Routes.guildMembers(guildId), params));
+    return this.#rest.get(withQuery3(Routes.guildMembers(guildId), params));
   }
   async fetchAutoModerationRules(guildId) {
     const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
@@ -3748,85 +4684,6 @@ var AuditLogEvent = {
   AutoModerationRuleDelete: 142,
   AutoModerationBlockMessage: 143
 };
-// packages/managers/src/role.ts
-class RoleManager extends ResourceManager {
-  #rest;
-  guildId;
-  constructor(guildId, rest) {
-    super((id) => rest.get(Routes.guildRole(guildId, id)).then((data) => new Role(data)), (role) => role.id);
-    this.guildId = guildId;
-    this.#rest = rest;
-  }
-  async fetchAll() {
-    const data = await this.#rest.get(Routes.guildRoles(this.guildId));
-    return data.map((item) => {
-      const role = new Role(item);
-      this.set(role.id, role);
-      return role;
-    });
-  }
-  async create(options) {
-    const { reason, ...payload } = options;
-    const data = await this.#rest.post(Routes.guildRoles(this.guildId), {
-      ...payload,
-      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
-    });
-    const role = new Role(data);
-    this.set(role.id, role);
-    return role;
-  }
-  async edit(roleId, options) {
-    const { reason, ...payload } = options;
-    const data = await this.#rest.patch(Routes.guildRole(this.guildId, roleId), {
-      ...payload,
-      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
-    });
-    const role = new Role(data);
-    this.set(role.id, role);
-    return role;
-  }
-  async deleteRole(roleId) {
-    await this.#rest.delete(Routes.guildRole(this.guildId, roleId));
-    this.delete(roleId);
-  }
-}
-// packages/managers/src/member.ts
-class GuildMemberManager extends ResourceManager {
-  #rest;
-  guildId;
-  constructor(guildId, rest) {
-    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId })), (member) => member.user.id);
-    this.guildId = guildId;
-    this.#rest = rest;
-  }
-  async kick(userId) {
-    await this.#rest.delete(Routes.guildMember(this.guildId, userId));
-    this.delete(userId);
-  }
-  async ban(userId, options = {}) {
-    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
-    this.delete(userId);
-  }
-  async unban(userId) {
-    await this.#rest.delete(Routes.guildBan(this.guildId, userId));
-  }
-  async edit(userId, options) {
-    const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), options);
-    const member = new GuildMember({ ...data, guild_id: this.guildId });
-    this.set(member.user.id, member);
-    return member;
-  }
-  async addRole(userId, roleId) {
-    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId));
-  }
-  async removeRole(userId, roleId) {
-    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId));
-  }
-  async timeout(userId, milliseconds) {
-    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
-    return this.edit(userId, { communication_disabled_until: timeoutDate });
-  }
-}
 // packages/managers/src/application.ts
 class ApplicationCommandManager {
   #rest;
@@ -3866,53 +4723,22 @@ 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
+var BULK_DELETE_MAX_AGE_MS = 14 * 24 * 60 * 60000;
+function snowflakeTime(id) {
+  return Number((BigInt(id) >> 22n) + 1420070400000n);
+}
+
 class ChannelManager extends Manager {
   #rest;
   #context;
   #messageManagers = new Map;
-  constructor(rest) {
+  #messageCache;
+  constructor(rest, options = {}) {
     super();
     this.#rest = rest;
+    this.#messageCache = options.messageCache;
     this.#context = {
       sendMessage: (channelId, options) => this.send(channelId, options),
       editMessage: (channelId, messageId, options) => this.editMessage(channelId, messageId, options),
@@ -3931,7 +4757,7 @@ class ChannelManager extends Manager {
   messages(channelId) {
     let manager = this.#messageManagers.get(channelId);
     if (!manager) {
-      manager = new MessageManager(this.#rest, this.#context, channelId);
+      manager = new MessageManager(this.#rest, this.#context, channelId, this.#messageCache);
       this.#messageManagers.set(channelId, manager);
     }
     return manager;
@@ -3942,16 +4768,18 @@ class ChannelManager extends Manager {
   threads(channelId) {
     return new ThreadManager(this.#rest, this.#context, channelId);
   }
-  async fetch(channelId) {
-    return this.upsert(await this.#rest.get(Routes.channel(channelId)));
+  fetch(channelId) {
+    return this.fetchOnce(channelId, async () => createChannel(await this.#rest.get(Routes.channel(channelId)), this.#context), (channel) => this.#merge(channel));
   }
   async resolve(channelId) {
     return this.get(channelId) ?? this.fetch(channelId);
   }
   upsert(data) {
-    const existing = this.get(data.id);
-    const channel = createChannel(data, this.#context);
-    if (existing) {
+    return this.#merge(createChannel(data, this.#context));
+  }
+  #merge(channel) {
+    const existing = this.get(channel.id);
+    if (existing && existing.type === channel.type) {
       Object.assign(existing, channel);
       return existing;
     }
@@ -3961,6 +4789,37 @@ class ChannelManager extends Manager {
   update(channel) {
     return this.set(channel.id, channel);
   }
+  deleteGuildChannels(guildId) {
+    let removed = 0;
+    for (const channel of this.values())
+      if (channel.guildId === guildId && this.delete(channel.id))
+        removed++;
+    return removed;
+  }
+  async endPoll(channelId, messageId) {
+    return this.messages(channelId).upsert(await this.#rest.post(Routes.pollExpire(channelId, messageId)));
+  }
+  async fetchPollVoters(channelId, messageId, answerId, options = {}) {
+    if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 100))
+      throw new RangeError("Poll voter limit must be 1-100.");
+    const params = new URLSearchParams;
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    const suffix = params.toString();
+    const { users } = await this.#rest.get(`${Routes.pollAnswerVoters(channelId, messageId, answerId)}${suffix ? `?${suffix}` : ""}`);
+    return users.map((user) => new User(user));
+  }
+  async sendSoundboardSound(channelId, options) {
+    await this.#rest.post(Routes.sendSoundboardSound(channelId), {
+      sound_id: options.soundId,
+      source_guild_id: options.sourceGuildId
+    });
+  }
+  cachedMessages(channelId) {
+    return this.#messageManagers.get(channelId);
+  }
   async create(guildId, options) {
     return this.upsert(await this.#rest.post(Routes.guildChannels(guildId), options));
   }
@@ -4017,15 +4876,37 @@ class ChannelManager extends Manager {
     return this.messages(channelId).upsert(await this.#rest.post(Routes.crosspostMessage(channelId, messageId)));
   }
   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.");
+    const ids = [...new Set(messageIds)];
+    if (ids.length < 1 || ids.length > 100)
+      throw new RangeError("bulkDelete requires between 1 and 100 message IDs.");
+    if (ids.length === 1)
+      return this.deleteMessage(channelId, ids[0]);
+    const cutoff = Date.now() - BULK_DELETE_MAX_AGE_MS;
+    const tooOld = ids.filter((id) => snowflakeTime(id) < cutoff);
+    if (tooOld.length)
+      throw new RangeError(`bulkDelete cannot delete messages older than 14 days: ${tooOld.join(", ")}`);
     await this.#rest.post(Routes.channelBulkDelete(channelId), {
       messages: ids
     });
     for (const id of ids)
       this.messages(channelId).delete(id);
   }
+  async* iterateMessages(channelId, options = {}) {
+    let before = options.before;
+    let remaining = options.limit ?? Infinity;
+    while (remaining > 0) {
+      const page = await this.fetchMessages(channelId, {
+        before,
+        limit: Math.min(100, remaining)
+      });
+      for (const message of page)
+        yield message;
+      remaining -= page.length;
+      if (page.length < 100)
+        return;
+      before = page.at(-1).id;
+    }
+  }
   async addReaction(channelId, messageId, emoji) {
     await this.#rest.put(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
   }
@@ -4121,6 +5002,8 @@ class GatewaySession {
       return false;
     if (!Number.isInteger(sequence))
       return false;
+    if (this.#sequence !== null && sequence < this.#sequence)
+      return false;
     this.#sequence = sequence;
     return true;
   }
@@ -4219,8 +5102,11 @@ class GatewayHeartbeat {
     this.#clearBeatTimers();
     this.#interval = interval;
     this.#acknowledged = true;
-    this.#initialTimer = setTimeout(() => this.sendHeartbeat(), Math.random() * interval);
-    this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+    this.#initialTimer = setTimeout(() => {
+      this.#initialTimer = undefined;
+      this.sendHeartbeat();
+      this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+    }, Math.random() * interval);
   }
   stop() {
     this.#clearBeatTimers();
@@ -4246,6 +5132,8 @@ class GatewayHeartbeat {
     }, this.#options.ackTimeout);
   }
   acknowledge() {
+    if (this.#acknowledged)
+      return;
     this.#acknowledged = true;
     this.#latency = this.#now() - this.#sentAt;
     this.#clearAckTimer();
@@ -4826,6 +5714,7 @@ class SendBudget {
 }
 
 // packages/ws/src/index.ts
+var RESUMABLE_CLOSE_CODE = 4900;
 var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
 
 class Gateway {
@@ -4911,7 +5800,7 @@ class Gateway {
     } else {
       this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${timeout.elapsedMs}ms.`));
     }
-    this.#transport.close(1001, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
+    this.#transport.close(RESUMABLE_CLOSE_CODE, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
   }
   connect(url = DEFAULT_GATEWAY_URL) {
     if (this.state === "CLOSED" /* Closed */)
@@ -5047,7 +5936,7 @@ class Gateway {
         this.#emit("heartbeatAck", action.data);
         return;
       case "reconnect":
-        this.#transport.close(1001, "Server requested reconnect");
+        this.#transport.close(RESUMABLE_CLOSE_CODE, "Server requested reconnect");
         return;
       case "invalid-session": {
         if (!action.resumable)
@@ -5241,6 +6130,7 @@ class Client extends EventEmitter2 {
   channels;
   stageInstances;
   application;
+  monetization;
   get ws() {
     return this.#gateway;
   }
@@ -5272,6 +6162,7 @@ class Client extends EventEmitter2 {
     return this.#gateway.requestGuildMembers(data);
   }
   #gateway;
+  #cache;
   #resourceContext;
   constructor(options) {
     super();
@@ -5279,9 +6170,18 @@ class Client extends EventEmitter2 {
     if (!options.token?.trim())
       throw new TypeError("Client token is required.");
     this.rest = new REST({ token: options.token, ...options.rest });
+    this.#cache = {
+      users: true,
+      members: true,
+      roles: true,
+      emojis: true,
+      ...options.cache
+    };
     this.users = new UserManager(this.rest);
     this.guilds = new GuildManager(this.rest);
-    this.channels = new ChannelManager(this.rest);
+    this.channels = new ChannelManager(this.rest, {
+      messageCache: options.messageCache
+    });
     this.stageInstances = new StageInstanceManager(this.rest);
     const placeholderAppCommands = new ApplicationCommandManager(this.rest, "0");
     this.application = { commands: placeholderAppCommands };
@@ -5312,6 +6212,8 @@ class Client extends EventEmitter2 {
       this.state = "ready";
       const appId = ready.application?.id ?? this.user.id;
       this.application.commands = new ApplicationCommandManager(this.rest, appId);
+      if (this.monetization?.applicationId !== appId)
+        this.monetization = new MonetizationManager(this.rest, appId);
       this.emit("ready" /* Ready */, this.user);
     });
     this.#gateway.on("RESUMED", () => {
@@ -5329,18 +6231,39 @@ class Client extends EventEmitter2 {
     });
     this.#gateway.on("MESSAGE_CREATE", (data) => {
       const message = new Message(data, this.#resourceContext);
-      this.channels.set(message.channelId, message.channel);
-      this.users.set(message.author.id, message.author);
-      this.emit("messageCreate" /* MessageCreate */, message);
+      this.#observeMessage(message);
+      const cached = this.options.messageCache ? this.channels.messages(message.channelId).upsert(data) : message;
+      this.emit("messageCreate" /* MessageCreate */, cached);
     });
     this.#gateway.on("MESSAGE_UPDATE", (data) => {
       const message = new Message(data, this.#resourceContext);
-      this.channels.set(message.channelId, message.channel);
-      this.users.set(message.author.id, message.author);
-      this.emit("messageUpdate" /* MessageUpdate */, message);
+      this.#observeMessage(message);
+      const messages = this.channels.cachedMessages(message.channelId);
+      const previous = messages?.cache.peek(message.id);
+      if (previous)
+        messages.cache.set(message.id, message);
+      this.emit("messageUpdate" /* MessageUpdate */, message, previous);
+    });
+    this.#gateway.on("MESSAGE_DELETE", (data) => {
+      const payload = data;
+      const messages = this.channels.cachedMessages(payload.channel_id);
+      const removed = messages?.cache.peek(payload.id);
+      messages?.delete(payload.id);
+      this.emit("messageDelete" /* MessageDelete */, payload, removed);
+    });
+    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => {
+      const payload = data;
+      const messages = this.channels.cachedMessages(payload.channel_id);
+      const removed = [];
+      if (messages)
+        for (const id of payload.ids) {
+          const message = messages.cache.peek(id);
+          if (message)
+            removed.push(message);
+          messages.delete(id);
+        }
+      this.emit("messageDeleteBulk" /* MessageDeleteBulk */, payload, removed);
     });
-    this.#gateway.on("MESSAGE_DELETE", (data) => this.emit("messageDelete" /* MessageDelete */, data));
-    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => this.emit("messageDeleteBulk" /* MessageDeleteBulk */, data));
     this.#gateway.on("MESSAGE_REACTION_ADD", (data) => this.emit("messageReactionAdd" /* MessageReactionAdd */, data));
     this.#gateway.on("MESSAGE_REACTION_REMOVE", (data) => this.emit("messageReactionRemove" /* MessageReactionRemove */, data));
     this.#gateway.on("MESSAGE_REACTION_REMOVE_ALL", (data) => this.emit("messageReactionRemoveAll" /* MessageReactionRemoveAll */, data));
@@ -5354,20 +6277,27 @@ class Client extends EventEmitter2 {
         return;
       }
       const wasCached = this.guilds.has(payload.id);
-      const guild = new Guild(payload);
-      this.guilds.set(guild.id, guild);
+      this.guilds.patch(payload);
+      for (const role of payload.roles ?? [])
+        this.#upsertRole(payload.id, role);
+      if (this.#cache.emojis) {
+        const emojis = this.guilds.emojis(payload.id);
+        for (const emoji of payload.emojis ?? [])
+          emojis.upsert(emoji);
+      }
       for (const member of payload.members ?? [])
-        this.users.set(member.user.id, new User(member.user));
+        this.#upsertMember(payload.id, member);
+      for (const state of payload.voice_states ?? [])
+        this.#storeVoiceState(payload.id, state);
       for (const channelData of [
         ...payload.channels ?? [],
         ...payload.threads ?? []
       ])
-        this.channels.set(channelData.id, createChannel(channelData, this.#resourceContext));
+        this.channels.upsert({ ...channelData, guild_id: payload.id });
       this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
     });
     this.#gateway.on("GUILD_UPDATE", (data) => {
-      const guild = new Guild(data);
-      this.guilds.update(guild);
+      this.guilds.patch(data);
       this.emit("guildUpdate" /* GuildUpdate */, data);
     });
     this.#gateway.on("GUILD_DELETE", (data) => {
@@ -5377,45 +6307,158 @@ class Client extends EventEmitter2 {
         return;
       }
       this.guilds.delete(payload.id);
+      this.channels.deleteGuildChannels(payload.id);
       this.emit("guildDelete" /* GuildDelete */, payload);
     });
     this.#gateway.on("GUILD_MEMBER_ADD", (data) => {
       const member = data;
-      this.users.set(member.user.id, new User(member.user));
+      this.#upsertMember(member.guild_id, member);
       this.emit("guildMemberAdd" /* GuildMemberAdd */, member);
     });
     this.#gateway.on("GUILD_MEMBER_UPDATE", (data) => {
       const member = data;
-      this.users.set(member.user.id, new User(member.user));
+      this.#upsertMember(member.guild_id, member);
       this.emit("guildMemberUpdate" /* GuildMemberUpdate */, member);
     });
-    this.#gateway.on("GUILD_MEMBER_REMOVE", (data) => this.emit("guildMemberRemove" /* GuildMemberRemove */, data));
-    this.#gateway.on("GUILD_MEMBERS_CHUNK", (data) => this.emit("guildMembersChunk" /* GuildMembersChunk */, data));
-    this.#gateway.on("GUILD_BAN_ADD", (data) => this.emit("guildBanAdd" /* GuildBanAdd */, data));
-    this.#gateway.on("GUILD_BAN_REMOVE", (data) => this.emit("guildBanRemove" /* GuildBanRemove */, data));
-    this.#gateway.on("GUILD_ROLE_CREATE", (data) => this.emit("guildRoleCreate" /* GuildRoleCreate */, data));
-    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => this.emit("guildRoleUpdate" /* GuildRoleUpdate */, data));
-    this.#gateway.on("GUILD_ROLE_DELETE", (data) => this.emit("guildRoleDelete" /* GuildRoleDelete */, data));
-    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => this.emit("guildEmojisUpdate" /* GuildEmojisUpdate */, data));
-    this.#gateway.on("GUILD_STICKERS_UPDATE", (data) => this.emit("guildStickersUpdate" /* GuildStickersUpdate */, data));
+    this.#gateway.on("GUILD_MEMBER_REMOVE", (data) => {
+      const member = data;
+      this.guilds.members(member.guild_id).delete(member.user.id);
+      this.emit("guildMemberRemove" /* GuildMemberRemove */, member);
+    });
+    this.#gateway.on("GUILD_MEMBERS_CHUNK", (data) => {
+      const chunk = data;
+      for (const member of chunk.members)
+        this.#upsertMember(chunk.guild_id, member);
+      this.emit("guildMembersChunk" /* GuildMembersChunk */, chunk);
+    });
+    this.#gateway.on("GUILD_BAN_ADD", (data) => {
+      const ban = data;
+      const bans = this.guilds.bans(ban.guild_id);
+      bans.set(ban.user.id, {
+        reason: bans.get(ban.user.id)?.reason ?? null,
+        user: ban.user
+      });
+      this.guilds.members(ban.guild_id).delete(ban.user.id);
+      this.emit("guildBanAdd" /* GuildBanAdd */, ban);
+    });
+    this.#gateway.on("GUILD_BAN_REMOVE", (data) => {
+      const ban = data;
+      this.guilds.bans(ban.guild_id).delete(ban.user.id);
+      this.emit("guildBanRemove" /* GuildBanRemove */, ban);
+    });
+    this.#gateway.on("GUILD_ROLE_CREATE", (data) => {
+      const event = data;
+      this.#upsertRole(event.guild_id, event.role);
+      this.emit("guildRoleCreate" /* GuildRoleCreate */, event);
+    });
+    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => {
+      const event = data;
+      this.#upsertRole(event.guild_id, event.role);
+      this.emit("guildRoleUpdate" /* GuildRoleUpdate */, event);
+    });
+    this.#gateway.on("GUILD_ROLE_DELETE", (data) => {
+      const event = data;
+      this.guilds.roles(event.guild_id).delete(event.role_id);
+      this.emit("guildRoleDelete" /* GuildRoleDelete */, event);
+    });
+    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => {
+      const event = data;
+      if (this.#cache.emojis) {
+        const emojis = this.guilds.emojis(event.guild_id);
+        const current = new Set(event.emojis.map((emoji) => emoji.id));
+        for (const id of [...emojis.cache.keys()])
+          if (!current.has(id))
+            emojis.delete(id);
+        for (const emoji of event.emojis)
+          emojis.upsert(emoji);
+      }
+      this.emit("guildEmojisUpdate" /* GuildEmojisUpdate */, event);
+    });
+    this.#gateway.on("GUILD_STICKERS_UPDATE", (data) => {
+      const event = data;
+      this.guilds.stickers(event.guild_id).sync(event.stickers);
+      this.emit("guildStickersUpdate" /* GuildStickersUpdate */, event);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_CREATE", (data) => {
+      const sound = data;
+      if (sound.guild_id)
+        this.guilds.soundboard(sound.guild_id).set(sound.sound_id, sound);
+      this.emit("soundboardSoundCreate" /* SoundboardSoundCreate */, sound);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_UPDATE", (data) => {
+      const sound = data;
+      if (sound.guild_id)
+        this.guilds.soundboard(sound.guild_id).set(sound.sound_id, sound);
+      this.emit("soundboardSoundUpdate" /* SoundboardSoundUpdate */, sound);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_DELETE", (data) => {
+      const event = data;
+      this.guilds.soundboard(event.guild_id).delete(event.sound_id);
+      this.emit("soundboardSoundDelete" /* SoundboardSoundDelete */, event);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUNDS_UPDATE", (data) => {
+      const event = data;
+      const sounds = this.guilds.soundboard(event.guild_id);
+      sounds.clear();
+      for (const sound of event.soundboard_sounds)
+        sounds.set(sound.sound_id, sound);
+      this.emit("soundboardSoundsUpdate" /* SoundboardSoundsUpdate */, event);
+    });
+    this.#gateway.on("ENTITLEMENT_CREATE", (data) => {
+      const entitlement = data;
+      this.monetization?.set(entitlement.id, entitlement);
+      this.emit("entitlementCreate" /* EntitlementCreate */, entitlement);
+    });
+    this.#gateway.on("ENTITLEMENT_UPDATE", (data) => {
+      const entitlement = data;
+      this.monetization?.set(entitlement.id, entitlement);
+      this.emit("entitlementUpdate" /* EntitlementUpdate */, entitlement);
+    });
+    this.#gateway.on("ENTITLEMENT_DELETE", (data) => {
+      const entitlement = data;
+      this.monetization?.delete(entitlement.id);
+      this.emit("entitlementDelete" /* EntitlementDelete */, entitlement);
+    });
     this.#gateway.on("GUILD_INTEGRATIONS_UPDATE", (data) => this.emit("guildIntegrationsUpdate" /* GuildIntegrationsUpdate */, data));
-    this.#gateway.on("GUILD_SCHEDULED_EVENT_CREATE", (data) => this.emit("guildScheduledEventCreate" /* GuildScheduledEventCreate */, data));
-    this.#gateway.on("GUILD_SCHEDULED_EVENT_UPDATE", (data) => this.emit("guildScheduledEventUpdate" /* GuildScheduledEventUpdate */, data));
-    this.#gateway.on("GUILD_SCHEDULED_EVENT_DELETE", (data) => this.emit("guildScheduledEventDelete" /* GuildScheduledEventDelete */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_CREATE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).set(event.id, event);
+      this.emit("guildScheduledEventCreate" /* GuildScheduledEventCreate */, event);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_UPDATE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).set(event.id, event);
+      this.emit("guildScheduledEventUpdate" /* GuildScheduledEventUpdate */, event);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_DELETE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).delete(event.id);
+      this.emit("guildScheduledEventDelete" /* GuildScheduledEventDelete */, event);
+    });
     this.#gateway.on("GUILD_SCHEDULED_EVENT_USER_ADD", (data) => this.emit("guildScheduledEventUserAdd" /* GuildScheduledEventUserAdd */, data));
     this.#gateway.on("GUILD_SCHEDULED_EVENT_USER_REMOVE", (data) => this.emit("guildScheduledEventUserRemove" /* GuildScheduledEventUserRemove */, data));
-    this.#gateway.on("AUTO_MODERATION_RULE_CREATE", (data) => this.emit("autoModerationRuleCreate" /* AutoModerationRuleCreate */, data));
-    this.#gateway.on("AUTO_MODERATION_RULE_UPDATE", (data) => this.emit("autoModerationRuleUpdate" /* AutoModerationRuleUpdate */, data));
-    this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, data));
+    this.#gateway.on("AUTO_MODERATION_RULE_CREATE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).set(rule.id, rule);
+      this.emit("autoModerationRuleCreate" /* AutoModerationRuleCreate */, rule);
+    });
+    this.#gateway.on("AUTO_MODERATION_RULE_UPDATE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).set(rule.id, rule);
+      this.emit("autoModerationRuleUpdate" /* AutoModerationRuleUpdate */, rule);
+    });
+    this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).delete(rule.id);
+      this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, rule);
+    });
     this.#gateway.on("AUTO_MODERATION_ACTION_EXECUTION", (data) => this.emit("autoModerationActionExecution" /* AutoModerationActionExecution */, data));
     this.#gateway.on("CHANNEL_CREATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("channelCreate" /* ChannelCreate */, channel);
     });
     this.#gateway.on("CHANNEL_UPDATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("channelUpdate" /* ChannelUpdate */, channel);
     });
     this.#gateway.on("CHANNEL_DELETE", (data) => {
@@ -5425,13 +6468,11 @@ class Client extends EventEmitter2 {
     });
     this.#gateway.on("CHANNEL_PINS_UPDATE", (data) => this.emit("channelPinsUpdate" /* ChannelPinsUpdate */, data));
     this.#gateway.on("THREAD_CREATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("threadCreate" /* ThreadCreate */, channel);
     });
     this.#gateway.on("THREAD_UPDATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("threadUpdate" /* ThreadUpdate */, channel);
     });
     this.#gateway.on("THREAD_DELETE", (data) => {
@@ -5439,16 +6480,48 @@ class Client extends EventEmitter2 {
       this.channels.delete(payload.id);
       this.emit("threadDelete" /* ThreadDelete */, payload);
     });
-    this.#gateway.on("THREAD_LIST_SYNC", (data) => this.emit("threadListSync" /* ThreadListSync */, data));
+    this.#gateway.on("THREAD_LIST_SYNC", (data) => {
+      const sync = data;
+      for (const thread of sync.threads)
+        this.channels.upsert({ ...thread, guild_id: sync.guild_id });
+      this.emit("threadListSync" /* ThreadListSync */, sync);
+    });
     this.#gateway.on("THREAD_MEMBERS_UPDATE", (data) => this.emit("threadMembersUpdate" /* ThreadMembersUpdate */, data));
     this.#gateway.on("THREAD_MEMBER_UPDATE", (data) => this.emit("threadMemberUpdate" /* ThreadMemberUpdate */, data));
-    this.#gateway.on("STAGE_INSTANCE_CREATE", (data) => this.emit("stageInstanceCreate" /* StageInstanceCreate */, data));
-    this.#gateway.on("STAGE_INSTANCE_UPDATE", (data) => this.emit("stageInstanceUpdate" /* StageInstanceUpdate */, data));
-    this.#gateway.on("STAGE_INSTANCE_DELETE", (data) => this.emit("stageInstanceDelete" /* StageInstanceDelete */, data));
-    this.#gateway.on("INVITE_CREATE", (data) => this.emit("inviteCreate" /* InviteCreate */, data));
-    this.#gateway.on("INVITE_DELETE", (data) => this.emit("inviteDelete" /* InviteDelete */, data));
+    this.#gateway.on("STAGE_INSTANCE_CREATE", (data) => {
+      const stage = data;
+      this.stageInstances.set(stage.channel_id, stage);
+      this.emit("stageInstanceCreate" /* StageInstanceCreate */, stage);
+    });
+    this.#gateway.on("STAGE_INSTANCE_UPDATE", (data) => {
+      const stage = data;
+      this.stageInstances.set(stage.channel_id, stage);
+      this.emit("stageInstanceUpdate" /* StageInstanceUpdate */, stage);
+    });
+    this.#gateway.on("STAGE_INSTANCE_DELETE", (data) => {
+      const stage = data;
+      this.stageInstances.delete(stage.channel_id);
+      this.emit("stageInstanceDelete" /* StageInstanceDelete */, stage);
+    });
+    this.#gateway.on("INVITE_CREATE", (data) => {
+      const invite = data;
+      if (invite.guild_id)
+        this.guilds.invites(invite.guild_id).set(invite.code, invite);
+      this.emit("inviteCreate" /* InviteCreate */, invite);
+    });
+    this.#gateway.on("INVITE_DELETE", (data) => {
+      const invite = data;
+      if (invite.guild_id)
+        this.guilds.invites(invite.guild_id).delete(invite.code);
+      this.emit("inviteDelete" /* InviteDelete */, invite);
+    });
     this.#gateway.on("WEBHOOKS_UPDATE", (data) => this.emit("webhooksUpdate" /* WebhooksUpdate */, data));
-    this.#gateway.on("VOICE_STATE_UPDATE", (data) => this.emit("voiceStateUpdate" /* VoiceStateUpdate */, data));
+    this.#gateway.on("VOICE_STATE_UPDATE", (data) => {
+      const state = data;
+      if (state.guild_id)
+        this.#storeVoiceState(state.guild_id, state);
+      this.emit("voiceStateUpdate" /* VoiceStateUpdate */, state);
+    });
     this.#gateway.on("VOICE_SERVER_UPDATE", (data) => this.emit("voiceServerUpdate" /* VoiceServerUpdate */, data));
     this.#gateway.on("PRESENCE_UPDATE", (data) => this.emit("presenceUpdate" /* PresenceUpdate */, data));
     this.#gateway.on("TYPING_START", (data) => this.emit("typingStart" /* TypingStart */, data));
@@ -5456,6 +6529,80 @@ class Client extends EventEmitter2 {
     this.#gateway.on("RAW", (data) => this.emit("raw" /* Raw */, data));
     this.#gateway.on("error", (error) => this.emit("error" /* Error */, error));
   }
+  #observeMessage(message) {
+    if (!this.channels.has(message.channelId))
+      this.channels.set(message.channelId, message.channel);
+    if (this.#cache.users)
+      this.#merge(this.users, message.author.id, message.author);
+  }
+  #upsertMember(guildId, data) {
+    const member = new GuildMember({ ...data, guild_id: guildId });
+    if (this.#cache.users)
+      this.#merge(this.users, member.user.id, member.user);
+    if (!this.#cache.members)
+      return member;
+    return this.#merge(this.guilds.members(guildId), member.user.id, member);
+  }
+  #storeVoiceState(guildId, state) {
+    const states = this.guilds.voiceStates(guildId);
+    if (state.channel_id)
+      states.set(state.user_id, state);
+    else
+      states.delete(state.user_id);
+  }
+  #upsertRole(guildId, data) {
+    if (!this.#cache.roles)
+      return new Role(data);
+    return this.#merge(this.guilds.roles(guildId), data.id, new Role(data));
+  }
+  #merge(manager, id, next) {
+    const existing = manager.get(id);
+    if (!existing) {
+      manager.set(id, next);
+      return next;
+    }
+    for (const [key, value] of Object.entries(next))
+      if (value !== undefined)
+        existing[key] = value;
+    return existing;
+  }
+  createCollector(event, options = {}) {
+    const collector = new Collector(options);
+    let order = 0;
+    const listener = (...args) => {
+      const item = args[0];
+      const id = item?.id;
+      const key = options.key?.(item) ?? (typeof id === "string" ? id : String(order++));
+      collector.handle(key, item).catch((error) => this.emit("error" /* Error */, error instanceof Error ? error : new Error(String(error))));
+    };
+    this.on(event, listener);
+    collector.onDispose(() => this.off(event, listener));
+    return collector;
+  }
+  permissionsFor(memberId, guildOrChannelId) {
+    let channel = this.channels.get(guildOrChannelId);
+    if (channel?.isThread()) {
+      channel = channel.parentId ? this.channels.get(channel.parentId) : undefined;
+      if (!channel)
+        return null;
+    }
+    const guildId = channel?.guildId ?? guildOrChannelId;
+    const guild = this.guilds.get(guildId);
+    const member = this.guilds.members(guildId).get(memberId);
+    if (!guild || !member)
+      return null;
+    return computePermissions({
+      guildId,
+      ownerId: guild.ownerId,
+      memberId,
+      memberRoleIds: member.roleIds,
+      roles: this.guilds.roles(guildId).values(),
+      overwrites: channel?.permissionOverwrites
+    });
+  }
+  fetchDefaultSoundboardSounds() {
+    return this.rest.get(Routes.soundboardDefaultSounds());
+  }
   async login(token) {
     if (this.state === "destroyed")
       throw new Error("Cannot login a destroyed client.");
@@ -5492,6 +6639,14 @@ class Client extends EventEmitter2 {
       return Promise.reject(new Error("Client is unauthenticated."));
     return this.rest.post(`/webhooks/${this.user.id}/${token}`, data);
   }
+  interactionWebhookMessage(method, applicationId, token, messageId, data) {
+    const path = messageId === "@original" ? Routes.interactionOriginalResponse(applicationId, token) : Routes.webhookMessage(applicationId, token, messageId);
+    if (method === "GET")
+      return this.rest.get(path);
+    if (method === "PATCH")
+      return this.rest.patch(path, data);
+    return this.rest.delete(path);
+  }
   fetchWebhook(id, token) {
     return this.rest.get(token ? `/webhooks/${id}/${token}` : `/webhooks/${id}`);
   }
@@ -5647,6 +6802,21 @@ class HandlerRegistry {
     return this.dispatch(event, ...args);
   }
 }
+// packages/sharding/package.json
+var package_default2 = {
+  name: "@lunibee/sharding",
+  version: "0.2.0",
+  type: "module",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
+  exports: {
+    ".": "./src/index.ts"
+  },
+  dependencies: {
+    "@lunibee/ws": "workspace:*"
+  }
+};
+
 // packages/sharding/src/bus.ts
 var REPLY_TYPE = "__lunibee:reply";
 
@@ -5824,7 +6994,7 @@ class ClusterManager {
     const response = await fetch("https://discord.com/api/v10/gateway/bot", {
       headers: {
         Authorization: `Bot ${this.#options.token}`,
-        "User-Agent": "Lunibee/0.1.0"
+        "User-Agent": `Lunibee/${package_default2.version}`
       }
     });
     if (!response.ok) {
@@ -5975,6 +7145,34 @@ class ClusterManager {
 
 // packages/sharding/src/index.ts
 var sleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function needsConnection(gateway) {
+  return gateway.state === "CONNECT" /* Connect */ || gateway.state === "RECONNECT" /* Reconnect */ || gateway.state === "CLOSED" /* Closed */;
+}
+var HANDSHAKE_SENT = new Set([
+  "IDENTIFY" /* Identify */,
+  "RESUME" /* Resume */,
+  "READY" /* Ready */,
+  "DISPATCH" /* Dispatch */,
+  "HEARTBEAT" /* Heartbeat */,
+  "CLOSED" /* Closed */
+]);
+function handshakeSent(gateway, timeout) {
+  if (HANDSHAKE_SENT.has(gateway.state))
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      gateway.off("stateChange", onState);
+      resolve();
+    };
+    const onState = (change) => {
+      if (HANDSHAKE_SENT.has(change.next))
+        done();
+    };
+    const timer = setTimeout(done, timeout);
+    gateway.on("stateChange", onState);
+  });
+}
 
 class ShardManager {
   static IDENTIFY_INTERVAL = 5000;
@@ -5987,6 +7185,7 @@ class ShardManager {
   #destroyed = false;
   #auto;
   #autoScaleTimer;
+  #gatewayInfo;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
@@ -5999,6 +7198,10 @@ class ShardManager {
       throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
     if (options.spawnDelay !== undefined && (!Number.isFinite(options.spawnDelay) || options.spawnDelay < 0))
       throw new RangeError("spawnDelay must be a non-negative finite number of milliseconds.");
+    if (options.maxConcurrency !== undefined && (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency < 1))
+      throw new RangeError("maxConcurrency must be a positive integer.");
+    if (options.handshakeTimeout !== undefined && (!Number.isFinite(options.handshakeTimeout) || options.handshakeTimeout < 0))
+      throw new RangeError("handshakeTimeout must be a non-negative number of milliseconds.");
     this.#auto = options.shardCount === "auto";
     this.#options = {
       spawnDelay: ShardManager.IDENTIFY_INTERVAL,
@@ -6008,10 +7211,13 @@ class ShardManager {
       this.#initialize(count);
   }
   async fetchRecommendedShardCount() {
+    return (await this.fetchGatewayInfo()).shards;
+  }
+  async fetchGatewayInfo() {
     const response = await fetch("https://discord.com/api/v10/gateway/bot", {
       headers: {
         Authorization: `Bot ${this.#options.token}`,
-        "User-Agent": "Lunibee/0.1.0"
+        "User-Agent": `Lunibee/${package_default2.version}`
       }
     });
     if (!response.ok)
@@ -6019,7 +7225,17 @@ class ShardManager {
     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;
+    const limit = data.session_start_limit;
+    const info = { shards: data.shards };
+    if (limit && typeof limit.total === "number" && typeof limit.remaining === "number" && typeof limit.reset_after === "number" && typeof limit.max_concurrency === "number")
+      info.sessionStartLimit = {
+        total: limit.total,
+        remaining: limit.remaining,
+        resetAfter: limit.reset_after,
+        maxConcurrency: Math.max(1, limit.max_concurrency)
+      };
+    this.#gatewayInfo = info;
+    return info;
   }
   async connect() {
     if (this.#autoScaleTimer) {
@@ -6027,17 +7243,25 @@ class ShardManager {
       this.#autoScaleTimer = undefined;
     }
     await this.#ensureInitialized();
-    for (const [id, shard] of this.shards) {
-      try {
-        await shard.connect();
-      } catch (error) {
+    const limit = this.#gatewayInfo?.sessionStartLimit;
+    const ids = [...this.shards].filter(([, gateway]) => needsConnection(gateway)).map(([id]) => id);
+    if (limit && limit.remaining < ids.length)
+      throw new Error(`Session start limit exhausted: ${limit.remaining} of ${limit.total} IDENTIFYs left for ${ids.length} shards; resets in ${Math.ceil(limit.resetAfter / 1000)}s.`);
+    const concurrency = Math.min(this.#options.maxConcurrency ?? limit?.maxConcurrency ?? 1, limit?.maxConcurrency ?? Infinity);
+    for (let start = 0;start < ids.length; start += concurrency) {
+      const round = ids.slice(start, start + concurrency);
+      const results = await Promise.allSettled(round.map((id) => this.shards.get(id).connect()));
+      const failed = results.findIndex((result) => result.status === "rejected");
+      if (failed !== -1) {
         this.destroy();
-        throw new Error(`Failed to connect shard ${id}.`, {
-          cause: error
+        throw new Error(`Failed to connect shard ${round[failed]}.`, {
+          cause: results[failed].reason
         });
       }
-      if (id + 1 < this.shardCount && this.#options.spawnDelay && this.#options.spawnDelay > 0)
+      if (start + concurrency < ids.length && this.#options.spawnDelay && this.#options.spawnDelay > 0) {
+        await Promise.all(round.map((id) => handshakeSent(this.shards.get(id), this.#options.handshakeTimeout ?? 15000)));
         await sleep3(this.#options.spawnDelay);
+      }
     }
     if (this.#options.autoScaleInterval && !this.#autoScaleTimer) {
       this.#autoScaleTimer = setInterval(() => {
@@ -6080,6 +7304,13 @@ class ShardManager {
   get(id) {
     return this.shards.get(id);
   }
+  health() {
+    return [...this.shards].map(([id, gateway]) => ({
+      id,
+      state: gateway.state,
+      ping: gateway.ping
+    }));
+  }
   values() {
     return [...this.shards].map(([id, gateway]) => ({ id, gateway }));
   }
@@ -6203,12 +7434,14 @@ class VoiceConnection {
     if (this.state === "destroyed" /* Destroyed */)
       return;
     this.#closeTransports();
+    this.receiver.close();
     this.#transition("disconnected" /* Disconnected */);
   }
   destroy() {
     if (this.state === "destroyed" /* Destroyed */)
       return;
     this.#closeTransports();
+    this.receiver.close();
     this.channelId = undefined;
     this.#transition("destroyed" /* Destroyed */);
     this.#listeners.clear();
@@ -6416,6 +7649,8 @@ class VoiceReceiver {
     this.#ssrcMap.set(ssrc, userId);
   }
   subscribe(userId) {
+    if (this.connection.state === "destroyed" /* Destroyed */)
+      throw new VoiceError("Voice connection has been destroyed.");
     let controllerRef;
     const stream = new ReadableStream({
       start: (controller) => {
@@ -6436,6 +7671,16 @@ class VoiceReceiver {
     });
     return new AudioStream(stream, { title: `User ${userId} Audio` });
   }
+  close() {
+    for (const controllers of this.#streams.values())
+      for (const controller of controllers) {
+        try {
+          controller.close();
+        } catch {}
+      }
+    this.#streams.clear();
+    this.#ssrcMap.clear();
+  }
   onPacket(packet) {
     if (packet.length < 12)
       return;
@@ -6663,10 +7908,13 @@ class ActionRowBuilder {
     return this;
   }
   toJSON() {
-    return {
-      type: ComponentType.ActionRow,
-      components: this.#components.map((component) => component.toJSON())
-    };
+    const components = this.#components.map((component) => component.toJSON());
+    if (components.length === 0)
+      throw new RangeError("An action row needs at least one component.");
+    const types = components.map((component) => component.type);
+    if (types.some((type) => type !== ComponentType.Button) && components.length > 1)
+      throw new RangeError("A select menu or text input must be alone in its action row.");
+    return { type: ComponentType.ActionRow, components };
   }
 }
 
@@ -6721,6 +7969,12 @@ class StringSelectBuilder {
     return this;
   }
   toJSON() {
+    assertSelect(this.#data);
+    const count = this.#data.options?.length ?? 0;
+    if (count === 0)
+      throw new RangeError("A string select needs at least one option.");
+    if ((this.#data.max_values ?? 1) > count)
+      throw new RangeError("max_values cannot exceed the number of options.");
     return structuredClone(this.#data);
   }
 }
@@ -6731,9 +7985,20 @@ class ButtonBuilder {
     style: ButtonStyle.Secondary
   };
   setStyle(style) {
-    this.#data.style = style;
-    if (style === ButtonStyle.Link)
-      delete this.#data.custom_id;
+    const data = this.#data;
+    data.style = style;
+    if (style === ButtonStyle.Link) {
+      delete data.custom_id;
+      delete data.sku_id;
+    } else if (style === ButtonStyle.Premium) {
+      delete data.custom_id;
+      delete data.url;
+      delete data.label;
+      delete data.emoji;
+    } else {
+      delete data.url;
+      delete data.sku_id;
+    }
     return this;
   }
   setCustomId(value) {
@@ -6758,11 +8023,16 @@ class ButtonBuilder {
         cause: error
       });
     }
-    this.#data.style = ButtonStyle.Link;
-    delete this.#data.custom_id;
+    this.setStyle(ButtonStyle.Link);
     this.#data.url = url.toString();
     return this;
   }
+  setSKUId(skuId) {
+    validateText(skuId, 20, "Button SKU ID");
+    this.setStyle(ButtonStyle.Premium);
+    this.#data.sku_id = skuId;
+    return this;
+  }
   setEmoji(emoji) {
     this.#data.emoji = typeof emoji === "string" ? { name: emoji } : { ...emoji };
     return this;
@@ -6772,7 +8042,26 @@ class ButtonBuilder {
     return this;
   }
   toJSON() {
-    return structuredClone(this.#data);
+    const data = this.#data;
+    if (data.style === ButtonStyle.Link) {
+      if (!data.url)
+        throw new TypeError("Link buttons require a URL.");
+      if (data.custom_id || data.sku_id)
+        throw new TypeError("Link buttons cannot have a custom ID or SKU ID.");
+    } else if (data.style === ButtonStyle.Premium) {
+      if (!data.sku_id)
+        throw new TypeError("Premium buttons require a SKU ID.");
+      if (data.custom_id || data.url || data.label || data.emoji)
+        throw new TypeError("Premium buttons cannot have a custom ID, URL, label or emoji.");
+    } else {
+      if (!data.custom_id)
+        throw new TypeError("Non-link buttons require a custom ID.");
+      if (data.url || data.sku_id)
+        throw new TypeError("Only link buttons have a URL and only premium buttons have a SKU ID.");
+    }
+    if (data.style !== ButtonStyle.Premium && !data.label && !data.emoji)
+      throw new TypeError("Buttons require a label or an emoji.");
+    return structuredClone(data);
   }
 }
 
@@ -6816,6 +8105,7 @@ class EntitySelectBuilder {
     return this;
   }
   toJSON() {
+    assertSelect(this.#data);
     return structuredClone(this.#data);
   }
 }
@@ -6843,6 +8133,10 @@ class ModalBuilder {
     return this;
   }
   toJSON() {
+    if (!this.#custom_id || !this.#title)
+      throw new TypeError("Modals require a custom ID and a title.");
+    if (this.#components.length === 0)
+      throw new RangeError("Modals require at least one component.");
     return {
       type: 9,
       ...this.#custom_id ? { custom_id: this.#custom_id } : {},
@@ -6896,7 +8190,12 @@ class TextInputBuilder {
     return this;
   }
   toJSON() {
-    return structuredClone(this.#data);
+    const data = this.#data;
+    if (!data.custom_id)
+      throw new TypeError("Text inputs require a custom ID.");
+    if (data.min_length !== undefined && data.max_length !== undefined && data.min_length > data.max_length)
+      throw new RangeError("min_length cannot exceed max_length.");
+    return structuredClone(data);
   }
 }
 
@@ -7123,6 +8422,12 @@ class ChannelSelectMenuBuilder extends EntitySelectBuilder {
     super(ComponentType.ChannelSelect);
   }
 }
+function assertSelect(data) {
+  if (!data.custom_id)
+    throw new TypeError("Select menus require a custom ID.");
+  if ((data.min_values ?? 1) > (data.max_values ?? 1))
+    throw new RangeError("min_values cannot exceed max_values.");
+}
 // packages/builders/src/commands.ts
 var ApplicationCommandOptionType2 = {
   Subcommand: 1,
@@ -7637,6 +8942,8 @@ export {
   GuildMemberManager,
   GuildOnboarding,
   GuildScheduledEventManager,
+  GuildSoundboardManager,
+  GuildStickerManager,
   GuildWelcomeScreen,
   HandlerRegistry,
   HttpTransport,
@@ -7662,6 +8969,7 @@ export {
   MessageManager,
   ModalBuilder,
   ModalSubmitInteraction,
+  MonetizationManager,
   NewsChannel,
   NumberOptionBuilder,
   OnboardingPrompt,
@@ -7739,6 +9047,7 @@ export {
   classifyFrame,
   classifyPayload,
   codeBlock,
+  computePermissions,
   createAudioPlayer,
   createAudioResource,
   createChannel,
@@ -7762,6 +9071,7 @@ export {
   normalizeRoutePath,
   orderedList,
   randomInt,
+  redactPath,
   resolveGatewayIntents,
   resumePayload,
   roleMention,
@@ -7776,4 +9086,4 @@ export {
   userMention
 };
 
-//# debugId=58F0E8EFC21C568E64756E2164756E21
+//# debugId=726AE42ABABEBEA864756E2164756E21