lunibee 0.1.8 → 0.2.1

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++) {
@@ -383,6 +396,11 @@ class PermissionSet {
   toArray() {
     return Object.keys(Permission).filter((permission) => this.has(permission));
   }
+  static #renamed = {
+    ManageEmojisAndStickers: "ManageGuildExpressions",
+    ManageEmojis: "ManageGuildExpressions",
+    UseSlashCommands: "UseApplicationCommands"
+  };
   #resolve(permission) {
     if (typeof permission === "bigint")
       return permission;
@@ -397,6 +415,9 @@ class PermissionSet {
       return bit;
     }
     if (typeof permission === "string") {
+      const renamed = PermissionSet.#renamed[permission];
+      if (renamed)
+        return this.#resolve(renamed);
       if (permission in Permission)
         return Permission[permission];
       if (permission in Permissions)
@@ -419,6 +440,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 +505,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 +554,9 @@ class Collector extends EventEmitter {
   endReason;
   totalProcessed = 0;
   #timeoutTimer;
+  #idleTimer;
+  #onAbort = () => this.stop("abort");
+  #cleanup = [];
   constructor(options = {}) {
     super();
     this.options = options;
@@ -505,6 +565,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 +603,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 +622,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 +984,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 +1542,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 +1611,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 +1635,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.8",
+  version: "0.2.1",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -1203,7 +1695,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 +1727,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 +2073,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 +2403,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 +2503,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 +2582,7 @@ class Channel extends BaseStructure {
   nsfw;
   rateLimitPerUser;
   position;
+  permissionOverwrites;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -2058,6 +2596,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) {
@@ -2081,6 +2620,11 @@ class Channel extends BaseStructure {
   editTopic(topic) {
     return this.edit({ topic });
   }
+  editPermissionOverwrite(targetId, changes, options) {
+    if (!this.#context?.editPermissionOverwrite)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.editPermissionOverwrite(this.id, targetId, changes, options);
+  }
   editParent(parentId) {
     return this.edit({ parent_id: parentId });
   }
@@ -2215,6 +2759,7 @@ class Guild extends BaseStructure {
     return this.name;
   }
 }
+
 // packages/structures/src/resources.ts
 function toDateOrNull(value) {
   if (!value)
@@ -2230,13 +2775,15 @@ class GuildMember {
   roleIds;
   pending;
   joinedAt;
-  permissions;
   avatarHash;
   premiumSince;
   timedOutUntil;
   flags;
-  constructor(data) {
+  #suppliedPermissions;
+  #context;
+  constructor(data, context) {
     this.user = new User(data.user);
+    this.#context = context;
     if (!/^\d{1,20}$/.test(data.guild_id))
       throw new TypeError("Member guild_id must be a valid snowflake.");
     this.guildId = data.guild_id;
@@ -2246,12 +2793,53 @@ class GuildMember {
     this.joinedAt = data.joined_at ? new Date(data.joined_at) : undefined;
     if (this.joinedAt?.toString() === "Invalid Date")
       throw new RangeError("Member joined_at must be a valid date.");
-    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
+    if (data.permissions !== undefined)
+      this.#suppliedPermissions = new PermissionsBitField(data.permissions);
     this.avatarHash = data.avatar ?? null;
     this.premiumSince = toDateOrNull(data.premium_since);
     this.timedOutUntil = toDateOrNull(data.communication_disabled_until);
     this.flags = data.flags ?? 0;
   }
+  get permissions() {
+    if (this.#suppliedPermissions)
+      return this.#suppliedPermissions;
+    return new PermissionsBitField(this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds) ?? 0n);
+  }
+  permissionsIn(channelId) {
+    const computed = this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds, channelId);
+    return computed ? new PermissionsBitField(computed) : null;
+  }
+  #action(name) {
+    const action = this.#context?.[name];
+    if (!action)
+      throw new Error("This member is not attached to a client.");
+    return action;
+  }
+  kick(reason) {
+    return this.#action("kickMember")(this.guildId, this.user.id, reason);
+  }
+  ban(options = {}) {
+    return this.#action("banMember")(this.guildId, this.user.id, options);
+  }
+  edit(options, reason) {
+    return this.#action("editMember")(this.guildId, this.user.id, options, reason);
+  }
+  timeout(milliseconds, reason) {
+    if (milliseconds !== null && !(milliseconds > 0))
+      throw new RangeError("Timeout length must be a positive number of milliseconds.");
+    return this.edit({
+      communication_disabled_until: milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString()
+    }, reason);
+  }
+  setNickname(nickname, reason) {
+    return this.edit({ nick: nickname }, reason);
+  }
+  addRole(roleId, reason) {
+    return this.#action("addMemberRole")(this.guildId, this.user.id, roleId, reason);
+  }
+  removeRole(roleId, reason) {
+    return this.#action("removeMemberRole")(this.guildId, this.user.id, roleId, reason);
+  }
   get displayName() {
     return this.nickname ?? this.user.displayName;
   }
@@ -2785,6 +3373,17 @@ class CommandOptions {
       throw new TypeError(`Resolved mentionable for option "${name}" is missing.`);
     return resolved;
   }
+  getMentionableType(name) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Mentionable)
+      return null;
+    const id = String(opt.value);
+    if (this.#resolved?.users?.[id])
+      return "user";
+    if (this.#resolved?.roles?.[id])
+      return "role";
+    return null;
+  }
   getAttachment(name, required = false) {
     const opt = this.#get(name);
     if (!opt || opt.type !== OptionType.Attachment) {
@@ -2810,6 +3409,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 +3434,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 +3455,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.");
@@ -2864,6 +3471,20 @@ class Interaction {
   isChatInputCommand() {
     return this.type === InteractionType.ApplicationCommand;
   }
+  awaitModalSubmit(options) {
+    const collect = this.#client.resourceContext?.collectInteractions;
+    if (!collect)
+      return Promise.reject(new Error("This interaction is not attached to a client."));
+    if (!(options.time > 0))
+      return Promise.reject(new RangeError("awaitModalSubmit needs a positive time."));
+    const userId = this.user?.id;
+    const collector = collect({
+      time: options.time,
+      max: 1,
+      filter: async (interaction) => interaction.isModalSubmit() && interaction.user?.id === userId && (options.customId === undefined || interaction.customId === options.customId) && (options.filter ? await options.filter(interaction) : true)
+    });
+    return collector.next();
+  }
   isMessageComponent() {
     return this.type === InteractionType.MessageComponent;
   }
@@ -2898,9 +3519,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
+    }, this.#client.resourceContext);
+  }
+  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 +3578,29 @@ 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;
+  async deferReply(options = false) {
+    const ephemeral = typeof options === "boolean" ? options : options.ephemeral === 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;
+    const data = "toJSON" in modal && typeof modal.toJSON === "function" ? modal.toJSON() : modal;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.Modal, data), "replied");
   }
 }
 
@@ -2964,6 +3621,9 @@ class ComponentInteraction extends Interaction {
   get customId() {
     return this.data?.data?.custom_id ?? "";
   }
+  get messageId() {
+    return this.data?.message?.id;
+  }
   get componentType() {
     return this.data?.data?.component_type ?? 0;
   }
@@ -2971,16 +3631,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 +3677,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) {
@@ -3221,6 +3874,7 @@ class AuditLog {
 }
 
 // packages/structures/src/index.ts
+var COMPONENT_COLLECTOR_DEFAULT_TIME = 15 * 60000;
 var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
 
 class Message extends BaseStructure {
@@ -3241,6 +3895,7 @@ class Message extends BaseStructure {
   reference;
   components;
   referencedMessage;
+  member;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -3263,6 +3918,11 @@ class Message extends BaseStructure {
     this.reference = data.message_reference;
     this.referencedMessage = data.referenced_message ? new Message(data.referenced_message, context) : data.referenced_message === null ? null : undefined;
     this.#context = context;
+    this.member = data.member && data.guild_id ? new GuildMember({
+      ...data.member,
+      user: data.member.user ?? data.author,
+      guild_id: data.guild_id
+    }, context) : null;
     this.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
   }
   get embedsSuppressed() {
@@ -3303,6 +3963,20 @@ class Message extends BaseStructure {
       throw new Error("This message is not attached to a client.");
     return this.#context.crosspostMessage(this.channelId, this.id);
   }
+  createComponentCollector(options = {}) {
+    const collect = this.#context?.collectInteractions;
+    if (!collect)
+      throw new Error("This message is not attached to a client.");
+    const { componentType, filter, ...rest } = options;
+    return collect({
+      ...rest,
+      time: rest.time ?? (rest.idle ? undefined : COMPONENT_COLLECTOR_DEFAULT_TIME),
+      filter: async (interaction) => interaction.isMessageComponent() && interaction.messageId === this.id && (componentType === undefined || interaction.componentType === componentType) && (filter ? await filter(interaction) : true)
+    });
+  }
+  awaitComponent(options = {}) {
+    return this.createComponentCollector({ ...options, max: 1 }).next();
+  }
   react(emoji) {
     if (!this.#context?.addReaction)
       throw new Error("This message is not attached to a client.");
@@ -3376,23 +4050,43 @@ class Message extends BaseStructure {
 }
 
 // packages/managers/src/message.ts
+function toRequest(options) {
+  const { files, ...body } = options;
+  if (!files?.length)
+    return body;
+  return {
+    body,
+    files: files.map((file) => ({
+      name: file.name,
+      data: typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data,
+      contentType: file.contentType
+    }))
+  };
+}
+
 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);
   }
   async send(options) {
-    const data = await this.#rest.post(Routes.channelMessages(this.#channelId), options);
+    const data = await this.#rest.post(Routes.channelMessages(this.#channelId), toRequest(options));
     return this.upsert(data);
   }
   async fetch(messageId) {
@@ -3403,13 +4097,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,17 +4158,58 @@ class UserManager extends ResourceManager {
     });
   }
 }
-// packages/managers/src/guild-resources.ts
-function withQuery(path, params) {
-  const query = new URLSearchParams;
-  for (const [key, value] of Object.entries(params))
+// 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)
-      query.set(key, String(value));
-  const suffix = query.toString();
+      params.set(key, String(value));
+  const suffix = params.toString();
   return suffix ? `${path}?${suffix}` : path;
 }
 
-class GuildBanManager extends Manager {
+class GuildStickerManager extends Manager {
   #rest;
   guildId;
   constructor(rest, guildId) {
@@ -3481,21 +4217,273 @@ class GuildBanManager extends Manager {
     this.#rest = rest;
     this.guildId = guildId;
   }
-  async fetch(userId) {
-    const ban = await this.#rest.get(Routes.guildBan(this.guildId, userId));
-    this.set(ban.user.id, ban);
-    return ban;
+  #store(sticker) {
+    this.set(sticker.id, sticker);
+    return sticker;
   }
-  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), {
-      limit,
-      before: options.before,
-      after: options.after
-    }));
-    for (const ban of bans)
-      this.set(ban.user.id, ban);
-    return bans;
+  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;
+  #context;
+  guildId;
+  constructor(guildId, rest, context = () => {
+    return;
+  }) {
+    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId }, context())), (member) => member.user.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+    this.#context = context;
+  }
+  async kick(userId, reason) {
+    await this.#rest.delete(Routes.guildMember(this.guildId, userId), {
+      reason
+    });
+    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, reason) {
+    const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), options, { reason });
+    const member = new GuildMember({ ...data, guild_id: this.guildId }, this.#context());
+    this.set(member.user.id, member);
+    return member;
+  }
+  async addRole(userId, roleId, reason) {
+    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId), undefined, { reason });
+  }
+  async removeRole(userId, roleId, reason) {
+    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId), { reason });
+  }
+  async timeout(userId, milliseconds, reason) {
+    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
+    return this.edit(userId, { communication_disabled_until: timeoutDate }, reason);
+  }
+}
+
+// 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 withQuery2(path, params) {
+  const query = new URLSearchParams;
+  for (const [key, value] of Object.entries(params))
+    if (value !== undefined)
+      query.set(key, String(value));
+  const suffix = query.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildBanManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  async fetch(userId) {
+    const ban = await this.#rest.get(Routes.guildBan(this.guildId, userId));
+    this.set(ban.user.id, ban);
+    return ban;
+  }
+  async fetchAll(options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
+    const bans = await this.#rest.get(withQuery2(Routes.guildBans(this.guildId), {
+      limit,
+      before: options.before,
+      after: options.after
+    }));
+    for (const ban of bans)
+      this.set(ban.user.id, ban);
+    return bans;
   }
   async create(userId, options = {}) {
     await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
@@ -3521,12 +4509,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 +4531,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,
@@ -3587,10 +4575,25 @@ class StageInstanceManager extends Manager {
 
 class PermissionOverwriteManager {
   #rest;
+  #current;
   channelId;
-  constructor(rest, channelId) {
+  constructor(rest, channelId, current = () => {
+    return;
+  }) {
     this.#rest = rest;
     this.channelId = channelId;
+    this.#current = current;
+  }
+  async update(overwriteId, changes, options = {}) {
+    const overwrites = this.#current() ?? (await this.#rest.get(Routes.channel(this.channelId))).permission_overwrites ?? [];
+    const existing = overwrites.find((entry) => entry.id === overwriteId);
+    const type = existing?.type ?? options.type;
+    if (type !== 0 && type !== 1)
+      throw new TypeError("A new permission overwrite needs a type: 0 for a role, 1 for a member.");
+    const touched = (changes.allow ?? 0n) | (changes.deny ?? 0n) | (changes.inherit ?? 0n);
+    const allow = BigInt(existing?.allow ?? 0) & ~touched | (changes.allow ?? 0n);
+    const deny = BigInt(existing?.deny ?? 0) & ~touched | (changes.deny ?? 0n);
+    await this.edit(overwriteId, { type, allow, deny }, options.reason);
   }
   async edit(overwriteId, options, reason) {
     await this.#rest.put(Routes.channelPermission(this.channelId, overwriteId), {
@@ -3605,7 +4608,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,6 +4617,24 @@ 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;
+  #context;
+  attachContext(context) {
+    this.#context = context;
+  }
+  #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;
@@ -3630,6 +4651,68 @@ class GuildManager extends ResourceManager {
       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, () => this.#context));
+    return manager;
+  }
+  roles(guildId) {
+    let manager = this.#roles.get(guildId);
+    if (!manager)
+      this.#roles.set(guildId, manager = new RoleManager(guildId, this.#rest));
+    return manager;
+  }
+  emojis(guildId) {
+    let manager = this.#emojis.get(guildId);
+    if (!manager)
+      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 +4748,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,160 +4756,81 @@ 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));
     return rules.map((r) => new AutoModerationRule(r));
   }
   async fetchAutoModerationRule(guildId, ruleId) {
-    const rule = await this.#rest.get(Routes.guildAutoModerationRule(guildId, ruleId));
-    return new AutoModerationRule(rule);
-  }
-  async createAutoModerationRule(guildId, options) {
-    const rule = await this.#rest.post(Routes.guildAutoModerationRules(guildId), options);
-    return new AutoModerationRule(rule);
-  }
-  async editAutoModerationRule(guildId, ruleId, options) {
-    const rule = await this.#rest.patch(Routes.guildAutoModerationRule(guildId, ruleId), options);
-    return new AutoModerationRule(rule);
-  }
-  async deleteAutoModerationRule(guildId, ruleId) {
-    await this.#rest.delete(Routes.guildAutoModerationRule(guildId, ruleId));
-  }
-}
-var AuditLogEvent = {
-  GuildUpdate: 1,
-  ChannelCreate: 10,
-  ChannelUpdate: 11,
-  ChannelDelete: 12,
-  ChannelOverwriteCreate: 13,
-  ChannelOverwriteUpdate: 14,
-  ChannelOverwriteDelete: 15,
-  MemberKick: 20,
-  MemberPrune: 21,
-  MemberBanAdd: 22,
-  MemberBanRemove: 23,
-  MemberUpdate: 24,
-  MemberRoleUpdate: 25,
-  MemberMove: 26,
-  MemberDisconnect: 27,
-  BotAdd: 28,
-  RoleCreate: 30,
-  RoleUpdate: 31,
-  RoleDelete: 32,
-  InviteCreate: 40,
-  InviteUpdate: 41,
-  InviteDelete: 42,
-  WebhookCreate: 50,
-  WebhookUpdate: 51,
-  WebhookDelete: 52,
-  EmojiCreate: 60,
-  EmojiUpdate: 61,
-  EmojiDelete: 62,
-  MessageDelete: 72,
-  MessageBulkDelete: 73,
-  MessagePin: 74,
-  MessageUnpin: 75,
-  IntegrationCreate: 80,
-  IntegrationUpdate: 81,
-  IntegrationDelete: 82,
-  StageInstanceCreate: 83,
-  StageInstanceUpdate: 84,
-  StageInstanceDelete: 85,
-  StickerCreate: 90,
-  StickerUpdate: 91,
-  StickerDelete: 92,
-  ScheduledEventCreate: 100,
-  ScheduledEventUpdate: 101,
-  ScheduledEventDelete: 102,
-  ThreadCreate: 110,
-  ThreadUpdate: 111,
-  ThreadDelete: 112,
-  AutoModerationRuleCreate: 140,
-  AutoModerationRuleUpdate: 141,
-  AutoModerationRuleDelete: 142,
-  AutoModerationBlockMessage: 143
-};
-// packages/managers/src/role.ts
-class RoleManager extends ResourceManager {
-  #rest;
-  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;
+    const rule = await this.#rest.get(Routes.guildAutoModerationRule(guildId, ruleId));
+    return new AutoModerationRule(rule);
   }
-  async addRole(userId, roleId) {
-    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId));
+  async createAutoModerationRule(guildId, options) {
+    const rule = await this.#rest.post(Routes.guildAutoModerationRules(guildId), options);
+    return new AutoModerationRule(rule);
   }
-  async removeRole(userId, roleId) {
-    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId));
+  async editAutoModerationRule(guildId, ruleId, options) {
+    const rule = await this.#rest.patch(Routes.guildAutoModerationRule(guildId, ruleId), options);
+    return new AutoModerationRule(rule);
   }
