lunibee 0.1.8 → 0.2.1

package/dist/managers/index.js

@@ -1,6 +1,339 @@
 // @bun
 // 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;
@@ -225,11 +558,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() {
@@ -265,16 +627,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;
   }
@@ -285,7 +651,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",
@@ -352,8 +718,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.`);
@@ -446,6 +827,7 @@ class Channel extends BaseStructure {
   nsfw;
   rateLimitPerUser;
   position;
+  permissionOverwrites;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -459,6 +841,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) {
@@ -482,6 +865,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 });
   }
@@ -616,6 +1004,7 @@ class Guild extends BaseStructure {
     return this.name;
   }
 }
+
 // packages/core/src/permissions.ts
 var Permission = {
   createInstantInvite: 1n << 0n,
@@ -665,8 +1054,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,
@@ -716,8 +1108,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,
@@ -767,8 +1162,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 {
@@ -970,6 +1368,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++) {
@@ -995,6 +1397,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;
@@ -1009,6 +1416,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)
@@ -1031,6 +1441,7 @@ class PermissionsBitField extends PermissionSet {
     super(value);
   }
 }
+var ALL_PERMISSIONS = Object.values(Permission).reduce((bits, bit) => bits | bit, 0n);
 // packages/types/src/gateway.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
@@ -1129,13 +1540,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;
@@ -1145,12 +1558,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;
   }
@@ -1367,7 +1821,7 @@ class ForumChannel extends Channel {
 
 class MediaChannel extends ForumChannel {
 }
-function createChannel(data, context) {
+function createChannel2(data, context) {
   switch (data.type) {
     case 0:
       return new TextChannel(data, context);
@@ -1394,7 +1848,11 @@ function createChannel(data, context) {
       return new Channel(data, context);
   }
 }
+// packages/structures/src/interactions.ts
+var TOKEN_LIFETIME_MS = 15 * 60000;
+
 // 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 {
@@ -1415,6 +1873,7 @@ class Message extends BaseStructure {
   reference;
   components;
   referencedMessage;
+  member;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -1437,6 +1896,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() {
@@ -1477,6 +1941,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.");
@@ -1550,23 +2028,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) {
@@ -1577,13 +2075,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) {
@@ -1609,7 +2108,7 @@ class ThreadManager {
       auto_archive_duration: options.autoArchiveDuration,
       rate_limit_per_user: options.rateLimitPerUser
     });
-    return createChannel(data, this.#context);
+    return createChannel2(data, this.#context);
   }
 }
 
@@ -1637,8 +2136,301 @@ class UserManager extends ResourceManager {
     });
   }
 }
+// packages/managers/src/emoji.ts
+class EmojiManager extends Manager {
+  #rest;
+  #guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.#guildId = guildId;
+  }
+  fetch(emojiId) {
+    return this.fetchOnce(emojiId, async () => new Emoji(await this.#rest.get(Routes.guildEmoji(this.#guildId, emojiId))), (emoji) => this.#merge(emojiId, emoji));
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes.guildEmoji(this.#guildId));
+    return data.map((item) => this.upsert(item));
+  }
+  async create(options) {
+    return this.upsert(await this.#rest.post(Routes.guildEmoji(this.#guildId), options));
+  }
+  async edit(emojiId, options) {
+    return this.upsert(await this.#rest.patch(Routes.guildEmoji(this.#guildId, emojiId), options));
+  }
+  async deleteEmoji(emojiId) {
+    await this.#rest.delete(Routes.guildEmoji(this.#guildId, emojiId));
+    this.delete(emojiId);
+  }
+  upsert(data) {
+    const key = data.id != null ? data.id : `unicode:${data.name ?? ""}`;
+    return this.#merge(key, new Emoji(data));
+  }
+  #merge(key, emoji) {
+    const existing = this.get(key);
+    if (existing) {
+      Object.assign(existing, emoji);
+      return existing;
+    }
+    this.set(key, emoji);
+    return emoji;
+  }
+}
+
+// packages/managers/src/advanced.ts
+function withQuery(path, query) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(query))
+    if (value !== undefined)
+      params.set(key, String(value));
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildStickerManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(sticker) {
+    this.set(sticker.id, sticker);
+    return sticker;
+  }
+  async fetchAll() {
+    const stickers = await this.#rest.get(Routes.guildSticker(this.guildId));
+    this.clear();
+    return stickers.map((sticker) => this.#store(sticker));
+  }
+  async fetch(stickerId) {
+    return this.#store(await this.#rest.get(Routes.guildSticker(this.guildId, stickerId)));
+  }
+  async create(options) {
+    const form = new FormData;
+    form.set("name", options.name);
+    form.set("description", options.description);
+    form.set("tags", options.tags);
+    form.set("file", options.file);
+    return this.#store(await this.#rest.post(Routes.guildSticker(this.guildId), form, { reason: options.reason }));
+  }
+  async edit(stickerId, options) {
+    const { reason, ...body } = options;
+    return this.#store(await this.#rest.patch(Routes.guildSticker(this.guildId, stickerId), body, { reason }));
+  }
+  async remove(stickerId, reason) {
+    await this.#rest.delete(Routes.guildSticker(this.guildId, stickerId), {
+      reason
+    });
+    this.delete(stickerId);
+  }
+  sync(stickers) {
+    this.clear();
+    for (const sticker of stickers)
+      this.#store(sticker);
+  }
+}
+
+class GuildSoundboardManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(sound) {
+    this.set(sound.sound_id, sound);
+    return sound;
+  }
+  async fetchAll() {
+    const { items } = await this.#rest.get(Routes.guildSoundboardSound(this.guildId));
+    this.clear();
+    return items.map((sound) => this.#store(sound));
+  }
+  async fetch(soundId) {
+    return this.#store(await this.#rest.get(Routes.guildSoundboardSound(this.guildId, soundId)));
+  }
+  async create(options) {
+    if (options.volume !== undefined && (options.volume < 0 || options.volume > 1))
+      throw new RangeError("Soundboard volume must be between 0 and 1.");
+    return this.#store(await this.#rest.post(Routes.guildSoundboardSound(this.guildId), {
+      name: options.name,
+      sound: options.sound,
+      volume: options.volume,
+      emoji_id: options.emojiId,
+      emoji_name: options.emojiName
+    }, { reason: options.reason }));
+  }
+  async edit(soundId, options) {
+    return this.#store(await this.#rest.patch(Routes.guildSoundboardSound(this.guildId, soundId), {
+      name: options.name,
+      volume: options.volume,
+      emoji_id: options.emojiId,
+      emoji_name: options.emojiName
+    }, { reason: options.reason }));
+  }
+  async remove(soundId, reason) {
+    await this.#rest.delete(Routes.guildSoundboardSound(this.guildId, soundId), { reason });
+    this.delete(soundId);
+  }
+}
+
+class MonetizationManager extends Manager {
+  #rest;
+  applicationId;
+  constructor(rest, applicationId) {
+    super();
+    this.#rest = rest;
+    this.applicationId = applicationId;
+  }
+  fetchSkus() {
+    return this.#rest.get(Routes.applicationSkus(this.applicationId));
+  }
+  async fetchEntitlements(query = {}) {
+    if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100))
+      throw new RangeError("Entitlement limit must be 1-100.");
+    const entitlements = await this.#rest.get(withQuery(Routes.applicationEntitlement(this.applicationId), {
+      user_id: query.userId,
+      sku_ids: query.skuIds?.join(","),
+      guild_id: query.guildId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit,
+      exclude_ended: query.excludeEnded,
+      exclude_deleted: query.excludeDeleted
+    }));
+    for (const entitlement of entitlements)
+      this.set(entitlement.id, entitlement);
+    return entitlements;
+  }
+  async fetch(entitlementId) {
+    const entitlement = await this.#rest.get(Routes.applicationEntitlement(this.applicationId, entitlementId));
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async consume(entitlementId) {
+    await this.#rest.post(Routes.consumeEntitlement(this.applicationId, entitlementId));
+    const cached = this.get(entitlementId);
+    if (cached)
+      cached.consumed = true;
+  }
+  async createTestEntitlement(options) {
+    const entitlement = await this.#rest.post(Routes.applicationEntitlement(this.applicationId), {
+      sku_id: options.skuId,
+      owner_id: options.ownerId,
+      owner_type: options.ownerType
+    });
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async deleteTestEntitlement(entitlementId) {
+    await this.#rest.delete(Routes.applicationEntitlement(this.applicationId, entitlementId));
+    this.delete(entitlementId);
+  }
+  fetchSubscriptions(skuId, query = {}) {
+    return this.#rest.get(withQuery(Routes.skuSubscription(skuId), {
+      user_id: query.userId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit
+    }));
+  }
+  fetchSubscription(skuId, subscriptionId) {
+    return this.#rest.get(Routes.skuSubscription(skuId, subscriptionId));
+  }
+}
+
+// packages/managers/src/member.ts
+class GuildMemberManager extends ResourceManager {
+  #rest;
+  #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 withQuery(path, params) {
+function withQuery2(path, params) {
   const query = new URLSearchParams;
   for (const [key, value] of Object.entries(params))
     if (value !== undefined)
@@ -1662,7 +2454,7 @@ class GuildBanManager extends Manager {
   }
   async fetchAll(options = {}) {
     const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
-    const bans = await this.#rest.get(withQuery(Routes.guildBans(this.guildId), {
+    const bans = await this.#rest.get(withQuery2(Routes.guildBans(this.guildId), {
       limit,
       before: options.before,
       after: options.after
@@ -1695,12 +2487,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));
@@ -1717,7 +2509,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,
@@ -1761,10 +2553,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), {
@@ -1779,7 +2586,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;
 }
@@ -1788,6 +2595,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;
@@ -1804,6 +2629,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));
@@ -1839,7 +2726,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;
@@ -1847,7 +2734,7 @@ class GuildManager extends ResourceManager {
       params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
     if (options.after)
       params.set("after", options.after);
-    return this.#rest.get(withQuery2(Routes.guildMembers(guildId), params));
+    return this.#rest.get(withQuery3(Routes.guildMembers(guildId), params));
   }
   async fetchAutoModerationRules(guildId) {
     const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
@@ -1922,85 +2809,6 @@ var AuditLogEvent = {
   AutoModerationRuleDelete: 142,
   AutoModerationBlockMessage: 143
 };
-// packages/managers/src/role.ts
-class RoleManager extends ResourceManager {
-  #rest;
-  guildId;
-  constructor(guildId, rest) {
-    super((id) => rest.get(Routes.guildRole(guildId, id)).then((data) => new Role(data)), (role) => role.id);
-    this.guildId = guildId;
-    this.#rest = rest;
-  }
-  async fetchAll() {
-    const data = await this.#rest.get(Routes.guildRoles(this.guildId));
-    return data.map((item) => {
-      const role = new Role(item);
-      this.set(role.id, role);
-      return role;
-    });
-  }
-  async create(options) {
-    const { reason, ...payload } = options;
-    const data = await this.#rest.post(Routes.guildRoles(this.guildId), {
-      ...payload,
-      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
-    });
-    const role = new Role(data);
-    this.set(role.id, role);
-    return role;
-  }
-  async edit(roleId, options) {
-    const { reason, ...payload } = options;
-    const data = await this.#rest.patch(Routes.guildRole(this.guildId, roleId), {
-      ...payload,
-      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
-    });
-    const role = new Role(data);
-    this.set(role.id, role);
-    return role;
-  }
-  async deleteRole(roleId) {
-    await this.#rest.delete(Routes.guildRole(this.guildId, roleId));
-    this.delete(roleId);
-  }
-}
-// packages/managers/src/member.ts
-class GuildMemberManager extends ResourceManager {
-  #rest;
-  guildId;
-  constructor(guildId, rest) {
-    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId })), (member) => member.user.id);
-    this.guildId = guildId;
-    this.#rest = rest;
-  }
-  async kick(userId) {
-    await this.#rest.delete(Routes.guildMember(this.guildId, userId));
-    this.delete(userId);
-  }
-  async ban(userId, options = {}) {
-    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
-    this.delete(userId);
-  }
-  async unban(userId) {
-    await this.#rest.delete(Routes.guildBan(this.guildId, userId));
-  }
-  async edit(userId, options) {
-    const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), options);
-    const member = new GuildMember({ ...data, guild_id: this.guildId });
-    this.set(member.user.id, member);
-    return member;
-  }
-  async addRole(userId, roleId) {
-    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId));
-  }
-  async removeRole(userId, roleId) {
-    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId));
-  }
-  async timeout(userId, milliseconds) {
-    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
-    return this.edit(userId, { communication_disabled_until: timeoutDate });
-  }
-}
 // packages/managers/src/application.ts
 class ApplicationCommandManager {
   #rest;
@@ -2040,53 +2848,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),
@@ -2105,27 +2882,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 () => createChannel2(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(createChannel2(data, this.#context));
+  }
+  #merge(channel) {
+    const existing = this.get(channel.id);
+    if (existing && existing.type === channel.type) {
       Object.assign(existing, channel);
       return existing;
     }
@@ -2135,6 +2914,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));
   }
@@ -2178,7 +2988,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));
@@ -2191,15 +3001,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`);
   }
@@ -2269,14 +3101,18 @@ export {
   GuildManager,
   GuildMemberManager,
   GuildScheduledEventManager,
+  GuildSoundboardManager,
+  GuildStickerManager,
   Manager,
   MessageManager,
+  MonetizationManager,
   PermissionOverwriteManager,
   ResourceManager,
   RoleManager,
   StageInstanceManager,
   ThreadManager,
-  UserManager
+  UserManager,
+  toRequest
 };
 
-//# debugId=E5CAD3E6B2BD672164756E2164756E21
+//# debugId=6C6CF1CF95B4E3CA64756E2164756E21