-  async timeout(userId, milliseconds) {
-    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
-    return this.edit(userId, { communication_disabled_until: timeoutDate });
+  async deleteAutoModerationRule(guildId, ruleId) {
+    await this.#rest.delete(Routes.guildAutoModerationRule(guildId, ruleId));
   }
 }
+var AuditLogEvent = {
+  GuildUpdate: 1,
+  ChannelCreate: 10,
+  ChannelUpdate: 11,
+  ChannelDelete: 12,
+  ChannelOverwriteCreate: 13,
+  ChannelOverwriteUpdate: 14,
+  ChannelOverwriteDelete: 15,
+  MemberKick: 20,
+  MemberPrune: 21,
+  MemberBanAdd: 22,
+  MemberBanRemove: 23,
+  MemberUpdate: 24,
+  MemberRoleUpdate: 25,
+  MemberMove: 26,
+  MemberDisconnect: 27,
+  BotAdd: 28,
+  RoleCreate: 30,
+  RoleUpdate: 31,
+  RoleDelete: 32,
+  InviteCreate: 40,
+  InviteUpdate: 41,
+  InviteDelete: 42,
+  WebhookCreate: 50,
+  WebhookUpdate: 51,
+  WebhookDelete: 52,
+  EmojiCreate: 60,
+  EmojiUpdate: 61,
+  EmojiDelete: 62,
+  MessageDelete: 72,
+  MessageBulkDelete: 73,
+  MessagePin: 74,
+  MessageUnpin: 75,
+  IntegrationCreate: 80,
+  IntegrationUpdate: 81,
+  IntegrationDelete: 82,
+  StageInstanceCreate: 83,
+  StageInstanceUpdate: 84,
+  StageInstanceDelete: 85,
+  StickerCreate: 90,
+  StickerUpdate: 91,
+  StickerDelete: 92,
+  ScheduledEventCreate: 100,
+  ScheduledEventUpdate: 101,
+  ScheduledEventDelete: 102,
+  ThreadCreate: 110,
+  ThreadUpdate: 111,
+  ThreadDelete: 112,
+  AutoModerationRuleCreate: 140,
+  AutoModerationRuleUpdate: 141,
+  AutoModerationRuleDelete: 142,
+  AutoModerationBlockMessage: 143
+};
 // packages/managers/src/application.ts
 class ApplicationCommandManager {
   #rest;
@@ -3866,53 +4870,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,27 +4904,29 @@ 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;
   }
   permissionOverwrites(channelId) {
-    return new PermissionOverwriteManager(this.#rest, channelId);
+    return new PermissionOverwriteManager(this.#rest, channelId, () => this.get(channelId)?.permissionOverwrites);
   }
   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 +4936,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));
   }
@@ -4004,7 +5010,7 @@ class ChannelManager extends Manager {
     return this.messages(data.channel_id).upsert(data);
   }
   async editMessage(channelId, messageId, options) {
-    return this.messages(channelId).upsert(await this.#rest.patch(Routes.message(channelId, messageId), options));
+    return this.messages(channelId).upsert(await this.#rest.patch(Routes.message(channelId, messageId), toRequest(options)));
   }
   async deleteMessage(channelId, messageId) {
     await this.#rest.delete(Routes.message(channelId, messageId));
@@ -4017,15 +5023,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 +5149,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 +5249,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 +5279,8 @@ class GatewayHeartbeat {
     }, this.#options.ackTimeout);
   }
   acknowledge() {
+    if (this.#acknowledged)
+      return;
     this.#acknowledged = true;
     this.#latency = this.#now() - this.#sentAt;
     this.#clearAckTimer();
@@ -4826,6 +5861,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 +5947,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 +6083,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 +6277,7 @@ class Client extends EventEmitter2 {
   channels;
   stageInstances;
   application;
+  monetization;
   get ws() {
     return this.#gateway;
   }
@@ -5272,6 +6309,7 @@ class Client extends EventEmitter2 {
     return this.#gateway.requestGuildMembers(data);
   }
   #gateway;
+  #cache;
   #resourceContext;
   constructor(options) {
     super();
@@ -5279,9 +6317,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 };
@@ -5297,8 +6344,32 @@ class Client extends EventEmitter2 {
       removeReaction: (channelId, messageId, emoji, userId) => this.channels.removeReaction(channelId, messageId, emoji, userId),
       removeAllReactions: (channelId, messageId) => this.channels.removeAllReactions(channelId, messageId),
       pinMessage: (channelId, messageId) => this.channels.pinMessage(channelId, messageId),
-      unpinMessage: (channelId, messageId) => this.channels.unpinMessage(channelId, messageId)
+      unpinMessage: (channelId, messageId) => this.channels.unpinMessage(channelId, messageId),
+      collectInteractions: (options) => this.createCollector("interactionCreate" /* InteractionCreate */, options),
+      memberPermissions: (guildId, memberId, roleIds, channelId) => this.#memberPermissions(guildId, memberId, roleIds, channelId),
+      kickMember: (guildId, userId, reason) => this.guilds.members(guildId).kick(userId, reason),
+      banMember: (guildId, userId, options) => this.guilds.members(guildId).ban(userId, options),
+      editMember: (guildId, userId, options, reason) => this.guilds.members(guildId).edit(userId, options, reason),
+      addMemberRole: (guildId, userId, roleId, reason) => this.guilds.members(guildId).addRole(userId, roleId, reason),
+      removeMemberRole: (guildId, userId, roleId, reason) => this.guilds.members(guildId).removeRole(userId, roleId, reason),
+      editPermissionOverwrite: async (channelId, targetId, changes, options) => {
+        const bits = { allow: 0n, deny: 0n, inherit: 0n };
+        for (const [name, value] of Object.entries(changes)) {
+          if (!/^[A-Za-z]+$/.test(name))
+            throw new TypeError(`Unknown permission: ${name}`);
+          let bit;
+          try {
+            bit = new PermissionSet(name).bitfield;
+          } catch {
+            throw new TypeError(`Unknown permission: ${name}`);
+          }
+          const key = value === true ? "allow" : value === false ? "deny" : "inherit";
+          bits[key] |= bit;
+        }
+        return this.channels.permissionOverwrites(channelId).update(targetId, bits, options);
+      }
     };
+    this.guilds.attachContext(this.#resourceContext);
     this.#gateway = new Gateway({
       token: options.token,
       intents: options.intents,
@@ -5312,6 +6383,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", () => {
@@ -5328,19 +6401,46 @@ class Client extends EventEmitter2 {
       this.emit("close" /* Close */, data);
     });
     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);
+      const payload = data;
+      const message = new Message(payload, this.#resourceContext);
+      this.#observeMessage(message);
+      if (payload.member && payload.guild_id && this.guilds.has(payload.guild_id))
+        this.#upsertMember(payload.guild_id, {
+          ...payload.member,
+          user: payload.member.user ?? payload.author
+        });
+      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 +6454,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 +6484,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 +6645,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 +6657,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 +6706,103 @@ 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 }, this.#resourceContext);
+    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;
+  }
+  get resourceContext() {
+    return this.#resourceContext;
+  }
+  #memberPermissions(guildId, memberId, roleIds, channelId) {
+    const guild = this.guilds.get(guildId);
+    if (!guild)
+      return null;
+    let channel = channelId ? this.channels.get(channelId) : undefined;
+    if (channelId) {
+      if (channel?.isThread())
+        channel = channel.parentId ? this.channels.get(channel.parentId) : undefined;
+      if (!channel || channel.guildId !== guildId)
+        return null;
+    }
+    return computePermissions({
+      guildId,
+      ownerId: guild.ownerId,
+      memberId,
+      memberRoleIds: [...roleIds],
+      roles: this.guilds.roles(guildId).values(),
+      overwrites: channel?.permissionOverwrites
+    });
+  }
+  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.");
@@ -5475,12 +6822,21 @@ class Client extends EventEmitter2 {
     this.#gateway.close();
   }
   postInteractionResponse(id, token, response) {
-    return this.rest.post(Routes.interactionCallback(id, token), response.toJSON());
+    const json = response.toJSON();
+    const upload = json.data ? toRequest(json.data) : undefined;
+    if (upload && typeof upload === "object" && "files" in upload) {
+      const { body, files } = upload;
+      return this.rest.post(Routes.interactionCallback(id, token), {
+        body: { ...json, data: body },
+        files
+      });
+    }
+    return this.rest.post(Routes.interactionCallback(id, token), json);
   }
   editInteractionReply(token, data) {
     if (!this.user)
       return Promise.reject(new Error("Client is unauthenticated."));
-    return this.rest.patch(Routes.interactionOriginalResponse(this.user.id, token), data);
+    return this.rest.patch(Routes.interactionOriginalResponse(this.user.id, token), toRequest(data));
   }
   deleteInteractionReply(token) {
     if (!this.user)
@@ -5490,7 +6846,15 @@ class Client extends EventEmitter2 {
   followUpInteraction(token, data) {
     if (!this.user)
       return Promise.reject(new Error("Client is unauthenticated."));
-    return this.rest.post(`/webhooks/${this.user.id}/${token}`, data);
+    return this.rest.post(`/webhooks/${this.user.id}/${token}`, toRequest(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 +7011,21 @@ class HandlerRegistry {
     return this.dispatch(event, ...args);
   }
 }
+// packages/sharding/package.json
+var package_default2 = {
+  name: "@lunibee/sharding",
+  version: "0.2.1",
+  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 +7203,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 +7354,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 +7394,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 +7407,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 +7420,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 +7434,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 +7452,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 +7513,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 }));
   }
@@ -6108,6 +7548,187 @@ class ShardManager {
     });
   }
 }
+// packages/utils/src/args.ts
+var SNOWFLAKE = /^\d{16,22}$/;
+var TRUE_WORDS = new Set([
+  "true",
+  "yes",
+  "y",
+  "on",
+  "1",
+  "enable",
+  "enabled"
+]);
+var FALSE_WORDS = new Set([
+  "false",
+  "no",
+  "n",
+  "off",
+  "0",
+  "disable",
+  "disabled"
+]);
+function tokenizeArgs(input) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let started = false;
+  for (let index = 0;index < input.length; index++) {
+    const character = input[index];
+    if (character === "\\" && index + 1 < input.length) {
+      current += input[++index];
+      started = true;
+    } else if (quote) {
+      if (character === quote)
+        quote = null;
+      else
+        current += character;
+    } else if (character === '"' || character === "'") {
+      if (started)
+        current += character;
+      else {
+        quote = character;
+        started = true;
+      }
+    } else if (/\s/.test(character)) {
+      if (started)
+        args.push(current);
+      current = "";
+      started = false;
+    } else {
+      current += character;
+      started = true;
+    }
+  }
+  if (started)
+    args.push(current);
+  return args;
+}
+function parseUserMention(value) {
+  const id = /^<@!?(\d{16,22})>$/.exec(value)?.[1] ?? value;
+  return SNOWFLAKE.test(id) ? id : null;
+}
+function parseRoleMention(value) {
+  const id = /^<@&(\d{16,22})>$/.exec(value)?.[1] ?? value;
+  return SNOWFLAKE.test(id) ? id : null;
+}
+function parseChannelMention(value) {
+  const id = /^<#(\d{16,22})>$/.exec(value)?.[1] ?? value;
+  return SNOWFLAKE.test(id) ? id : null;
+}
+function parseMentionable(value) {
+  const role = /^<@&(\d{16,22})>$/.exec(value)?.[1];
+  if (role)
+    return { id: role, type: "role" };
+  const user = parseUserMention(value);
+  return user ? { id: user, type: "user" } : null;
+}
+function readOne(spec, raw) {
+  switch (spec.type) {
+    case "string":
+    case "rest":
+      if (spec.maxLength !== undefined && raw.length > spec.maxLength)
+        return {
+          error: `must be at most ${spec.maxLength} characters`
+        };
+      if (spec.choices && !spec.choices.some((choice) => String(choice).toLowerCase() === raw.toLowerCase()))
+        return { error: `must be one of: ${spec.choices.join(", ")}` };
+      return { value: raw };
+    case "integer":
+    case "number": {
+      const value = Number(raw);
+      if (!Number.isFinite(value) || raw.trim() === "")
+        return { error: "must be a number" };
+      if (spec.type === "integer" && !Number.isSafeInteger(value))
+        return { error: "must be a whole number" };
+      if (spec.min !== undefined && value < spec.min)
+        return { error: `must be at least ${spec.min}` };
+      if (spec.max !== undefined && value > spec.max)
+        return { error: `must be at most ${spec.max}` };
+      if (spec.choices && !spec.choices.includes(value))
+        return { error: `must be one of: ${spec.choices.join(", ")}` };
+      return { value };
+    }
+    case "boolean": {
+      const word = raw.toLowerCase();
+      if (TRUE_WORDS.has(word))
+        return { value: true };
+      if (FALSE_WORDS.has(word))
+        return { value: false };
+      return { error: "must be yes or no" };
+    }
+    case "user": {
+      const id = parseUserMention(raw);
+      return id ? { value: id } : { error: "must be a user mention or ID" };
+    }
+    case "role": {
+      const id = parseRoleMention(raw);
+      return id ? { value: id } : { error: "must be a role mention or ID" };
+    }
+    case "channel": {
+      const id = parseChannelMention(raw);
+      return id ? { value: id } : { error: "must be a channel mention or ID" };
+    }
+    case "mentionable": {
+      const value = parseMentionable(raw);
+      return value ? { value } : { error: "must be a user or role mention" };
+    }
+  }
+}
+function parsePrefixArgs(input, specs) {
+  const args = typeof input === "string" ? tokenizeArgs(input) : [...input];
+  const values = {};
+  let position = 0;
+  for (const [index, spec] of specs.entries()) {
+    if (spec.type === "rest" && index !== specs.length - 1)
+      throw new TypeError(`The rest argument "${spec.name}" must be the last one.`);
+    const raw = spec.type === "rest" ? args.slice(position).join(" ") : args[position];
+    if (raw === undefined || raw === "") {
+      if (spec.required)
+        return { ok: false, arg: spec.name, error: "is required" };
+      values[spec.name] = undefined;
+      continue;
+    }
+    const read = readOne(spec, raw);
+    if ("error" in read)
+      return { ok: false, arg: spec.name, error: read.error };
+    values[spec.name] = read.value;
+    position += spec.type === "rest" ? args.length : 1;
+  }
+  return { ok: true, values };
+}
+var OPTION_TYPES = {
+  3: "string",
+  4: "integer",
+  5: "boolean",
+  6: "user",
+  7: "channel",
+  8: "role",
+  9: "mentionable",
+  10: "number"
+};
+function argsFromCommandOptions(options, restLast = false) {
+  const specs = [];
+  for (const option of options) {
+    const type = OPTION_TYPES[option.type];
+    if (!type)
+      continue;
+    specs.push({
+      name: option.name,
+      type,
+      required: option.required,
+      min: option.min_value,
+      max: option.max_value,
+      maxLength: option.max_length,
+      choices: option.choices?.map((choice) => choice.value)
+    });
+  }
+  const last = specs[specs.length - 1];
+  if (restLast && last?.type === "string")
+    last.type = "rest";
+  return specs;
+}
+
 // packages/utils/src/index.ts
 function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -6203,12 +7824,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 +8039,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 +8061,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;
@@ -6516,15 +8151,24 @@ function entersState(target, status, timeoutMs) {
 class EmbedBuilder {
   #data = {};
   setTitle(value) {
-    this.#data.title = validate(value, 256, "Embed title");
+    if (value === null)
+      delete this.#data.title;
+    else
+      this.#data.title = validate(value, 256, "Embed title");
     return this;
   }
   setDescription(value) {
-    this.#data.description = validate(value, 4096, "Embed description");
+    if (value === null)
+      delete this.#data.description;
+    else
+      this.#data.description = validate(value, 4096, "Embed description");
     return this;
   }
   setURL(value) {
-    this.#data.url = url(value, "Embed URL");
+    if (value === null)
+      delete this.#data.url;
+    else
+      this.#data.url = url(value, "Embed URL");
     return this;
   }
   setColor(value) {
@@ -6556,11 +8200,19 @@ class EmbedBuilder {
     return this;
   }
   setThumbnail(value) {
+    if (value === null) {
+      delete this.#data.thumbnail;
+      return this;
+    }
     const valueURL = typeof value === "string" ? value : value.url;
     this.#data.thumbnail = { url: url(valueURL, "Thumbnail URL") };
     return this;
   }
   setImage(value) {
+    if (value === null) {
+      delete this.#data.image;
+      return this;
+    }
     const valueURL = typeof value === "string" ? value : value.url;
     this.#data.image = { url: url(valueURL, "Image URL") };
     return this;
@@ -6663,10 +8315,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 +8376,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 +8392,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 +8430,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 +8449,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 +8512,7 @@ class EntitySelectBuilder {
     return this;
   }
   toJSON() {
+    assertSelect(this.#data);
     return structuredClone(this.#data);
   }
 }
@@ -6842,11 +8539,18 @@ class ModalBuilder {
     this.#components.push(...components);
     return this;
   }
+  addTextInputs(...inputs) {
+    return this.addComponents(...inputs.map((input) => new ActionRowBuilder().addComponents(input)));
+  }
   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 } : {},
-      ...this.#title ? { title: this.#title } : {},
+      custom_id: this.#custom_id,
+      title: this.#title,
       components: this.#components.map((component) => component.toJSON())
     };
   }
@@ -6896,7 +8600,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 +8832,23 @@ 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.");
+}
+var IS_COMPONENTS_V2 = 1 << 15;
+function componentsV2Message(components, options) {
+  const list = Array.isArray(components) ? components : [components];
+  if (!list.length)
+    throw new TypeError("A Components V2 message needs at least one component.");
+  return {
+    ...options ?? {},
+    components: list.map((component) => component.toJSON()),
+    flags: (options?.flags ?? 0) | IS_COMPONENTS_V2
+  };
+}
 // packages/builders/src/commands.ts
 var ApplicationCommandOptionType2 = {
   Subcommand: 1,
@@ -7637,6 +9363,8 @@ export {
   GuildMemberManager,
   GuildOnboarding,
   GuildScheduledEventManager,
+  GuildSoundboardManager,
+  GuildStickerManager,
   GuildWelcomeScreen,
   HandlerRegistry,
   HttpTransport,
@@ -7662,6 +9390,7 @@ export {
   MessageManager,
   ModalBuilder,
   ModalSubmitInteraction,
+  MonetizationManager,
   NewsChannel,
   NumberOptionBuilder,
   OnboardingPrompt,
@@ -7731,6 +9460,7 @@ export {
   WelcomeScreenChannel,
   ZlibStreamDecoder,
   abortError,
+  argsFromCommandOptions,
   blockQuote,
   bold,
   bulletList,
@@ -7739,6 +9469,8 @@ export {
   classifyFrame,
   classifyPayload,
   codeBlock,
+  componentsV2Message,
+  computePermissions,
   createAudioPlayer,
   createAudioResource,
   createChannel,
@@ -7761,7 +9493,13 @@ export {
   masked,
   normalizeRoutePath,
   orderedList,
+  parseChannelMention,
+  parseMentionable,
+  parsePrefixArgs,
+  parseRoleMention,
+  parseUserMention,
   randomInt,
+  redactPath,
   resolveGatewayIntents,
   resumePayload,
   roleMention,
@@ -7772,8 +9510,10 @@ export {
   strikethrough,
   subtext,
   timestamp,
+  toRequest,
+  tokenizeArgs,
   underline,
   userMention
 };
 
-//# debugId=58F0E8EFC21C568E64756E2164756E21
+//# debugId=9E598E337B852A0164756E2164756E21