lunibee 0.1.6 → 0.1.8

package/dist/core/index.js

@@ -1,9 +1,9 @@
 // @bun
 // packages/core/src/permissions.ts
 var PermissionOverwriteType;
-((PermissionOverwriteType2) => {
-  PermissionOverwriteType2[PermissionOverwriteType2["Role"] = 0] = "Role";
-  PermissionOverwriteType2[PermissionOverwriteType2["Member"] = 1] = "Member";
+((PermissionOverwriteType) => {
+  PermissionOverwriteType[PermissionOverwriteType["Role"] = 0] = "Role";
+  PermissionOverwriteType[PermissionOverwriteType["Member"] = 1] = "Member";
 })(PermissionOverwriteType ||= {});
 var Permission = {
   createInstantInvite: 1n << 0n,
@@ -107,58 +107,57 @@ var Permissions = {
   SendPolls: 1n << 49n,
   UseExternalApps: 1n << 50n
 };
-var PermissionFlagsBits;
-((PermissionFlagsBits2) => {
-  PermissionFlagsBits2["CreateInstantInvite"] = "1";
-  PermissionFlagsBits2["KickMembers"] = "2";
-  PermissionFlagsBits2["BanMembers"] = "4";
-  PermissionFlagsBits2["Administrator"] = "8";
-  PermissionFlagsBits2["ManageChannels"] = "16";
-  PermissionFlagsBits2["ManageGuild"] = "32";
-  PermissionFlagsBits2["AddReactions"] = "64";
-  PermissionFlagsBits2["ViewAuditLog"] = "128";
-  PermissionFlagsBits2["PrioritySpeaker"] = "256";
-  PermissionFlagsBits2["Stream"] = "512";
-  PermissionFlagsBits2["ViewChannel"] = "1024";
-  PermissionFlagsBits2["SendMessages"] = "2048";
-  PermissionFlagsBits2["SendTTSMessages"] = "4096";
-  PermissionFlagsBits2["ManageMessages"] = "8192";
-  PermissionFlagsBits2["EmbedLinks"] = "16384";
-  PermissionFlagsBits2["AttachFiles"] = "32768";
-  PermissionFlagsBits2["ReadMessageHistory"] = "65536";
-  PermissionFlagsBits2["MentionEveryone"] = "131072";
-  PermissionFlagsBits2["UseExternalEmojis"] = "262144";
-  PermissionFlagsBits2["ViewGuildInsights"] = "524288";
-  PermissionFlagsBits2["Connect"] = "1048576";
-  PermissionFlagsBits2["Speak"] = "2097152";
-  PermissionFlagsBits2["MuteMembers"] = "4194304";
-  PermissionFlagsBits2["DeafenMembers"] = "8388608";
-  PermissionFlagsBits2["MoveMembers"] = "16777216";
-  PermissionFlagsBits2["UseVAD"] = "33554432";
-  PermissionFlagsBits2["ChangeNickname"] = "67108864";
-  PermissionFlagsBits2["ManageNicknames"] = "134217728";
-  PermissionFlagsBits2["ManageRoles"] = "268435456";
-  PermissionFlagsBits2["ManageWebhooks"] = "536870912";
-  PermissionFlagsBits2["ManageGuildExpressions"] = "1073741824";
-  PermissionFlagsBits2["UseApplicationCommands"] = "2147483648";
-  PermissionFlagsBits2["RequestToSpeak"] = "4294967296";
-  PermissionFlagsBits2["ManageEvents"] = "8589934592";
-  PermissionFlagsBits2["ManageThreads"] = "17179869184";
-  PermissionFlagsBits2["CreatePublicThreads"] = "34359738368";
-  PermissionFlagsBits2["CreatePrivateThreads"] = "68719476736";
-  PermissionFlagsBits2["UseExternalStickers"] = "137438953472";
-  PermissionFlagsBits2["SendMessagesInThreads"] = "274877906944";
-  PermissionFlagsBits2["UseEmbeddedActivities"] = "549755813888";
-  PermissionFlagsBits2["ModerateMembers"] = "1099511627776";
-  PermissionFlagsBits2["ViewCreatorMonetizationAnalytics"] = "2199023255552";
-  PermissionFlagsBits2["UseSoundboard"] = "4398046511104";
-  PermissionFlagsBits2["CreateGuildExpressions"] = "8796093022208";
-  PermissionFlagsBits2["CreateEvents"] = "17592186044416";
-  PermissionFlagsBits2["UseExternalSounds"] = "35184372088832";
-  PermissionFlagsBits2["SendVoiceMessages"] = "70368744177664";
-  PermissionFlagsBits2["SendPolls"] = "562949953421312";
-  PermissionFlagsBits2["UseExternalApps"] = "1125899906842624";
-})(PermissionFlagsBits ||= {});
+var PermissionFlagsBits = {
+  CreateInstantInvite: 1n << 0n,
+  KickMembers: 1n << 1n,
+  BanMembers: 1n << 2n,
+  Administrator: 1n << 3n,
+  ManageChannels: 1n << 4n,
+  ManageGuild: 1n << 5n,
+  AddReactions: 1n << 6n,
+  ViewAuditLog: 1n << 7n,
+  PrioritySpeaker: 1n << 8n,
+  Stream: 1n << 9n,
+  ViewChannel: 1n << 10n,
+  SendMessages: 1n << 11n,
+  SendTTSMessages: 1n << 12n,
+  ManageMessages: 1n << 13n,
+  EmbedLinks: 1n << 14n,
+  AttachFiles: 1n << 15n,
+  ReadMessageHistory: 1n << 16n,
+  MentionEveryone: 1n << 17n,
+  UseExternalEmojis: 1n << 18n,
+  ViewGuildInsights: 1n << 19n,
+  Connect: 1n << 20n,
+  Speak: 1n << 21n,
+  MuteMembers: 1n << 22n,
+  DeafenMembers: 1n << 23n,
+  MoveMembers: 1n << 24n,
+  UseVAD: 1n << 25n,
+  ChangeNickname: 1n << 26n,
+  ManageNicknames: 1n << 27n,
+  ManageRoles: 1n << 28n,
+  ManageWebhooks: 1n << 29n,
+  ManageGuildExpressions: 1n << 30n,
+  UseApplicationCommands: 1n << 31n,
+  RequestToSpeak: 1n << 32n,
+  ManageEvents: 1n << 33n,
+  ManageThreads: 1n << 34n,
+  CreatePublicThreads: 1n << 35n,
+  CreatePrivateThreads: 1n << 36n,
+  UseExternalStickers: 1n << 37n,
+  SendMessagesInThreads: 1n << 38n,
+  UseEmbeddedActivities: 1n << 39n,
+  ModerateMembers: 1n << 40n,
+  ViewCreatorMonetizationAnalytics: 1n << 41n,
+  UseSoundboard: 1n << 42n,
+  CreateGuildExpressions: 1n << 43n,
+  CreateEvents: 1n << 44n,
+  UseExternalSounds: 1n << 45n,
+  SendVoiceMessages: 1n << 46n,
+  SendPolls: 1n << 49n,
+  UseExternalApps: 1n << 50n
+};
 
 class PermissionSet {
   bitfield;
@@ -403,7 +402,7 @@ class PermissionSet {
       if (permission in Permissions)
         return Permissions[permission];
       if (permission in PermissionFlagsBits)
-        return BigInt(PermissionFlagsBits[permission]);
+        return PermissionFlagsBits[permission];
       const lower = permission.charAt(0).toLowerCase() + permission.slice(1);
       if (lower in Permission)
         return Permission[lower];
@@ -422,71 +421,147 @@ class PermissionsBitField extends PermissionSet {
 }
 // packages/core/src/events.ts
 var ClientEvent;
-((ClientEvent2) => {
-  ClientEvent2["Ready"] = "ready";
-  ClientEvent2["Raw"] = "raw";
-  ClientEvent2["Error"] = "error";
-  ClientEvent2["Open"] = "open";
-  ClientEvent2["Close"] = "close";
-  ClientEvent2["MessageCreate"] = "messageCreate";
-  ClientEvent2["MessageUpdate"] = "messageUpdate";
-  ClientEvent2["MessageDelete"] = "messageDelete";
-  ClientEvent2["MessageDeleteBulk"] = "messageDeleteBulk";
-  ClientEvent2["MessageReactionAdd"] = "messageReactionAdd";
-  ClientEvent2["MessageReactionRemove"] = "messageReactionRemove";
-  ClientEvent2["MessageReactionRemoveAll"] = "messageReactionRemoveAll";
-  ClientEvent2["MessageReactionRemoveEmoji"] = "messageReactionRemoveEmoji";
-  ClientEvent2["MessagePollVoteAdd"] = "messagePollVoteAdd";
-  ClientEvent2["MessagePollVoteRemove"] = "messagePollVoteRemove";
-  ClientEvent2["GuildCreate"] = "guildCreate";
-  ClientEvent2["GuildUpdate"] = "guildUpdate";
-  ClientEvent2["GuildDelete"] = "guildDelete";
-  ClientEvent2["GuildAvailable"] = "guildAvailable";
-  ClientEvent2["GuildUnavailable"] = "guildUnavailable";
-  ClientEvent2["GuildMemberAdd"] = "guildMemberAdd";
-  ClientEvent2["GuildMemberUpdate"] = "guildMemberUpdate";
-  ClientEvent2["GuildMemberRemove"] = "guildMemberRemove";
-  ClientEvent2["GuildMembersChunk"] = "guildMembersChunk";
-  ClientEvent2["GuildBanAdd"] = "guildBanAdd";
-  ClientEvent2["GuildBanRemove"] = "guildBanRemove";
-  ClientEvent2["GuildRoleCreate"] = "guildRoleCreate";
-  ClientEvent2["GuildRoleUpdate"] = "guildRoleUpdate";
-  ClientEvent2["GuildRoleDelete"] = "guildRoleDelete";
-  ClientEvent2["GuildEmojisUpdate"] = "guildEmojisUpdate";
-  ClientEvent2["GuildStickersUpdate"] = "guildStickersUpdate";
-  ClientEvent2["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
-  ClientEvent2["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
-  ClientEvent2["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
-  ClientEvent2["GuildScheduledEventDelete"] = "guildScheduledEventDelete";
-  ClientEvent2["GuildScheduledEventUserAdd"] = "guildScheduledEventUserAdd";
-  ClientEvent2["GuildScheduledEventUserRemove"] = "guildScheduledEventUserRemove";
-  ClientEvent2["AutoModerationRuleCreate"] = "autoModerationRuleCreate";
-  ClientEvent2["AutoModerationRuleUpdate"] = "autoModerationRuleUpdate";
-  ClientEvent2["AutoModerationRuleDelete"] = "autoModerationRuleDelete";
-  ClientEvent2["AutoModerationActionExecution"] = "autoModerationActionExecution";
-  ClientEvent2["ChannelCreate"] = "channelCreate";
-  ClientEvent2["ChannelUpdate"] = "channelUpdate";
-  ClientEvent2["ChannelDelete"] = "channelDelete";
-  ClientEvent2["ChannelPinsUpdate"] = "channelPinsUpdate";
-  ClientEvent2["ThreadCreate"] = "threadCreate";
-  ClientEvent2["ThreadUpdate"] = "threadUpdate";
-  ClientEvent2["ThreadDelete"] = "threadDelete";
-  ClientEvent2["ThreadListSync"] = "threadListSync";
-  ClientEvent2["ThreadMembersUpdate"] = "threadMembersUpdate";
-  ClientEvent2["ThreadMemberUpdate"] = "threadMemberUpdate";
-  ClientEvent2["StageInstanceCreate"] = "stageInstanceCreate";
-  ClientEvent2["StageInstanceUpdate"] = "stageInstanceUpdate";
-  ClientEvent2["StageInstanceDelete"] = "stageInstanceDelete";
-  ClientEvent2["InviteCreate"] = "inviteCreate";
-  ClientEvent2["InviteDelete"] = "inviteDelete";
-  ClientEvent2["WebhooksUpdate"] = "webhooksUpdate";
-  ClientEvent2["VoiceStateUpdate"] = "voiceStateUpdate";
-  ClientEvent2["VoiceServerUpdate"] = "voiceServerUpdate";
-  ClientEvent2["PresenceUpdate"] = "presenceUpdate";
-  ClientEvent2["TypingStart"] = "typingStart";
-  ClientEvent2["InteractionCreate"] = "interactionCreate";
+((ClientEvent) => {
+  ClientEvent["Ready"] = "ready";
+  ClientEvent["Resumed"] = "resumed";
+  ClientEvent["InvalidSession"] = "invalidSession";
+  ClientEvent["Raw"] = "raw";
+  ClientEvent["Error"] = "error";
+  ClientEvent["Open"] = "open";
+  ClientEvent["Close"] = "close";
+  ClientEvent["MessageCreate"] = "messageCreate";
+  ClientEvent["MessageUpdate"] = "messageUpdate";
+  ClientEvent["MessageDelete"] = "messageDelete";
+  ClientEvent["MessageDeleteBulk"] = "messageDeleteBulk";
+  ClientEvent["MessageReactionAdd"] = "messageReactionAdd";
+  ClientEvent["MessageReactionRemove"] = "messageReactionRemove";
+  ClientEvent["MessageReactionRemoveAll"] = "messageReactionRemoveAll";
+  ClientEvent["MessageReactionRemoveEmoji"] = "messageReactionRemoveEmoji";
+  ClientEvent["MessagePollVoteAdd"] = "messagePollVoteAdd";
+  ClientEvent["MessagePollVoteRemove"] = "messagePollVoteRemove";
+  ClientEvent["GuildCreate"] = "guildCreate";
+  ClientEvent["GuildUpdate"] = "guildUpdate";
+  ClientEvent["GuildDelete"] = "guildDelete";
+  ClientEvent["GuildAvailable"] = "guildAvailable";
+  ClientEvent["GuildUnavailable"] = "guildUnavailable";
+  ClientEvent["GuildMemberAdd"] = "guildMemberAdd";
+  ClientEvent["GuildMemberUpdate"] = "guildMemberUpdate";
+  ClientEvent["GuildMemberRemove"] = "guildMemberRemove";
+  ClientEvent["GuildMembersChunk"] = "guildMembersChunk";
+  ClientEvent["GuildBanAdd"] = "guildBanAdd";
+  ClientEvent["GuildBanRemove"] = "guildBanRemove";
+  ClientEvent["GuildRoleCreate"] = "guildRoleCreate";
+  ClientEvent["GuildRoleUpdate"] = "guildRoleUpdate";
+  ClientEvent["GuildRoleDelete"] = "guildRoleDelete";
+  ClientEvent["GuildEmojisUpdate"] = "guildEmojisUpdate";
+  ClientEvent["GuildStickersUpdate"] = "guildStickersUpdate";
+  ClientEvent["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
+  ClientEvent["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
+  ClientEvent["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
+  ClientEvent["GuildScheduledEventDelete"] = "guildScheduledEventDelete";
+  ClientEvent["GuildScheduledEventUserAdd"] = "guildScheduledEventUserAdd";
+  ClientEvent["GuildScheduledEventUserRemove"] = "guildScheduledEventUserRemove";
+  ClientEvent["AutoModerationRuleCreate"] = "autoModerationRuleCreate";
+  ClientEvent["AutoModerationRuleUpdate"] = "autoModerationRuleUpdate";
+  ClientEvent["AutoModerationRuleDelete"] = "autoModerationRuleDelete";
+  ClientEvent["AutoModerationActionExecution"] = "autoModerationActionExecution";
+  ClientEvent["ChannelCreate"] = "channelCreate";
+  ClientEvent["ChannelUpdate"] = "channelUpdate";
+  ClientEvent["ChannelDelete"] = "channelDelete";
+  ClientEvent["ChannelPinsUpdate"] = "channelPinsUpdate";
+  ClientEvent["ThreadCreate"] = "threadCreate";
+  ClientEvent["ThreadUpdate"] = "threadUpdate";
+  ClientEvent["ThreadDelete"] = "threadDelete";
+  ClientEvent["ThreadListSync"] = "threadListSync";
+  ClientEvent["ThreadMembersUpdate"] = "threadMembersUpdate";
+  ClientEvent["ThreadMemberUpdate"] = "threadMemberUpdate";
+  ClientEvent["StageInstanceCreate"] = "stageInstanceCreate";
+  ClientEvent["StageInstanceUpdate"] = "stageInstanceUpdate";
+  ClientEvent["StageInstanceDelete"] = "stageInstanceDelete";
+  ClientEvent["InviteCreate"] = "inviteCreate";
+  ClientEvent["InviteDelete"] = "inviteDelete";
+  ClientEvent["WebhooksUpdate"] = "webhooksUpdate";
+  ClientEvent["VoiceStateUpdate"] = "voiceStateUpdate";
+  ClientEvent["VoiceServerUpdate"] = "voiceServerUpdate";
+  ClientEvent["PresenceUpdate"] = "presenceUpdate";
+  ClientEvent["TypingStart"] = "typingStart";
+  ClientEvent["InteractionCreate"] = "interactionCreate";
 })(ClientEvent ||= {});
-// packages/types/src/index.ts
+// packages/core/src/collector.ts
+import { EventEmitter } from "events";
+
+class Collector extends EventEmitter {
+  collected = new Map;
+  options;
+  ended = false;
+  endReason;
+  totalProcessed = 0;
+  #timeoutTimer;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    if (options.time && options.time > 0) {
+      this.#timeoutTimer = setTimeout(() => {
+        this.stop("time");
+      }, options.time);
+    }
+  }
+  async handle(key, item) {
+    if (this.ended)
+      return false;
+    this.totalProcessed++;
+    const reachedProcessed = !!this.options.maxProcessed && this.totalProcessed >= this.options.maxProcessed;
+    let passed = true;
+    if (this.options.filter)
+      passed = !!await this.options.filter(item);
+    if (this.ended)
+      return false;
+    if (!passed) {
+      if (reachedProcessed)
+        this.stop("processedLimit");
+      return false;
+    }
+    this.collected.set(key, item);
+    this.emit("collect", item);
+    if (this.options.max && this.collected.size >= this.options.max) {
+      this.stop("limit");
+      return true;
+    }
+    if (reachedProcessed) {
+      this.stop("processedLimit");
+      return true;
+    }
+    return true;
+  }
+  stop(reason = "user") {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.endReason = reason;
+    if (this.#timeoutTimer)
+      clearTimeout(this.#timeoutTimer);
+    this.emit("end", this.collected, reason);
+    this.removeAllListeners();
+  }
+  next() {
+    return new Promise((resolve, reject) => {
+      if (this.ended) {
+        return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
+      }
+      const onCollect = (item) => {
+        this.off("end", onEnd);
+        resolve(item);
+      };
+      const onEnd = (_collected, reason) => {
+        this.off("collect", onCollect);
+        reject(new Error(`Collector ended before item was collected: ${reason}`));
+      };
+      this.once("collect", onCollect);
+      this.once("end", onEnd);
+    });
+  }
+}
+// packages/types/src/gateway.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
   GuildMembers: 1 << 1,
@@ -542,6 +617,8 @@ var Intents = IntentBits;
 function resolveGatewayIntents(intents) {
   if (typeof intents === "number")
     return intents;
+  if (intents && typeof intents === "object" && !Array.isArray(intents))
+    return intents.bitfield;
   if (Array.isArray(intents)) {
     return intents.reduce((acc, intent) => {
       return acc | resolveGatewayIntents(intent);
@@ -561,6 +638,44 @@ function resolveGatewayIntents(intents) {
   }
   return 0;
 }
+
+class IntentsBitField {
+  static Flags = GatewayIntentBits;
+  bitfield;
+  constructor(bits = 0) {
+    this.bitfield = resolveGatewayIntents(bits);
+  }
+  has(bits) {
+    const resolved = resolveGatewayIntents(bits);
+    return (this.bitfield & resolved) === resolved;
+  }
+  any(bits) {
+    return (this.bitfield & resolveGatewayIntents(bits)) !== 0;
+  }
+  add(...bits) {
+    for (const bit of bits)
+      this.bitfield |= resolveGatewayIntents(bit);
+    return this;
+  }
+  remove(...bits) {
+    for (const bit of bits)
+      this.bitfield &= ~resolveGatewayIntents(bit);
+    return this;
+  }
+  toArray() {
+    return Object.keys(GatewayIntentBits).filter((name) => this.has(GatewayIntentBits[name]));
+  }
+  equals(bits) {
+    return this.bitfield === resolveGatewayIntents(bits);
+  }
+  valueOf() {
+    return this.bitfield;
+  }
+  toJSON() {
+    return this.bitfield;
+  }
+}
+// packages/types/src/index.ts
 var InteractionResponseType = {
   Pong: 1,
   ChannelMessage: 4,
@@ -716,6 +831,75 @@ class Collection extends Map {
     }
     return result;
   }
+  partition(predicate) {
+    const pass = new Collection;
+    const fail = new Collection;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        pass.set(key, value);
+      else
+        fail.set(key, value);
+    }
+    return [pass, fail];
+  }
+  tap(fn) {
+    fn(this);
+    return this;
+  }
+  flatMap(transform) {
+    const result = [];
+    for (const [key, value] of this) {
+      for (const item of transform(value, key, this))
+        result.push(item);
+    }
+    return result;
+  }
+  reduce(fn, initialValue) {
+    let acc = initialValue;
+    for (const [key, value] of this)
+      acc = fn(acc, value, key, this);
+    return acc;
+  }
+  sorted(comparator) {
+    const decorated = [...this.entries()].map((entry, index) => ({
+      entry,
+      index
+    }));
+    if (comparator)
+      decorated.sort((x, y) => {
+        const comparison = comparator(x.entry[1], y.entry[1], x.entry[0], y.entry[0]);
+        return comparison !== 0 ? comparison : x.index - y.index;
+      });
+    const result = new Collection;
+    for (const { entry } of decorated)
+      result.set(entry[0], entry[1]);
+    return result;
+  }
+  random() {
+    const arr = [...this.values()];
+    if (!arr.length)
+      return;
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  randomKey() {
+    const arr = [...this.keys()];
+    if (!arr.length)
+      return;
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  at(index) {
+    const arr = [...this.values()];
+    const i = index < 0 ? arr.length + index : index;
+    return arr[i];
+  }
+  keyAt(index) {
+    const arr = [...this.keys()];
+    const i = index < 0 ? arr.length + index : index;
+    return arr[i];
+  }
+  toJSON() {
+    return [...this.entries()];
+  }
 }
 
 // packages/managers/src/base.ts
@@ -787,7 +971,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.6",
+  version: "0.1.8",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -796,60 +980,57 @@ var package_default = {
   }
 };
 
-// packages/rest/src/routes.ts
-var Routes = {
-  user: () => "/users/@me",
-  userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
-  guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
-  guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
-  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
-  guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
-  guildInvites: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/invites`,
-  guildChannels: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/channels`,
-  guildMember: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}`,
-  guildRoles: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles`,
-  guildRole: (guildId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles/${snowflake(roleId, "Role ID")}`,
-  guildMemberRole: (guildId, userId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}/roles/${snowflake(roleId, "Role ID")}`,
-  guildBans: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans`,
-  guildBan: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans/${snowflake(userId, "User ID")}`,
-  channel: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}`,
-  channelMessages: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages`,
-  message: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/${snowflake(messageId, "Message ID")}`,
-  crosspostMessage: (channelId, messageId) => `${Routes.message(channelId, messageId)}/crosspost`,
-  messageReactions: (channelId, messageId, emoji) => `${Routes.message(channelId, messageId)}/reactions/${encodeURIComponent(emoji)}`,
-  messageReactionsAll: (channelId, messageId) => `${Routes.message(channelId, messageId)}/reactions`,
-  channelPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/pins`,
-  channelPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/pins/${snowflake(messageId, "Message ID")}`,
-  messageThread: (channelId, messageId) => `${Routes.message(channelId, messageId)}/threads`,
-  channelBulkDelete: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/bulk-delete`,
-  channelWebhooks: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/webhooks`,
-  channelInvites: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/invites`,
-  webhook: (webhookId, token) => `/webhooks/${snowflake(webhookId, "Webhook ID")}${token ? `/${encodeURIComponent(token)}` : ""}`,
-  webhookMessage: (webhookId, token, messageId) => `/webhooks/${snowflake(webhookId, "Webhook ID")}/${encodeURIComponent(token)}/messages/${snowflake(messageId, "Message ID")}`,
-  applicationCommands: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/commands`,
-  applicationCommand: (applicationId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/commands/${snowflake(commandId, "Command ID")}`,
-  guildApplicationCommands: (applicationId, guildId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands`,
-  guildApplicationCommand: (applicationId, guildId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands/${snowflake(commandId, "Command ID")}`,
-  interactionCallback: (interactionId, token) => `/interactions/${snowflake(interactionId, "Interaction ID")}/${encodeURIComponent(token)}/callback`,
-  interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
-  channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
-  channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
-  threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
-  guildScheduledEvents: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events`,
-  guildScheduledEvent: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}`,
-  guildAutoModerationRules: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules`,
-  guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
-  voiceRegions: () => "/voice/regions",
-  gateway: () => "/gateway",
-  gatewayBot: () => "/gateway/bot"
-};
-function snowflake(value, field) {
-  if (!/^\d{1,20}$/.test(value))
-    throw new TypeError(`${field} must be a valid Discord snowflake.`);
-  return value;
+// packages/rest/src/store.ts
+class MemoryRateLimitStore {
+  #buckets = new Map;
+  #routeBuckets = new Map;
+  #globalResetAt = 0;
+  static #PRUNE_INTERVAL = 60000;
+  #lastPruneAt = 0;
+  getBucketHash(route) {
+    return this.#routeBuckets.get(route);
+  }
+  setBucketHash(route, hash) {
+    this.#routeBuckets.set(route, hash);
+  }
+  getBucket(key) {
+    return this.#buckets.get(key);
+  }
+  reserve(key) {
+    const state = this.#buckets.get(key);
+    const now = Date.now();
+    if (!state || state.resetAt <= now)
+      return { granted: true };
+    if (state.remaining > 0) {
+      state.remaining -= 1;
+      return { granted: true };
+    }
+    return { granted: false, retryAfterMs: state.resetAt - now };
+  }
+  updateBucket(key, state) {
+    this.#buckets.set(key, state);
+    const now = Date.now();
+    if (now - this.#lastPruneAt >= MemoryRateLimitStore.#PRUNE_INTERVAL) {
+      this.#lastPruneAt = now;
+      this.prune();
+    }
+  }
+  prune(maxAge = 0) {
+    const cutoff = Date.now() - Math.max(0, maxAge);
+    for (const [key, state] of this.#buckets) {
+      if (state.resetAt <= cutoff)
+        this.#buckets.delete(key);
+    }
+  }
+  getGlobalReset() {
+    return this.#globalResetAt;
+  }
+  setGlobalReset(resetAt) {
+    this.#globalResetAt = resetAt;
+  }
 }
 
-// packages/rest/src/index.ts
+// packages/rest/src/errors.ts
 class RESTError extends Error {
   status;
   code;
@@ -866,196 +1047,254 @@ class RESTError extends Error {
     this.path = options.path;
   }
 }
-var LIBRARY_VERSION = package_default.version;
-var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
-var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
-function createRetryPolicy(maxRetries = 2) {
-  if (!Number.isFinite(maxRetries) || maxRetries < 0)
-    throw new TypeError("maxRetries must be a non-negative finite number.");
+function abortError(path, reason) {
+  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+}
+async function sleep(delay, signal, path) {
+  if (delay <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delay);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(abortError(path, signal?.reason));
+    };
+    if (signal?.aborted)
+      return abort();
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function abortable(promise, signal, path) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    throw abortError(path, signal.reason);
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => signal.addEventListener("abort", () => reject(abortError(path, signal.reason)), { once: true }))
+  ]);
+}
+
+// packages/rest/src/route.ts
+function normalizeRoutePath(path) {
+  const queryIndex = path.indexOf("?");
+  const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
+  return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
+}
+function majorParameter(path) {
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  if (!match)
+    return "@none";
+  if (match[1] === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${match[3]}`;
+  return match[2];
+}
+function scopeBucket(hashOrRoute, major) {
+  return `${hashOrRoute}|${major}`;
+}
+function createRouteKey(method, path) {
+  const normalizedMethod = method.toUpperCase();
   return {
-    maxRetries: Math.floor(maxRetries),
-    shouldRetry(method, status) {
-      const normalized = method.toUpperCase();
-      return status === 429 || status >= 500 && status <= 599 && ["GET", "HEAD", "PUT", "DELETE"].includes(normalized);
-    },
-    getDelay(attempt, retryAfter) {
-      if (retryAfter !== undefined)
-        return Math.max(0, retryAfter * 1000);
-      return Math.min(1e4, 500 * 2 ** attempt) + Math.random() * 250;
-    }
+    method: normalizedMethod,
+    path,
+    route: `${normalizedMethod}:${normalizeRoutePath(path)}`,
+    major: majorParameter(path)
   };
 }
+function serializeQuery(query) {
+  if (query === undefined)
+    return "";
+  if (typeof query === "string")
+    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
+  const serialized = params.toString();
+  return serialized.length === 0 ? "" : `?${serialized}`;
+}
 
-class REST {
-  #baseURL;
-  #timeout;
-  #retryPolicy;
-  #token;
-  #globalResetAt = 0;
-  #buckets = new Map;
-  #routeBuckets = new Map;
-  constructor(options = {}) {
-    this.#token = options.token;
-    this.#timeout = Math.max(1, options.timeout ?? 15000);
-    this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
-    this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
-  }
-  setToken(token) {
-    if (!token.trim())
-      throw new TypeError("A Discord bot token is required.");
-    this.#token = token;
+// packages/rest/src/scheduler.ts
+class RequestScheduler {
+  static MAX_REMAPS = 2;
+  #queues = new Map;
+  get size() {
+    return this.#queues.size;
+  }
+  async runResolved(resolveKey, signal, path, task) {
+    let key = await resolveKey();
+    for (let hop = 0;hop < RequestScheduler.MAX_REMAPS; hop++) {
+      const outcome = await this.run(key, signal, path, async (release) => {
+        const current = await resolveKey();
+        if (current !== key)
+          return { done: false, key: current };
+        return { done: true, value: await task(key, release) };
+      });
+      if (outcome.done)
+        return outcome.value;
+      key = outcome.key;
+    }
+    return this.run(key, signal, path, (release) => task(key, release));
   }
-  async request(method, path, body, options = {}) {
-    const normalizedMethod = method.toUpperCase();
-    if (!normalizedMethod)
-      throw new TypeError("REST method is required.");
-    if (!path.startsWith("/"))
-      throw new TypeError("REST paths must start with '/'.");
-    const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    let bucketKey = this.#routeBuckets.get(route) ?? route;
-    let bucket = this.#buckets.get(bucketKey) ?? {
-      remaining: 1,
-      resetAt: 0,
-      queue: Promise.resolve()
-    };
-    this.#buckets.set(bucketKey, bucket);
-    const previous = bucket.queue;
-    let release;
-    bucket.queue = new Promise((resolve) => {
-      release = resolve;
+  async run(key, signal, path, task) {
+    const previous = this.#queues.get(key) ?? Promise.resolve();
+    let open;
+    const gate = new Promise((resolve) => {
+      open = resolve;
     });
-    await this.#abortable(previous, options.signal, path);
+    this.#queues.set(key, gate);
+    let released = false;
+    const release = () => {
+      if (released)
+        return;
+      released = true;
+      open();
+      if (this.#queues.get(key) === gate)
+        this.#queues.delete(key);
+    };
     try {
-      for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucket, options.signal, path);
-        await this.#waitGlobal(options.signal, path);
-        const controller = new AbortController;
-        const onAbort = () => controller.abort(options.signal?.reason);
-        if (options.signal?.aborted)
-          throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, { once: true });
-        const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
-        const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
-        const headers = {
-          ...this.#token ? { Authorization: `Bot ${this.#token}` } : {},
-          "User-Agent": USER_AGENT
-        };
-        if (!isFormData)
-          headers["Content-Type"] = "application/json";
-        const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
-        try {
-          const response = await fetch(`${this.#baseURL}${path}`, {
-            method: normalizedMethod,
-            headers,
-            body: fetchBody,
-            signal: controller.signal
-          });
-          bucket = this.#update(response, bucket, route, bucketKey);
-          bucketKey = this.#routeBuckets.get(route) ?? bucketKey;
-          const payload = await this.#readPayload(response);
-          if (response.ok)
-            return response.status === 204 ? undefined : payload;
-          const data = this.#errorData(payload);
-          const retryAfter = response.status === 429 ? this.#retryAfter(response, data) : undefined;
-          if (data.global && retryAfter !== undefined)
-            this.#globalResetAt = Date.now() + retryAfter * 1000;
-          if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt, retryAfter), options.signal, path);
-            continue;
-          }
-          throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method: normalizedMethod, path });
-        } catch (error) {
-          if (error instanceof RESTError)
-            throw error;
-          if (options.signal?.aborted)
-            throw this.#abortError(path, options.signal.reason);
-          const isTimeout = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
-          if (!isTimeout && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, 0)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt), options.signal, path);
-            continue;
-          }
-          throw new RESTError(isTimeout ? `Discord REST request timed out after ${this.#timeout}ms` : "Discord REST request failed", 0, undefined, undefined, { method: normalizedMethod, path, cause: error });
-        } finally {
-          clearTimeout(timer);
-          options.signal?.removeEventListener("abort", onAbort);
-        }
-      }
-      throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method: normalizedMethod, path });
+      await abortable(previous, signal, path);
+      return await task(release);
     } finally {
       release();
     }
   }
-  get(path, options) {
-    return this.request("GET", path, undefined, options);
+}
+
+// packages/rest/src/limiter.ts
+class RateLimiter {
+  #store;
+  #concurrent;
+  constructor(store, options = {}) {
+    this.#store = store;
+    this.#concurrent = options.concurrent ?? false;
+  }
+  get store() {
+    return this.#store;
+  }
+  async resolveBucketKey(route, major) {
+    return scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
+  }
+  get reserves() {
+    return typeof this.#store.reserve === "function";
+  }
+  async acquire(bucketKey, signal, path) {
+    await this.#waitGlobal(signal, path);
+    if (!this.#store.reserve) {
+      const bucket = await this.#store.getBucket(bucketKey);
+      if (bucket) {
+        const delay = bucket.resetAt - Date.now();
+        if (bucket.remaining <= 0 && delay > 0)
+          await sleep(delay, signal, path);
+      }
+      return;
+    }
+    for (let attempt = 0;attempt < 8; attempt++) {
+      const reservation = await this.#store.reserve(bucketKey);
+      if (reservation.granted)
+        return;
+      await sleep(Math.max(1, reservation.retryAfterMs), signal, path);
+      await this.#waitGlobal(signal, path);
+    }
   }
-  post(path, body, options) {
-    return this.request("POST", path, body, options);
+  async#waitGlobal(signal, path) {
+    const globalDelay = await this.#store.getGlobalReset() - Date.now();
+    if (globalDelay > 0)
+      await sleep(globalDelay, signal, path);
   }
-  patch(path, body, options) {
-    return this.request("PATCH", path, body, options);
+  async noteGlobalReset(resetAt) {
+    const current = await this.#store.getGlobalReset();
+    await this.#store.setGlobalReset(Math.max(current, resetAt));
   }
-  put(path, body, options) {
-    return this.request("PUT", path, body, options);
-  }
-  delete(path, options) {
-    return this.request("DELETE", path, undefined, options);
-  }
-  #fileForm(payload, files) {
-    const form = new FormData;
-    form.append("payload_json", JSON.stringify(payload));
-    for (let i = 0;i < files.length; i++) {
-      const file = files[i];
-      const blob = file.data instanceof Blob ? file.data : new Blob([file.data], {
-        type: file.contentType ?? "application/octet-stream"
-      });
-      form.append(`files[${i}]`, blob, file.name);
+  async applyResponse(response, bucketKey, route, major) {
+    let currentKey = bucketKey;
+    const serverBucket = response.headers.get("X-RateLimit-Bucket");
+    if (serverBucket) {
+      await this.#store.setBucketHash(route, serverBucket);
+      currentKey = scopeBucket(serverBucket, major);
     }
-    return form;
-  }
-  postWithFiles(path, payload, files, options) {
-    return this.request("POST", path, this.#fileForm(payload, files), options);
-  }
-  patchWithFiles(path, payload, files, options) {
-    return this.request("PATCH", path, this.#fileForm(payload, files), options);
+    const stored = await this.#store.getBucket(currentKey);
+    const bucket = stored ? { ...stored } : { remaining: 1, resetAt: 0 };
+    const windowActive = this.#concurrent && !!stored && stored.resetAt > Date.now();
+    const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
+    const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
+    const reset = Number(response.headers.get("X-RateLimit-Reset"));
+    if (Number.isFinite(remaining))
+      bucket.remaining = Math.max(0, remaining);
+    if (Number.isFinite(resetAfter))
+      bucket.resetAt = Date.now() + Math.max(0, resetAfter) * 1000;
+    else if (Number.isFinite(reset))
+      bucket.resetAt = reset * 1000;
+    if (windowActive && stored) {
+      bucket.remaining = Math.min(bucket.remaining, stored.remaining);
+      bucket.resetAt = Math.max(bucket.resetAt, stored.resetAt);
+    }
+    if (response.status === 429) {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      if (Number.isFinite(retryAfter))
+        bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
+    }
+    await this.#store.updateBucket(currentKey, bucket);
+    if (response.headers.get("X-RateLimit-Global") === "true") {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      if (Number.isFinite(retryAfter))
+        await this.noteGlobalReset(Date.now() + retryAfter * 1000);
+    }
+    return currentKey;
   }
-  async#wait(bucket, signal, path) {
-    const delay = bucket.resetAt - Date.now();
-    if (bucket.remaining <= 0 && delay > 0)
-      await this.#sleep(delay, signal, path);
+}
+
+// packages/rest/src/transport.ts
+class TransportError extends Error {
+  timedOut;
+  constructor(message, timedOut, cause) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "TransportError";
+    this.timedOut = timedOut;
   }
-  async#waitGlobal(signal, path) {
-    const delay = this.#globalResetAt - Date.now();
-    if (delay > 0)
-      await this.#sleep(delay, signal, path);
+}
+
+class HttpTransport {
+  #baseURL;
+  #timeout;
+  #fetch;
+  constructor(options = {}) {
+    this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    this.#timeout = Math.max(1, options.timeout ?? 15000);
+    this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
   }
-  async#sleep(delay, signal, path) {
-    if (delay <= 0)
-      return;
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(resolve, delay);
-      const abort = () => {
-        clearTimeout(timer);
-        reject(this.#abortError(path, signal?.reason));
-      };
-      if (signal?.aborted)
-        return abort();
-      signal?.addEventListener("abort", abort, { once: true });
-    });
+  get baseURL() {
+    return this.#baseURL;
   }
-  async#abortable(promise, signal, path) {
-    if (!signal)
-      return promise;
-    if (signal.aborted)
-      throw this.#abortError(path, signal.reason);
-    return Promise.race([
-      promise,
-      new Promise((_, reject) => signal.addEventListener("abort", () => reject(this.#abortError(path, signal.reason)), { once: true }))
-    ]);
+  get timeout() {
+    return this.#timeout;
   }
-  #abortError(path, reason) {
-    return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+  async send(request) {
+    if (request.signal?.aborted)
+      throw abortError(request.path, request.signal.reason);
+    const controller = new AbortController;
+    const onAbort = () => controller.abort(request.signal?.reason);
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
+    try {
+      return await this.#fetch(`${this.#baseURL}${request.path}`, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof RESTError)
+        throw error;
+      const timedOut = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
+      throw new TransportError(timedOut ? `Discord REST request timed out after ${this.#timeout}ms` : "Discord REST request failed", timedOut, error);
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", onAbort);
+    }
   }
-  async#readPayload(response) {
+}
+
+// packages/rest/src/decoder.ts
+class ResponseDecoder {
+  async read(response) {
     if (response.status === 204)
       return;
     const contentType = response.headers.get("content-type") ?? "";
@@ -1067,7 +1306,7 @@ class REST {
       return;
     });
   }
-  #errorData(payload) {
+  errorData(payload) {
     if (!payload || typeof payload !== "object")
       return {};
     const data = payload;
@@ -1078,46 +1317,310 @@ class REST {
       global: data.global === true
     };
   }
-  #retryAfter(response, data) {
-    const header = Number(response.headers.get("Retry-After"));
+  retryAfter(response, data) {
+    const raw = response.headers.get("Retry-After");
+    const header = raw === null ? Number.NaN : Number(raw);
     const retryAfter = data.retry_after ?? (Number.isFinite(header) ? header : 1);
     return Math.max(0, retryAfter);
   }
-  #normalizeRoute(path) {
-    const queryIndex = path.indexOf("?");
-    const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
-    return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
+}
+
+// packages/rest/src/routes.ts
+var Routes = {
+  user: () => "/users/@me",
+  userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
+  guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
+  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
+  guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
+  guildInvites: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/invites`,
+  guildChannels: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/channels`,
+  guildMember: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}`,
+  guildRoles: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles`,
+  guildRole: (guildId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles/${snowflake(roleId, "Role ID")}`,
+  guildMemberRole: (guildId, userId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}/roles/${snowflake(roleId, "Role ID")}`,
+  guildBans: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans`,
+  guildBan: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans/${snowflake(userId, "User ID")}`,
+  channel: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}`,
+  channelMessages: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages`,
+  message: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/${snowflake(messageId, "Message ID")}`,
+  crosspostMessage: (channelId, messageId) => `${Routes.message(channelId, messageId)}/crosspost`,
+  messageReactions: (channelId, messageId, emoji) => `${Routes.message(channelId, messageId)}/reactions/${encodeURIComponent(emoji)}`,
+  messageReactionsAll: (channelId, messageId) => `${Routes.message(channelId, messageId)}/reactions`,
+  channelPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/pins`,
+  channelPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/pins/${snowflake(messageId, "Message ID")}`,
+  messageThread: (channelId, messageId) => `${Routes.message(channelId, messageId)}/threads`,
+  channelBulkDelete: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/bulk-delete`,
+  channelWebhooks: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/webhooks`,
+  channelInvites: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/invites`,
+  webhook: (webhookId, token) => `/webhooks/${snowflake(webhookId, "Webhook ID")}${token ? `/${encodeURIComponent(token)}` : ""}`,
+  webhookMessage: (webhookId, token, messageId) => `/webhooks/${snowflake(webhookId, "Webhook ID")}/${encodeURIComponent(token)}/messages/${snowflake(messageId, "Message ID")}`,
+  applicationCommands: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/commands`,
+  applicationCommand: (applicationId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/commands/${snowflake(commandId, "Command ID")}`,
+  guildApplicationCommands: (applicationId, guildId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands`,
+  guildApplicationCommand: (applicationId, guildId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands/${snowflake(commandId, "Command ID")}`,
+  interactionCallback: (interactionId, token) => `/interactions/${snowflake(interactionId, "Interaction ID")}/${encodeURIComponent(token)}/callback`,
+  interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
+  channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
+  channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
+  threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
+  guildScheduledEvents: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events`,
+  guildScheduledEvent: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}`,
+  guildScheduledEventUsers: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}/users`,
+  channelPermission: (channelId, overwriteId) => `/channels/${snowflake(channelId, "Channel ID")}/permissions/${snowflake(overwriteId, "Overwrite ID")}`,
+  guildAutoModerationRules: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules`,
+  guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
+  voiceRegions: () => "/voice/regions",
+  gateway: () => "/gateway",
+  gatewayBot: () => "/gateway/bot",
+  guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
+  guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
+  guildWelcomeScreen: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/welcome-screen`,
+  guildOnboarding: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/onboarding`,
+  guildPrune: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/prune`,
+  stageInstances: () => "/stage-instances",
+  stageInstanceByChannel: (channelId) => `/stage-instances/${snowflake(channelId, "Channel ID")}`,
+  invite: (code) => `/invites/${encodeURIComponent(code)}`,
+  guildVanity: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/vanity-url`,
+  guildEmoji: (guildId, emojiId) => emojiId ? `/guilds/${snowflake(guildId, "Guild ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/emojis`,
+  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`
+};
+function snowflake(value, field) {
+  if (!/^\d{1,20}$/.test(value))
+    throw new TypeError(`${field} must be a valid Discord snowflake.`);
+  return value;
+}
+
+// packages/rest/src/index.ts
+var LIBRARY_VERSION = package_default.version;
+var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
+var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
+var REQUEST_DATA_KEYS = new Set([
+  "body",
+  "files",
+  "query",
+  "headers",
+  "reason",
+  "auth",
+  "signal"
+]);
+function isRequestData(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData)
+    return false;
+  if (value instanceof Blob || value instanceof Uint8Array || value instanceof ArrayBuffer)
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return false;
+  return keys.every((key) => REQUEST_DATA_KEYS.has(key));
+}
+function createRetryPolicy(maxRetries = 2) {
+  if (!Number.isFinite(maxRetries) || maxRetries < 0)
+    throw new TypeError("maxRetries must be a non-negative finite number.");
+  return {
+    maxRetries: Math.floor(maxRetries),
+    shouldRetry(method, status) {
+      const normalized = method.toUpperCase();
+      const idempotent = ["GET", "HEAD", "PUT", "DELETE"].includes(normalized);
+      if (status === 0)
+        return idempotent;
+      return status === 429 || status >= 500 && status <= 599 && idempotent;
+    },
+    getDelay(attempt, retryAfter) {
+      if (retryAfter !== undefined)
+        return Math.max(0, retryAfter * 1000);
+      return Math.min(1e4, 500 * 2 ** attempt) + Math.random() * 250;
+    }
+  };
+}
+
+class REST {
+  #retryPolicy;
+  #token;
+  #limiter;
+  #scheduler = new RequestScheduler;
+  #transport;
+  #decoder = new ResponseDecoder;
+  #hooks = {};
+  #concurrentBuckets;
+  constructor(options = {}) {
+    this.#token = options.token;
+    this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
+    this.#transport = options.transport ?? new HttpTransport({
+      baseURL: options.baseURL,
+      timeout: options.timeout
+    });
+    const store = options.store ?? new MemoryRateLimitStore;
+    this.#concurrentBuckets = (options.concurrentBuckets ?? false) && typeof store.reserve === "function";
+    this.#limiter = new RateLimiter(store, {
+      concurrent: this.#concurrentBuckets
+    });
+    if (options.hooks)
+      this.#hooks = options.hooks;
   }
-  #update(response, bucket, route, bucketKey) {
-    const serverBucket = response.headers.get("X-RateLimit-Bucket");
-    if (serverBucket) {
-      this.#routeBuckets.set(route, serverBucket);
-      if (serverBucket !== bucketKey) {
-        const shared = this.#buckets.get(serverBucket) ?? bucket;
-        this.#buckets.set(serverBucket, shared);
-        bucket = shared;
+  get store() {
+    return this.#limiter.store;
+  }
+  setHooks(hooks) {
+    this.#hooks = hooks;
+    return this;
+  }
+  setToken(token) {
+    if (!token.trim())
+      throw new TypeError("A Discord bot token is required.");
+    this.#token = token;
+  }
+  async request(method, path, body, options = {}) {
+    if (!method.toUpperCase())
+      throw new TypeError("REST method is required.");
+    if (!path.startsWith("/"))
+      throw new TypeError("REST paths must start with '/'.");
+    const route = createRouteKey(method, path);
+    const files = options.files;
+    if (files && files.length > 0 && !(body instanceof FormData))
+      body = this.#fileForm(body, files);
+    const query = serializeQuery(options.query);
+    const requestPath = query ? `${path}${query}` : path;
+    return this.#scheduler.runResolved(() => this.#limiter.resolveBucketKey(route.route, route.major), options.signal, path, (bucketKey, release) => this.#attempts(route, requestPath, body, options, bucketKey, release));
+  }
+  async#attempts(route, requestPath, body, options, initialBucketKey, release) {
+    const { method, path } = route;
+    let bucketKey = initialBucketKey;
+    for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
+      await this.#limiter.acquire(bucketKey, options.signal, path);
+      if (this.#concurrentBuckets) {
+        const bucket = await this.#limiter.store.getBucket(bucketKey);
+        if (bucket && bucket.resetAt > Date.now())
+          release();
       }
+      this.#emit(this.#hooks.onRequest, { method, path, attempt });
+      const requestStart = Date.now();
+      let response;
+      try {
+        response = await this.#transport.send({
+          method,
+          path: requestPath,
+          headers: this.#headers(body, options),
+          body: this.#encodeBody(body),
+          signal: options.signal
+        });
+      } catch (error) {
+        if (error instanceof RESTError)
+          throw error;
+        if (options.signal?.aborted)
+          throw abortError(path, options.signal.reason);
+        const failure = error instanceof TransportError ? error : new TransportError("Discord REST request failed", false, error);
+        if (!failure.timedOut && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, 0)) {
+          await sleep(this.#retryPolicy.getDelay(attempt), options.signal, path);
+          continue;
+        }
+        throw new RESTError(failure.message, 0, undefined, undefined, {
+          method,
+          path,
+          cause: failure.cause ?? failure
+        });
+      }
+      this.#emit(this.#hooks.onResponse, {
+        method,
+        path,
+        status: response.status,
+        durationMs: Date.now() - requestStart
+      });
+      bucketKey = await this.#limiter.applyResponse(response, bucketKey, route.route, route.major);
+      const payload = await this.#decoder.read(response);
+      if (response.ok)
+        return response.status === 204 ? undefined : payload;
+      const data = this.#decoder.errorData(payload);
+      const retryAfter = response.status === 429 ? this.#decoder.retryAfter(response, data) : undefined;
+      if (data.global && retryAfter !== undefined)
+        await this.#limiter.noteGlobalReset(Date.now() + retryAfter * 1000);
+      if (response.status === 429)
+        this.#emit(this.#hooks.onRateLimit, {
+          method,
+          path,
+          retryAfterMs: (retryAfter ?? 1) * 1000,
+          global: data.global ?? false,
+          bucket: await this.#limiter.store.getBucketHash(route.route)
+        });
+      if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, response.status)) {
+        const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
+        this.#emit(this.#hooks.onRetry, {
+          method,
+          path,
+          attempt,
+          status: response.status,
+          delayMs: delay
+        });
+        await sleep(delay, options.signal, path);
+        continue;
+      }
+      throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method, path });
     }
-    const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
-    const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
-    const reset = Number(response.headers.get("X-RateLimit-Reset"));
-    if (Number.isFinite(remaining))
-      bucket.remaining = Math.max(0, remaining);
-    if (Number.isFinite(resetAfter))
-      bucket.resetAt = Date.now() + Math.max(0, resetAfter) * 1000;
-    else if (Number.isFinite(reset))
-      bucket.resetAt = reset * 1000;
-    if (response.status === 429) {
-      const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
-    }
-    if (response.headers.get("X-RateLimit-Global") === "true") {
-      const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        this.#globalResetAt = Math.max(this.#globalResetAt, Date.now() + retryAfter * 1000);
+    throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method, path });
+  }
+  #headers(body, options) {
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    const headers = { ...options.headers };
+    if (options.auth !== false && this.#token)
+      headers["Authorization"] = `Bot ${this.#token}`;
+    headers["User-Agent"] = USER_AGENT;
+    if (options.reason !== undefined)
+      headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+    if (!isFormData)
+      headers["Content-Type"] = "application/json";
+    return headers;
+  }
+  #encodeBody(body) {
+    if (typeof FormData !== "undefined" && body instanceof FormData)
+      return body;
+    return body === undefined ? undefined : JSON.stringify(body);
+  }
+  #dispatch(method, path, bodyOrOptions, options) {
+    if (options === undefined && isRequestData(bodyOrOptions))
+      return this.request(method, path, bodyOrOptions.body, bodyOrOptions);
+    return this.request(method, path, bodyOrOptions, options);
+  }
+  get(path, options) {
+    return this.request("GET", path, options?.body, options);
+  }
+  post(path, body, options) {
+    return this.#dispatch("POST", path, body, options);
+  }
+  patch(path, body, options) {
+    return this.#dispatch("PATCH", path, body, options);
+  }
+  put(path, body, options) {
+    return this.#dispatch("PUT", path, body, options);
+  }
+  delete(path, options) {
+    return this.request("DELETE", path, options?.body, options);
+  }
+  #fileForm(payload, files) {
+    const form = new FormData;
+    form.append("payload_json", JSON.stringify(payload));
+    for (let i = 0;i < files.length; i++) {
+      const file = files[i];
+      const blob = file.data instanceof Blob ? file.data : new Blob([file.data], {
+        type: file.contentType ?? "application/octet-stream"
+      });
+      form.append(`files[${i}]`, blob, file.name);
     }
-    return bucket;
+    return form;
+  }
+  postWithFiles(path, payload, files, options) {
+    return this.request("POST", path, this.#fileForm(payload, files), options);
+  }
+  patchWithFiles(path, payload, files, options) {
+    return this.request("PATCH", path, this.#fileForm(payload, files), options);
+  }
+  #emit(hook, ctx) {
+    if (!hook)
+      return;
+    Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
 }
 
@@ -1240,6 +1743,18 @@ class Channel extends BaseStructure {
   update(options) {
     return this.edit(options);
   }
+  isThread() {
+    return this.type === 10 || this.type === 11 || this.type === 12;
+  }
+  isTextBased() {
+    return [0, 1, 2, 3, 5, 10, 11, 12, 13].includes(this.type);
+  }
+  isVoiceBased() {
+    return this.type === 2 || this.type === 13;
+  }
+  isDMBased() {
+    return this.type === 1 || this.type === 3;
+  }
   toString() {
     return `<#${this.id}>`;
   }
@@ -1263,6 +1778,13 @@ class Guild extends BaseStructure {
   vanityUrlCode;
   nsfwLevel;
   discoverySplash;
+  rulesChannelId;
+  systemChannelId;
+  systemChannelFlags;
+  maxMembers;
+  mfaLevel;
+  explicitContentFilter;
+  defaultMessageNotifications;
   constructor(data) {
     super(data.id);
     if (!data.name)
@@ -1284,6 +1806,14 @@ class Guild extends BaseStructure {
     this.vanityUrlCode = data.vanity_url_code ?? null;
     this.nsfwLevel = data.nsfw_level ?? 0;
     this.discoverySplash = data.discovery_splash ?? null;
+    const d = data;
+    this.rulesChannelId = d.rules_channel_id ?? null;
+    this.systemChannelId = d.system_channel_id ?? null;
+    this.systemChannelFlags = d.system_channel_flags ?? 0;
+    this.maxMembers = d.max_members ?? 0;
+    this.mfaLevel = d.mfa_level ?? 0;
+    this.explicitContentFilter = d.explicit_content_filter ?? 0;
+    this.defaultMessageNotifications = d.default_message_notifications ?? 0;
   }
   iconURL(options = {}) {
     if (!this.icon)
@@ -1305,12 +1835,27 @@ class Guild extends BaseStructure {
       return null;
     return cdnURL(`/discovery-splashes/${this.id}`, this.discoverySplash, options);
   }
+  widgetImageURL(style = "shield") {
+    return `https://discord.com/api/guilds/${this.id}/widget.png?style=${style}`;
+  }
   hasFeature(feature) {
     return this.features.includes(feature);
   }
   get isCommunity() {
     return this.hasFeature("COMMUNITY");
   }
+  get isPartnered() {
+    return this.hasFeature("PARTNERED");
+  }
+  get isVerified() {
+    return this.hasFeature("VERIFIED");
+  }
+  get isBoosted() {
+    return this.premiumSubscriptionCount > 0;
+  }
+  get boostLevel() {
+    return this.premiumTier;
+  }
   get hasVanityUrl() {
     return this.vanityUrlCode !== null;
   }
@@ -1321,66 +1866,158 @@ class Guild extends BaseStructure {
     return this.name;
   }
 }
-// packages/structures/src/permissions.ts
-var Permissions2 = {
-  CreateInstantInvite: 1n << 0n,
-  KickMembers: 1n << 1n,
-  BanMembers: 1n << 2n,
-  Administrator: 1n << 3n,
-  ManageChannels: 1n << 4n,
-  ManageGuild: 1n << 5n,
-  AddReactions: 1n << 6n,
-  ViewAuditLog: 1n << 7n,
-  PrioritySpeaker: 1n << 8n,
-  Stream: 1n << 9n,
-  ViewChannel: 1n << 10n,
-  SendMessages: 1n << 11n,
-  SendTTSMessages: 1n << 12n,
-  ManageMessages: 1n << 13n,
-  EmbedLinks: 1n << 14n,
-  AttachFiles: 1n << 15n,
-  ReadMessageHistory: 1n << 16n,
-  MentionEveryone: 1n << 17n,
-  UseExternalEmojis: 1n << 18n,
-  ViewGuildInsights: 1n << 19n,
-  Connect: 1n << 20n,
-  Speak: 1n << 21n,
-  MuteMembers: 1n << 22n,
-  DeafenMembers: 1n << 23n,
-  MoveMembers: 1n << 24n,
-  UseVAD: 1n << 25n,
-  ChangeNickname: 1n << 26n,
-  ManageNicknames: 1n << 27n,
-  ManageRoles: 1n << 28n,
-  ManageWebhooks: 1n << 29n,
-  ManageGuildExpressions: 1n << 30n,
-  UseApplicationCommands: 1n << 31n,
-  RequestToSpeak: 1n << 32n,
-  ManageEvents: 1n << 33n,
-  ManageThreads: 1n << 34n,
-  CreatePublicThreads: 1n << 35n,
-  CreatePrivateThreads: 1n << 36n,
-  UseExternalStickers: 1n << 37n,
-  SendMessagesInThreads: 1n << 38n,
-  UseEmbeddedActivities: 1n << 39n,
-  ModerateMembers: 1n << 40n,
-  ViewCreatorMonetizationAnalytics: 1n << 41n,
-  UseSoundboard: 1n << 42n,
-  CreateGuildExpressions: 1n << 43n,
-  CreateEvents: 1n << 44n,
-  UseExternalSounds: 1n << 45n,
-  SendVoiceMessages: 1n << 46n,
-  SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
-};
-// packages/structures/src/interactions.ts
-var InteractionType = {
-  Ping: 1,
-  ApplicationCommand: 2,
-  MessageComponent: 3,
-  ApplicationCommandAutocomplete: 4,
-  ModalSubmit: 5
-};
+// packages/structures/src/resources.ts
+class TextChannel extends Channel {
+  constructor(data, context) {
+    super(data, context);
+  }
+  toString() {
+    return `<#${this.id}>`;
+  }
+}
+class AutoModerationRule extends BaseStructure {
+  guildId;
+  name;
+  creatorId;
+  eventType;
+  triggerType;
+  triggerMetadata;
+  actions;
+  enabled;
+  exemptRoles;
+  exemptChannels;
+  constructor(data) {
+    super(data.id);
+    if (!/^\d{1,20}$/.test(data.guild_id))
+      throw new TypeError("AutoModerationRule guild_id must be a valid snowflake.");
+    this.guildId = data.guild_id;
+    this.name = data.name;
+    this.creatorId = data.creator_id;
+    this.eventType = data.event_type;
+    this.triggerType = data.trigger_type;
+    this.triggerMetadata = data.trigger_metadata;
+    this.actions = data.actions;
+    this.enabled = data.enabled;
+    this.exemptRoles = data.exempt_roles;
+    this.exemptChannels = data.exempt_channels;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      guildId: this.guildId,
+      name: this.name,
+      creatorId: this.creatorId,
+      eventType: this.eventType,
+      triggerType: this.triggerType,
+      triggerMetadata: this.triggerMetadata,
+      actions: this.actions,
+      enabled: this.enabled,
+      exemptRoles: this.exemptRoles,
+      exemptChannels: this.exemptChannels
+    };
+  }
+}
+// packages/structures/src/channels.ts
+class NewsChannel extends TextChannel {
+}
+
+class DMChannel extends Channel {
+  recipients;
+  ownerId;
+  constructor(data, context) {
+    super(data, context);
+    this.recipients = (data.recipients ?? []).map((u) => new User(u));
+    this.ownerId = data.owner_id ?? null;
+  }
+}
+
+class VoiceChannel extends Channel {
+  bitrate;
+  userLimit;
+  rtcRegion;
+  videoQualityMode;
+  constructor(data, context) {
+    super(data, context);
+    this.bitrate = data.bitrate ?? 64000;
+    this.userLimit = data.user_limit ?? 0;
+    this.rtcRegion = data.rtc_region ?? null;
+    this.videoQualityMode = data.video_quality_mode ?? 1;
+  }
+}
+
+class StageChannel extends VoiceChannel {
+}
+
+class CategoryChannel extends Channel {
+}
+
+class ThreadChannel extends Channel {
+  ownerId;
+  messageCount;
+  memberCount;
+  metadata;
+  constructor(data, context) {
+    super(data, context);
+    this.ownerId = data.owner_id ?? null;
+    this.messageCount = data.message_count ?? 0;
+    this.memberCount = data.member_count ?? 0;
+    this.metadata = data.thread_metadata ?? null;
+  }
+  get archived() {
+    return this.metadata?.archived ?? false;
+  }
+  get locked() {
+    return this.metadata?.locked ?? false;
+  }
+  get autoArchiveDuration() {
+    return this.metadata?.auto_archive_duration ?? null;
+  }
+}
+
+class ForumChannel extends Channel {
+  availableTags;
+  defaultReactionEmoji;
+  defaultThreadRateLimitPerUser;
+  defaultAutoArchiveDuration;
+  constructor(data, context) {
+    super(data, context);
+    this.availableTags = data.available_tags ?? [];
+    this.defaultReactionEmoji = data.default_reaction_emoji ?? null;
+    this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user ?? 0;
+    this.defaultAutoArchiveDuration = data.default_auto_archive_duration ?? null;
+  }
+}
+
+class MediaChannel extends ForumChannel {
+}
+function createChannel(data, context) {
+  switch (data.type) {
+    case 0:
+      return new TextChannel(data, context);
+    case 1:
+    case 3:
+      return new DMChannel(data, context);
+    case 2:
+      return new VoiceChannel(data, context);
+    case 4:
+      return new CategoryChannel(data, context);
+    case 5:
+      return new NewsChannel(data, context);
+    case 10:
+    case 11:
+    case 12:
+      return new ThreadChannel(data, context);
+    case 13:
+      return new StageChannel(data, context);
+    case 15:
+      return new ForumChannel(data, context);
+    case 16:
+      return new MediaChannel(data, context);
+    default:
+      return new Channel(data, context);
+  }
+}
+// packages/structures/src/options.ts
 var OptionType = {
   SubCommand: 1,
   SubCommandGroup: 2,
@@ -1436,6 +2073,12 @@ class CommandOptions {
     }
     return this.#subcommandGroup;
   }
+  getFocused(full = false) {
+    const focused = this.#options.find((o) => o.focused);
+    if (!focused)
+      throw new TypeError("No focused option was provided.");
+    return full ? focused : focused.value ?? "";
+  }
   getString(name, required = false) {
     const opt = this.#get(name);
     if (!opt || opt.type !== OptionType.String) {
@@ -1541,6 +2184,14 @@ class CommandOptions {
     return this.#options;
   }
 }
+// packages/structures/src/interactions.ts
+var InteractionType = {
+  Ping: 1,
+  ApplicationCommand: 2,
+  MessageComponent: 3,
+  ApplicationCommandAutocomplete: 4,
+  ModalSubmit: 5
+};
 
 class InteractionResponse {
   type;
@@ -1604,6 +2255,30 @@ class Interaction {
   isAutocomplete() {
     return this.type === InteractionType.ApplicationCommandAutocomplete;
   }
+  #componentType() {
+    return this.isMessageComponent() ? this.data.data?.component_type ?? 0 : 0;
+  }
+  isButton() {
+    return this.#componentType() === 2;
+  }
+  isStringSelectMenu() {
+    return this.#componentType() === 3;
+  }
+  isUserSelectMenu() {
+    return this.#componentType() === 5;
+  }
+  isRoleSelectMenu() {
+    return this.#componentType() === 6;
+  }
+  isMentionableSelectMenu() {
+    return this.#componentType() === 7;
+  }
+  isChannelSelectMenu() {
+    return this.#componentType() === 8;
+  }
+  isAnySelectMenu() {
+    return [3, 5, 6, 7, 8].includes(this.#componentType());
+  }
   assertUnacknowledged() {
     if (this.replied || this.deferred)
       throw new Error("Interaction has already been acknowledged.");
@@ -1663,8 +2338,7 @@ class CommandInteraction extends Interaction {
     super(client, data);
     const rawOptions = data.data?.options ?? [];
     const resolved = data.data?.resolved ?? {};
-    const sub = rawOptions.find((o) => o.type === 1 || o.type === 2);
-    this.options = new CommandOptions(sub?.options ?? rawOptions, resolved);
+    this.options = new CommandOptions(rawOptions, resolved);
   }
 }
 
@@ -1715,6 +2389,11 @@ class ModalSubmitInteraction extends Interaction {
 }
 
 class AutocompleteInteraction extends Interaction {
+  options;
+  constructor(client, data) {
+    super(client, data);
+    this.options = new CommandOptions(data.data?.options ?? []);
+  }
   get commandName() {
     return this.data?.data?.name ?? "";
   }
@@ -1758,6 +2437,8 @@ function createInteraction(client, data) {
 }
 
 // packages/structures/src/index.ts
+var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
+
 class Message extends BaseStructure {
   content;
   author;
@@ -1803,6 +2484,12 @@ class Message extends BaseStructure {
   get embedsSuppressed() {
     return (this.flags & 4) !== 0;
   }
+  get createdTimestamp() {
+    return this.timestamp.getTime();
+  }
+  get createdAt() {
+    return this.timestamp;
+  }
   edit(options) {
     if (!this.#context)
       throw new Error("This message is not attached to a client.");
@@ -1857,6 +2544,51 @@ class Message extends BaseStructure {
       throw new Error("This message is not attached to a client.");
     return this.#context.unpinMessage(this.channelId, this.id);
   }
+  get isEphemeral() {
+    return (this.flags & 64) !== 0;
+  }
+  get isPinned() {
+    return this.pinned;
+  }
+  get isSystemMessage() {
+    return !NON_SYSTEM_MESSAGE_TYPES.has(this.type);
+  }
+  get isCrosspost() {
+    return (this.flags & 2) !== 0;
+  }
+  get hasAttachments() {
+    return this.attachments.length > 0;
+  }
+  get hasEmbeds() {
+    return this.embeds.length > 0;
+  }
+  get hasComponents() {
+    return this.components.length > 0;
+  }
+  suppressEmbeds() {
+    return this.edit({ flags: this.flags | 4 });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      content: this.content,
+      channelId: this.channelId,
+      guildId: this.guildId,
+      flags: this.flags,
+      pinned: this.pinned,
+      mentionEveryone: this.mentionEveryone,
+      type: this.type,
+      timestamp: this.timestamp.toISOString(),
+      author: { id: this.author.id, username: this.author.username },
+      attachments: [...this.attachments],
+      embeds: [...this.embeds],
+      components: [...this.components],
+      mentions: this.mentions.map((u) => u.id),
+      mentionRoles: [...this.mentionRoles],
+      reference: this.reference,
+      referencedMessage: this.referencedMessage ? this.referencedMessage.id : this.referencedMessage
+    };
+  }
 }
 
 // packages/managers/src/message.ts
@@ -1919,7 +2651,7 @@ class ThreadManager {
       auto_archive_duration: options.autoArchiveDuration,
       rate_limit_per_user: options.rateLimitPerUser
     });
-    return new Channel(data, this.#context);
+    return createChannel(data, this.#context);
   }
 }
 
@@ -1947,13 +2679,173 @@ 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))
+    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(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 create(userId, options = {}) {
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+  }
+  async remove(userId, reason) {
+    await this.#rest.delete(Routes.guildBan(this.guildId, userId), {
+      reason
+    });
+    this.delete(userId);
+  }
+}
+
+class GuildScheduledEventManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(event) {
+    this.set(event.id, event);
+    return event;
+  }
+  async fetch(eventId, options = {}) {
+    return this.#store(await this.#rest.get(withQuery(Routes.guildScheduledEvent(this.guildId, eventId), {
+      with_user_count: options.withUserCount
+    })));
+  }
+  async fetchAll(options = {}) {
+    const events = await this.#rest.get(withQuery(Routes.guildScheduledEvents(this.guildId), {
+      with_user_count: options.withUserCount
+    }));
+    return events.map((event) => this.#store(event));
+  }
+  async create(options, reason) {
+    return this.#store(await this.#rest.post(Routes.guildScheduledEvents(this.guildId), options, { reason }));
+  }
+  async edit(eventId, options, reason) {
+    return this.#store(await this.#rest.patch(Routes.guildScheduledEvent(this.guildId, eventId), options, { reason }));
+  }
+  async remove(eventId) {
+    await this.#rest.delete(Routes.guildScheduledEvent(this.guildId, eventId));
+    this.delete(eventId);
+  }
+  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), {
+      limit,
+      with_member: options.withMember,
+      before: options.before,
+      after: options.after
+    }));
+  }
+}
+
+class StageInstanceManager extends Manager {
+  #rest;
+  constructor(rest) {
+    super();
+    this.#rest = rest;
+  }
+  #store(stage) {
+    this.set(stage.channel_id, stage);
+    return stage;
+  }
+  async create(channelId, options, reason) {
+    return this.#store(await this.#rest.post(Routes.stageInstances(), {
+      channel_id: channelId,
+      topic: options.topic,
+      privacy_level: options.privacyLevel,
+      send_start_notification: options.sendStartNotification,
+      guild_scheduled_event_id: options.guildScheduledEventId
+    }, { reason }));
+  }
+  async fetch(channelId) {
+    return this.#store(await this.#rest.get(Routes.stageInstanceByChannel(channelId)));
+  }
+  async edit(channelId, options, reason) {
+    return this.#store(await this.#rest.patch(Routes.stageInstanceByChannel(channelId), { topic: options.topic, privacy_level: options.privacyLevel }, { reason }));
+  }
+  async remove(channelId, reason) {
+    await this.#rest.delete(Routes.stageInstanceByChannel(channelId), {
+      reason
+    });
+    this.delete(channelId);
+  }
+}
+
+class PermissionOverwriteManager {
+  #rest;
+  channelId;
+  constructor(rest, channelId) {
+    this.#rest = rest;
+    this.channelId = channelId;
+  }
+  async edit(overwriteId, options, reason) {
+    await this.#rest.put(Routes.channelPermission(this.channelId, overwriteId), {
+      type: options.type,
+      allow: BigInt(options.allow ?? 0).toString(),
+      deny: BigInt(options.deny ?? 0).toString()
+    }, { reason });
+  }
+  async remove(overwriteId, reason) {
+    await this.#rest.delete(Routes.channelPermission(this.channelId, overwriteId), { reason });
+  }
+}
+
 // packages/managers/src/guild.ts
+function withQuery2(path, params) {
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
 class GuildManager extends ResourceManager {
   #rest;
+  #bans = new Map;
+  #scheduledEvents = new Map;
   constructor(rest) {
     super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
     this.#rest = rest;
   }
+  bans(guildId) {
+    let manager = this.#bans.get(guildId);
+    if (!manager)
+      this.#bans.set(guildId, manager = new GuildBanManager(this.#rest, guildId));
+    return manager;
+  }
+  scheduledEvents(guildId) {
+    let manager = this.#scheduledEvents.get(guildId);
+    if (!manager)
+      this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager(this.#rest, guildId));
+    return manager;
+  }
   async create(options) {
     const data = await this.#rest.post("/guilds", options);
     return this.upsert(new Guild(data));
@@ -1977,6 +2869,47 @@ class GuildManager extends ResourceManager {
   async fetchInvites(id) {
     return this.#rest.get(Routes.guildInvites(id));
   }
+  async fetchAuditLog(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.userId)
+      params.set("user_id", options.userId);
+    if (options.actionType !== undefined)
+      params.set("action_type", String(options.actionType));
+    if (options.before)
+      params.set("before", options.before);
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    return this.#rest.get(withQuery2(Routes.guildAuditLog(guildId), params));
+  }
+  async fetchMembers(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
+    if (options.after)
+      params.set("after", options.after);
+    return this.#rest.get(withQuery2(Routes.guildMembers(guildId), params));
+  }
+  async fetchAutoModerationRules(guildId) {
+    const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
+    return rules.map((r) => new AutoModerationRule(r));
+  }
+  async fetchAutoModerationRule(guildId, ruleId) {
+    const rule = await this.#rest.get(Routes.guildAutoModerationRule(guildId, ruleId));
+    return new AutoModerationRule(rule);
+  }
+  async createAutoModerationRule(guildId, options) {
+    const rule = await this.#rest.post(Routes.guildAutoModerationRules(guildId), options);
+    return new AutoModerationRule(rule);
+  }
+  async editAutoModerationRule(guildId, ruleId, options) {
+    const rule = await this.#rest.patch(Routes.guildAutoModerationRule(guildId, ruleId), options);
+    return new AutoModerationRule(rule);
+  }
+  async deleteAutoModerationRule(guildId, ruleId) {
+    await this.#rest.delete(Routes.guildAutoModerationRule(guildId, ruleId));
+  }
 }
 // packages/managers/src/application.ts
 class ApplicationCommandManager {
@@ -2049,6 +2982,9 @@ class ChannelManager extends Manager {
     }
     return manager;
   }
+  permissionOverwrites(channelId) {
+    return new PermissionOverwriteManager(this.#rest, channelId);
+  }
   threads(channelId) {
     return new ThreadManager(this.#rest, this.#context, channelId);
   }
@@ -2060,7 +2996,7 @@ class ChannelManager extends Manager {
   }
   upsert(data) {
     const existing = this.get(data.id);
-    const channel = new Channel(data, this.#context);
+    const channel = createChannel(data, this.#context);
     if (existing) {
       Object.assign(existing, channel);
       return existing;
@@ -2079,8 +3015,11 @@ class ChannelManager extends Manager {
   }
   async deleteChannel(channelId) {
     await this.#rest.delete(Routes.channel(channelId));
+    this.delete(channelId);
+  }
+  delete(channelId) {
     this.#messageManagers.delete(channelId);
-    super.delete(channelId);
+    return super.delete(channelId);
   }
   send(channelId, options) {
     return this.messages(channelId).send(options);
@@ -2120,66 +3059,638 @@ class ChannelManager extends Manager {
   deleteCachedMessage(channelId, messageId) {
     return this.messages(channelId).delete(messageId);
   }
-  async crosspostMessage(channelId, messageId) {
-    return this.messages(channelId).upsert(await this.#rest.post(Routes.crosspostMessage(channelId, messageId)));
+  async crosspostMessage(channelId, messageId) {
+    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.");
+    await this.#rest.post(Routes.channelBulkDelete(channelId), {
+      messages: ids
+    });
+    for (const id of ids)
+      this.messages(channelId).delete(id);
+  }
+  async addReaction(channelId, messageId, emoji) {
+    await this.#rest.put(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
+  }
+  async fetchReactions(channelId, messageId, emoji, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.after)
+      params.set("after", options.after);
+    const suffix = params.toString();
+    const data = await this.#rest.get(`${Routes.messageReactions(channelId, messageId, emoji)}${suffix ? `?${suffix}` : ""}`);
+    return data.map((user) => new User(user));
+  }
+  async removeOwnReaction(channelId, messageId, emoji) {
+    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
+  }
+  async removeReaction(channelId, messageId, emoji, userId) {
+    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/${userId}`);
+  }
+  async removeAllReactions(channelId, messageId) {
+    await this.#rest.delete(Routes.messageReactionsAll(channelId, messageId));
+  }
+  async fetchPinnedMessages(channelId) {
+    const data = await this.#rest.get(Routes.channelPins(channelId));
+    return data.map((item) => this.messages(channelId).upsert(item));
+  }
+  async pinMessage(channelId, messageId) {
+    await this.#rest.put(Routes.channelPin(channelId, messageId));
+  }
+  async unpinMessage(channelId, messageId) {
+    await this.#rest.delete(Routes.channelPin(channelId, messageId));
+  }
+  createThreadFromMessage(channelId, messageId, options) {
+    return this.threads(channelId).createFromMessage(messageId, options);
+  }
+  async fetchPage(channelId, options = {}) {
+    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+    const messages = await this.fetchMessages(channelId, {
+      ...options,
+      limit
+    });
+    return {
+      messages,
+      before: messages[0]?.id,
+      after: messages[messages.length - 1]?.id,
+      hasMore: messages.length === limit
+    };
+  }
+  async bulkDelete(channelId, messageIds) {
+    return this.bulkDeleteMessages(channelId, messageIds);
+  }
+  clear() {
+    this.#messageManagers.clear();
+    super.clear();
+  }
+}
+function isMessageQuery(value) {
+  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
+}
+
+// packages/ws/src/session.ts
+class GatewaySession {
+  #state = { status: "none" };
+  #sequence = null;
+  #generation = 0;
+  #lastInvalidation;
+  get lastInvalidation() {
+    return this.#lastInvalidation;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  get sessionId() {
+    return this.#state.status === "established" ? this.#state.sessionId : undefined;
+  }
+  get resumeURL() {
+    return this.#state.status === "established" ? this.#state.resumeURL : undefined;
+  }
+  get sequence() {
+    return this.#sequence;
+  }
+  get canResume() {
+    return this.#state.status === "established" && this.#sequence !== null;
+  }
+  beginConnection() {
+    return ++this.#generation;
+  }
+  owns(token) {
+    return token === this.#generation;
+  }
+  recordSequence(sequence, token) {
+    if (!this.owns(token))
+      return false;
+    if (!Number.isInteger(sequence))
+      return false;
+    this.#sequence = sequence;
+    return true;
+  }
+  activate(payload, token) {
+    if (!this.owns(token))
+      return false;
+    const ready = payload;
+    if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string")
+      return false;
+    this.#state = {
+      status: "established",
+      sessionId: ready.session_id,
+      resumeURL: ready.resume_gateway_url
+    };
+    return true;
+  }
+  invalidate(token, reason = "explicit") {
+    if (!this.owns(token))
+      return false;
+    this.#lastInvalidation = reason;
+    this.#state = { status: "none" };
+    this.#sequence = null;
+    return true;
+  }
+  resumeInfo() {
+    if (this.#state.status !== "established")
+      return;
+    if (this.#sequence === null)
+      return;
+    const { sessionId, resumeURL } = this.#state;
+    return { sessionId, sequence: this.#sequence, resumeURL };
+  }
+  handshake() {
+    const resume = this.resumeInfo();
+    return resume ? { type: "resume", ...resume } : { type: "identify" };
+  }
+  connectURL(fallback) {
+    return this.resumeInfo()?.resumeURL ?? fallback;
+  }
+}
+
+// packages/ws/src/heartbeat.ts
+var MAX_MONITOR_INTERVAL = 1000;
+
+class GatewayHeartbeat {
+  #options;
+  #now;
+  #interval = 0;
+  #acknowledged = true;
+  #sentAt = 0;
+  #latency = -1;
+  #lastMessageAt = 0;
+  #zombieReported = false;
+  #timer;
+  #initialTimer;
+  #ackTimer;
+  #monitorTimer;
+  constructor(options) {
+    if (options.zombieTimeout <= options.ackTimeout)
+      throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
+    this.#options = options;
+    this.#now = options.now ?? (() => Date.now());
+  }
+  get latency() {
+    return this.#latency;
+  }
+  get interval() {
+    return this.#interval;
+  }
+  get acknowledged() {
+    return this.#acknowledged;
+  }
+  get silentFor() {
+    return this.#lastMessageAt === 0 ? 0 : this.#now() - this.#lastMessageAt;
+  }
+  get stalenessDeadline() {
+    return Math.max(this.#options.zombieTimeout, this.#interval + this.#options.ackTimeout);
+  }
+  isHealthy() {
+    if (!this.#acknowledged)
+      return false;
+    if (this.#lastMessageAt === 0)
+      return true;
+    return this.silentFor < this.stalenessDeadline;
+  }
+  watch() {
+    this.#lastMessageAt = this.#now();
+    this.#zombieReported = false;
+    this.#startMonitor();
+  }
+  receivedMessage() {
+    this.#lastMessageAt = this.#now();
+    this.#zombieReported = false;
+  }
+  start(interval) {
+    this.#clearBeatTimers();
+    this.#interval = interval;
+    this.#acknowledged = true;
+    this.#initialTimer = setTimeout(() => this.sendHeartbeat(), Math.random() * interval);
+    this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+  }
+  stop() {
+    this.#clearBeatTimers();
+    if (this.#monitorTimer)
+      clearInterval(this.#monitorTimer);
+    this.#monitorTimer = undefined;
+  }
+  sendHeartbeat() {
+    this.#acknowledged = false;
+    this.#sentAt = this.#now();
+    if (!this.#options.send(this.#options.sequence())) {
+      this.#options.onError(new Error("Unable to send Gateway heartbeat because the WebSocket is not open."));
+      return;
+    }
+    this.#clearAckTimer();
+    this.#ackTimer = setTimeout(() => {
+      if (this.#acknowledged)
+        return;
+      this.#options.onTimeout({
+        type: "ack",
+        elapsedMs: this.#now() - this.#sentAt
+      });
+    }, this.#options.ackTimeout);
+  }
+  acknowledge() {
+    this.#acknowledged = true;
+    this.#latency = this.#now() - this.#sentAt;
+    this.#clearAckTimer();
+  }
+  #startMonitor() {
+    if (this.#monitorTimer)
+      clearInterval(this.#monitorTimer);
+    const interval = Math.max(1, Math.min(MAX_MONITOR_INTERVAL, this.#options.ackTimeout, this.#options.zombieTimeout / 2));
+    this.#monitorTimer = setInterval(() => this.#checkStaleness(), interval);
+  }
+  #checkStaleness() {
+    if (!this.#options.isConnected() || this.#lastMessageAt === 0)
+      return;
+    const silentFor = this.silentFor;
+    const deadline = this.stalenessDeadline;
+    if (silentFor < deadline || this.#zombieReported)
+      return;
+    this.#zombieReported = true;
+    this.#options.onTimeout({ type: "zombie", silentFor, deadline });
+  }
+  #clearAckTimer() {
+    if (this.#ackTimer)
+      clearTimeout(this.#ackTimer);
+    this.#ackTimer = undefined;
+  }
+  #clearBeatTimers() {
+    if (this.#timer)
+      clearInterval(this.#timer);
+    if (this.#initialTimer)
+      clearTimeout(this.#initialTimer);
+    this.#clearAckTimer();
+    this.#timer = undefined;
+    this.#initialTimer = undefined;
   }
-  async bulkDeleteMessages(channelId, messageIds) {
-    const ids = [...messageIds];
-    await this.#rest.post(Routes.channelBulkDelete(channelId), {
-      messages: ids
+}
+
+// packages/ws/src/close-codes.ts
+var GatewayCloseCodes = {
+  UnknownError: 4000,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSeq: 4007,
+  RateLimited: 4008,
+  SessionTimedOut: 4009,
+  InvalidShard: 4010,
+  ShardingRequired: 4011,
+  InvalidAPIVersion: 4012,
+  InvalidIntents: 4013,
+  DisallowedIntents: 4014
+};
+
+// packages/ws/src/reconnect.ts
+var FATAL_CLOSE_CODES = [
+  GatewayCloseCodes.AuthenticationFailed,
+  GatewayCloseCodes.InvalidShard,
+  GatewayCloseCodes.ShardingRequired,
+  GatewayCloseCodes.InvalidAPIVersion,
+  GatewayCloseCodes.InvalidIntents,
+  GatewayCloseCodes.DisallowedIntents
+];
+var IDENTIFY_CLOSE_CODES = [
+  GatewayCloseCodes.InvalidSeq,
+  GatewayCloseCodes.SessionTimedOut
+];
+function classifyCloseCode(code, canResume) {
+  if (FATAL_CLOSE_CODES.includes(code))
+    return "stop";
+  if (IDENTIFY_CLOSE_CODES.includes(code))
+    return "identify";
+  return canResume ? "resume" : "identify";
+}
+
+class GatewayReconnect {
+  #options;
+  #random;
+  #attempt = 0;
+  #timer;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(options) {
+    this.#options = options;
+    this.#random = options.random ?? Math.random;
+  }
+  get enabled() {
+    return this.#options.enabled;
+  }
+  get attempts() {
+    return this.#attempt;
+  }
+  get pending() {
+    return this.#timer !== undefined;
+  }
+  get exhausted() {
+    return this.#attempt >= this.#options.maxAttempts;
+  }
+  get connecting() {
+    return this.#promise !== undefined;
+  }
+  get attemptPromise() {
+    return this.#promise;
+  }
+  classifyClose(code, canResume) {
+    return classifyCloseCode(code, canResume);
+  }
+  canReconnect() {
+    return this.#options.enabled && !this.exhausted;
+  }
+  schedule(run) {
+    if (!this.#options.enabled)
+      return { scheduled: false, reason: "disabled" };
+    if (this.#timer)
+      return { scheduled: false, reason: "pending" };
+    if (this.exhausted)
+      return { scheduled: false, reason: "exhausted" };
+    const attempt = this.#attempt;
+    const delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
+    const jitter = this.#random() * Math.max(1, delay * 0.25);
+    const delayMs = delay + jitter;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      run();
+    }, delayMs);
+    return { scheduled: true, delayMs, attempt };
+  }
+  cancel() {
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+  }
+  reset() {
+    this.#attempt = 0;
+  }
+  attempt(start) {
+    if (this.#promise)
+      return this.#promise;
+    this.#promise = new Promise((resolve, reject) => {
+      this.#resolve = resolve;
+      this.#reject = reject;
+      start();
     });
-    for (const id of ids)
-      this.messages(channelId).delete(id);
-  }
-  async addReaction(channelId, messageId, emoji) {
-    await this.#rest.put(Routes.messageReactions(channelId, messageId, emoji));
+    return this.#promise;
+  }
+  settle(error) {
+    const resolve = this.#resolve;
+    const reject = this.#reject;
+    this.#resolve = undefined;
+    this.#reject = undefined;
+    this.#promise = undefined;
+    if (error)
+      reject?.(error);
+    else
+      resolve?.();
   }
-  async fetchReactions(channelId, messageId, emoji, options = {}) {
-    const params = new URLSearchParams;
-    if (options.limit !== undefined)
-      params.set("limit", String(options.limit));
-    if (options.after)
-      params.set("after", options.after);
-    const suffix = params.toString();
-    const data = await this.#rest.get(`${Routes.messageReactions(channelId, messageId, emoji)}${suffix ? `?${suffix}` : ""}`);
-    return data.map((user) => new User(user));
+}
+
+// packages/ws/src/decoder.ts
+import {
+  createInflate,
+  constants as zlibConstants
+} from "zlib";
+async function toBytes(data) {
+  if (data instanceof Uint8Array)
+    return data;
+  if (data instanceof ArrayBuffer)
+    return new Uint8Array(data);
+  if (typeof Blob !== "undefined" && data instanceof Blob)
+    return new Uint8Array(await data.arrayBuffer());
+  throw new TypeError("Gateway returned an unsupported compressed frame type.");
+}
+
+class PlainTextDecoder {
+  push(data) {
+    return [String(data)];
   }
-  async removeOwnReaction(channelId, messageId, emoji) {
-    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
+  reset() {}
+}
+
+class ZlibStreamDecoder {
+  #create;
+  #inflate;
+  #chunks = [];
+  #failure;
+  #pendingReject;
+  constructor(create = () => createInflate()) {
+    this.#create = create;
+  }
+  push(data) {
+    if (typeof data === "string")
+      return [data];
+    return this.#inflateFrame(data);
+  }
+  async#inflateFrame(data) {
+    const chunk = await toBytes(data);
+    const inflate = this.#inflate ??= this.#open();
+    if (this.#failure)
+      throw this.#failure;
+    const complete = chunk.length >= 4 && chunk[chunk.length - 4] === 0 && chunk[chunk.length - 3] === 0 && chunk[chunk.length - 2] === 255 && chunk[chunk.length - 1] === 255;
+    await this.#awaiting((settle) => inflate.write(chunk, (error) => error ? settle(error) : settle()));
+    if (!complete)
+      return [];
+    await this.#awaiting((settle) => inflate.flush(zlibConstants.Z_SYNC_FLUSH, () => settle()));
+    const parts = this.#chunks;
+    this.#chunks = [];
+    if (parts.length === 0)
+      return [];
+    const total = parts.reduce((size, part) => size + part.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+      merged.set(part, offset);
+      offset += part.length;
+    }
+    return [new TextDecoder().decode(merged)];
+  }
+  reset() {
+    const inflate = this.#inflate;
+    this.#inflate = undefined;
+    this.#chunks = [];
+    this.#failure = undefined;
+    this.#pendingReject = undefined;
+    if (!inflate)
+      return;
+    inflate.removeAllListeners();
+    try {
+      inflate.close();
+    } catch {}
+  }
+  #awaiting(run) {
+    if (this.#failure)
+      return Promise.reject(this.#failure);
+    return new Promise((resolve, reject) => {
+      this.#pendingReject = reject;
+      run((error) => {
+        this.#pendingReject = undefined;
+        if (error)
+          reject(error);
+        else if (this.#failure)
+          reject(this.#failure);
+        else
+          resolve();
+      });
+    });
   }
-  async removeReaction(channelId, messageId, emoji, userId) {
-    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/${userId}`);
+  #open() {
+    const inflate = this.#create();
+    inflate.on("data", (chunk) => this.#chunks.push(chunk));
+    inflate.on("error", (error) => {
+      this.#failure = error;
+      const reject = this.#pendingReject;
+      this.#pendingReject = undefined;
+      reject?.(error);
+    });
+    return inflate;
   }
-  async removeAllReactions(channelId, messageId) {
-    await this.#rest.delete(Routes.messageReactionsAll(channelId, messageId));
+}
+function createDecoder(compress) {
+  return compress ? new ZlibStreamDecoder : new PlainTextDecoder;
+}
+
+// packages/ws/src/transport.ts
+var OPEN = 1;
+
+class WebSocketTransport {
+  #handlers;
+  #decoder;
+  #createSocket;
+  #compress;
+  #socket;
+  #generation = 0;
+  #queue = Promise.resolve();
+  constructor(options) {
+    this.#handlers = options.handlers;
+    this.#compress = options.compress ?? false;
+    this.#decoder = options.decoder ?? createDecoder(options.compress);
+    this.#createSocket = options.createSocket ?? ((url) => new WebSocket(url));
+  }
+  get connected() {
+    return this.#socket?.readyState === OPEN;
+  }
+  get live() {
+    return this.#socket !== undefined && this.#socket.readyState <= OPEN;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  connect(url) {
+    this.#discard(1000, "Superseded by a new connection");
+    const generation = ++this.#generation;
+    this.#decoder.reset();
+    this.#queue = Promise.resolve();
+    let socket;
+    try {
+      socket = this.#createSocket(url);
+    } catch (error) {
+      return { ok: false, error: this.#asError(error) };
+    }
+    if (this.#compress) {
+      try {
+        socket.binaryType = "arraybuffer";
+      } catch {}
+    }
+    this.#socket = socket;
+    socket.addEventListener("open", () => {
+      if (!this.#owns(generation))
+        return;
+      this.#handlers.onOpen();
+    });
+    socket.addEventListener("message", (event) => {
+      if (!this.#owns(generation))
+        return;
+      let decoded;
+      try {
+        decoded = this.#decoder.push(event.data);
+      } catch (error) {
+        this.#handlers.onError(this.#asError(error));
+        return;
+      }
+      if (!(decoded instanceof Promise)) {
+        for (const frame of decoded)
+          this.#handlers.onFrame(frame);
+        return;
+      }
+      this.#queue = this.#queue.then(async () => {
+        const frames = await decoded;
+        if (!this.#owns(generation))
+          return;
+        for (const frame of frames)
+          this.#handlers.onFrame(frame);
+      }).catch((error) => {
+        if (!this.#owns(generation))
+          return;
+        this.#handlers.onError(this.#asError(error));
+      });
+    });
+    socket.addEventListener("close", (event) => {
+      if (!this.#owns(generation))
+        return;
+      this.#socket = undefined;
+      this.#generation++;
+      this.#decoder.reset();
+      this.#handlers.onClose(event.code, event.reason ?? "");
+    });
+    socket.addEventListener("error", () => {
+      if (!this.#owns(generation))
+        return;
+      this.#handlers.onError(new Error("Gateway WebSocket error"));
+    });
+    return { ok: true };
   }
-  async fetchPinnedMessages(channelId) {
-    const data = await this.#rest.get(Routes.channelPins(channelId));
-    return data.map((item) => this.messages(channelId).upsert(item));
+  send(data) {
+    if (!this.connected)
+      return false;
+    try {
+      this.#socket.send(data);
+      return true;
+    } catch (error) {
+      this.#handlers.onError(this.#asError(error));
+      return false;
+    }
   }
-  async pinMessage(channelId, messageId) {
-    await this.#rest.put(Routes.channelPin(channelId, messageId));
+  close(code = 1000, reason = "") {
+    const socket = this.#socket;
+    if (!socket)
+      return;
+    try {
+      socket.close(code, reason);
+    } catch (error) {
+      this.#handlers.onError(this.#asError(error));
+    }
   }
-  async unpinMessage(channelId, messageId) {
-    await this.#rest.delete(Routes.channelPin(channelId, messageId));
+  destroy(code = 1000, reason = "") {
+    this.#discard(code, reason);
+    this.#decoder.reset();
   }
-  createThreadFromMessage(channelId, messageId, options) {
-    return this.threads(channelId).createFromMessage(messageId, options);
+  #owns(generation) {
+    return generation === this.#generation;
   }
-  delete(channelId) {
-    this.#messageManagers.delete(channelId);
-    return super.delete(channelId);
+  #discard(code, reason) {
+    const socket = this.#socket;
+    if (!socket)
+      return;
+    this.#generation++;
+    this.#socket = undefined;
+    try {
+      socket.close(code, reason);
+    } catch (error) {
+      this.#handlers.onError(this.#asError(error));
+    }
   }
-  clear() {
-    this.#messageManagers.clear();
-    super.clear();
+  #asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
   }
 }
-function isMessageQuery(value) {
-  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
-}
 
-// packages/ws/src/index.ts
+// packages/ws/src/opcodes.ts
 var GatewayOpcodes = {
   Dispatch: 0,
   Heartbeat: 1,
@@ -2193,6 +3704,131 @@ var GatewayOpcodes = {
   Hello: 10,
   HeartbeatAck: 11
 };
+
+// packages/ws/src/protocol.ts
+function classifyFrame(raw) {
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (error) {
+    return {
+      sequence: null,
+      action: {
+        type: "invalid",
+        violation: "invalid-json",
+        message: "Gateway returned invalid JSON",
+        cause: error
+      }
+    };
+  }
+  return classifyPayload(payload);
+}
+function classifyPayload(payload) {
+  if (payload === null || typeof payload !== "object" || typeof payload.op !== "number")
+    return {
+      sequence: null,
+      action: {
+        type: "invalid",
+        violation: "invalid-payload",
+        message: "Gateway returned an invalid payload"
+      }
+    };
+  const frame = payload;
+  const sequence = typeof frame.s === "number" ? frame.s : null;
+  switch (frame.op) {
+    case GatewayOpcodes.Dispatch:
+      return {
+        sequence,
+        action: {
+          type: "dispatch",
+          event: typeof frame.t === "string" ? frame.t : null,
+          data: frame.d
+        }
+      };
+    case GatewayOpcodes.Hello: {
+      const interval = frame.d?.heartbeat_interval;
+      if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0)
+        return {
+          sequence,
+          action: {
+            type: "invalid",
+            violation: "invalid-hello",
+            message: "Gateway HELLO payload contains an invalid heartbeat interval"
+          }
+        };
+      return {
+        sequence,
+        action: { type: "hello", heartbeatInterval: interval }
+      };
+    }
+    case GatewayOpcodes.Heartbeat:
+      return { sequence, action: { type: "heartbeat" } };
+    case GatewayOpcodes.HeartbeatAck:
+      return {
+        sequence,
+        action: { type: "heartbeat-ack", data: frame.d }
+      };
+    case GatewayOpcodes.Reconnect:
+      return { sequence, action: { type: "reconnect" } };
+    case GatewayOpcodes.InvalidSession:
+      return {
+        sequence,
+        action: {
+          type: "invalid-session",
+          resumable: frame.d === true
+        }
+      };
+    default:
+      return { sequence, action: { type: "unknown", opcode: frame.op } };
+  }
+}
+function identifyPayload(options) {
+  const props = options.properties ?? {};
+  const os = props.os ?? "Android";
+  const browser = props.browser ?? "Discord Android";
+  const device = props.device ?? "Discord Android";
+  return {
+    op: GatewayOpcodes.Identify,
+    d: {
+      token: options.token,
+      intents: options.intents,
+      properties: {
+        os,
+        browser,
+        device,
+        $os: os,
+        $browser: browser,
+        $device: device,
+        ...props
+      },
+      presence: {
+        since: options.presence?.since ?? null,
+        activities: options.presence?.activities ?? [],
+        status: options.presence?.status ?? "online",
+        afk: Boolean(options.presence?.afk)
+      },
+      shard: [options.shardId, options.shardCount]
+    },
+    s: null,
+    t: null
+  };
+}
+function resumePayload(token, resume) {
+  return {
+    op: GatewayOpcodes.Resume,
+    d: {
+      token,
+      session_id: resume.sessionId,
+      seq: resume.sequence
+    },
+    s: null,
+    t: null
+  };
+}
+function heartbeatPayload(sequence) {
+  return { op: GatewayOpcodes.Heartbeat, d: sequence, s: null, t: null };
+}
+// packages/ws/src/state.ts
 class GatewayError extends Error {
   code;
   constructor(message, code, options) {
@@ -2201,31 +3837,43 @@ class GatewayError extends Error {
     this.code = code;
   }
 }
+// packages/ws/src/send-budget.ts
+class SendBudget {
+  #timestamps = [];
+  #limit;
+  #windowMs;
+  constructor(limit = 115, windowMs = 60000) {
+    this.#limit = limit;
+    this.#windowMs = windowMs;
+  }
+  get used() {
+    return this.#timestamps.length;
+  }
+  allows(privileged, now = Date.now()) {
+    while (this.#timestamps.length && now - this.#timestamps[0] >= this.#windowMs)
+      this.#timestamps.shift();
+    return privileged || this.#timestamps.length < this.#limit;
+  }
+  record(now = Date.now()) {
+    this.#timestamps.push(now);
+  }
+}
+
+// packages/ws/src/index.ts
+var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
 
 class Gateway {
   state = "CONNECT" /* Connect */;
   #options;
-  #ws;
-  #sequence = null;
-  #sessionId;
-  #resumeURL;
-  #heartbeatTimer;
-  #initialHeartbeat;
-  #heartbeatAckTimer;
-  #heartbeatACK = true;
-  #heartbeatInterval = 0;
-  #heartbeatSentAt = 0;
-  #lastMessageAt = 0;
-  #zombieTimer;
-  #zombieReported = false;
+  #transport;
+  #session = new GatewaySession;
+  #token = 0;
+  #heartbeat;
   #closed = false;
-  #attempt = 0;
-  #reconnectTimer;
-  #connectPromise;
-  #resolveConnect;
-  #rejectConnect;
+  #reconnect;
   #listeners = new Map;
-  #sendTimestamps = [];
+  #sendBudget = new SendBudget;
+  ping = -1;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Gateway token is required.");
@@ -2246,39 +3894,78 @@ class Gateway {
         browser: "Discord Android",
         device: "Discord Android"
       },
-      presence: { status: "online", activities: [], afk: false, since: null },
-      ...options
+      presence: {
+        status: "online",
+        activities: [],
+        afk: false,
+        since: null
+      },
+      ...options,
+      intents: resolvedIntents
     };
     if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
       throw new RangeError("Gateway shardId must be within the configured shard count.");
     if (this.#options.zombieTimeout <= this.#options.heartbeatAckTimeout)
       throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
+    this.#transport = new WebSocketTransport({
+      compress: this.#options.compress,
+      createSocket: options.createSocket,
+      handlers: {
+        onOpen: () => this.#onOpen(),
+        onFrame: (raw) => this.#message(raw, this.#token),
+        onClose: (code) => this.#close(code, this.#token),
+        onError: (error) => this.#emitError(error instanceof GatewayError ? error : new GatewayError(error.message, undefined, {
+          cause: error
+        }))
+      }
+    });
+    this.#reconnect = new GatewayReconnect({
+      enabled: this.#options.reconnect,
+      maxAttempts: this.#options.maxReconnectAttempts,
+      baseDelay: this.#options.reconnectBaseDelay,
+      maxDelay: this.#options.reconnectMaxDelay
+    });
+    this.#heartbeat = new GatewayHeartbeat({
+      ackTimeout: this.#options.heartbeatAckTimeout,
+      zombieTimeout: this.#options.zombieTimeout,
+      send: (sequence) => this.#dispatch(heartbeatPayload(sequence), true),
+      sequence: () => this.#session.sequence,
+      isConnected: () => !this.#closed && this.#transport.connected,
+      onTimeout: (timeout) => this.#onHeartbeatTimeout(timeout),
+      onError: (error) => this.#emitError(error)
+    });
+  }
+  #onHeartbeatTimeout(timeout) {
+    if (timeout.type === "zombie") {
+      this.#emit("zombie", {
+        silentFor: timeout.silentFor,
+        timeout: timeout.deadline
+      });
+      this.#emitError(new GatewayError(`Gateway connection appears stale after ${timeout.silentFor}ms without traffic.`));
+    } 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");
   }
-  connect(url = "wss://gateway.discord.gg/?v=10&encoding=json") {
+  connect(url = DEFAULT_GATEWAY_URL) {
     if (this.state === "CLOSED" /* Closed */)
       throw new GatewayError("Gateway has been permanently closed.");
-    if (this.#connectPromise)
-      return this.#connectPromise;
+    const inFlight = this.#reconnect.attemptPromise;
+    if (inFlight)
+      return inFlight;
+    if (this.#transport.live)
+      return Promise.resolve();
+    this.#reconnect.cancel();
     this.#closed = false;
     this.#setState("CONNECT" /* Connect */);
-    this.#connectPromise = new Promise((resolve, reject) => {
-      this.#resolveConnect = resolve;
-      this.#rejectConnect = reject;
-      this.#open(url);
-    });
-    return this.#connectPromise;
+    const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}&compress=zlib-stream` : url;
+    return this.#reconnect.attempt(() => this.#open(connectURL));
   }
   close() {
     this.#closed = true;
     this.#clearTimers();
     this.#settleConnect(new GatewayError("Gateway connection closed before socket open."));
-    const ws = this.#ws;
-    this.#ws = undefined;
-    try {
-      ws?.close(1000, "Client closed connection");
-    } catch (error) {
-      this.#emitError(error);
-    }
+    this.#transport.destroy(1000, "Client closed connection");
     this.#setState("CLOSED" /* Closed */);
   }
   emit(event, data) {
@@ -2300,23 +3987,20 @@ class Gateway {
   send(payload) {
     if (!payload || !Number.isInteger(payload.op))
       throw new TypeError("Gateway payload must contain an integer opcode.");
-    if (this.#ws?.readyState !== WebSocket.OPEN)
+    return this.#dispatch(payload, false);
+  }
+  #dispatch(payload, privileged) {
+    if (!this.#transport.connected)
       return false;
     const now = Date.now();
-    while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
-      this.#sendTimestamps.shift();
-    if (this.#sendTimestamps.length >= 115) {
+    if (!this.#sendBudget.allows(privileged, now)) {
       this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
       return false;
     }
-    try {
-      this.#ws.send(JSON.stringify(payload));
-      this.#sendTimestamps.push(now);
-      return true;
-    } catch (error) {
-      this.#emitError(error);
+    if (!this.#transport.send(JSON.stringify(payload)))
       return false;
-    }
+    this.#sendBudget.record(now);
+    return true;
   }
   setPresence(data) {
     this.#options.presence = { ...this.#options.presence, ...data };
@@ -2352,289 +4036,142 @@ class Gateway {
   #open(url) {
     if (this.#closed)
       return;
-    let ws;
-    try {
-      ws = new WebSocket(url);
-    } catch (error) {
-      const failure = this.#normalizeError(error);
-      this.#emitError(failure);
-      if (this.#options.reconnect) {
-        this.#setState("RECONNECT" /* Reconnect */);
-        this.#scheduleReconnect();
-      } else
-        this.#settleConnect(failure);
+    this.#token = this.#session.beginConnection();
+    const result = this.#transport.connect(url);
+    if (result.ok)
       return;
+    const failure = this.#normalizeError(result.error);
+    this.#emitError(failure);
+    if (this.#options.reconnect) {
+      this.#setState("RECONNECT" /* Reconnect */);
+      this.#scheduleReconnect();
+    } else {
+      this.#settleConnect(failure);
     }
-    this.#ws = ws;
-    ws.addEventListener("open", () => {
-      this.#lastMessageAt = Date.now();
-      this.#zombieReported = false;
-      this.#startZombieDetection();
-      this.#emit("open", undefined);
-      this.#settleConnect();
-    });
-    ws.addEventListener("message", (event) => {
-      this.#lastMessageAt = Date.now();
-      this.#zombieReported = false;
-      this.#message(ws, String(event.data));
-    });
-    ws.addEventListener("close", (event) => this.#close(ws, event.code));
-    ws.addEventListener("error", () => this.#emitError(new GatewayError("Gateway WebSocket error")));
-  }
-  #startZombieDetection() {
-    if (this.#zombieTimer)
-      clearInterval(this.#zombieTimer);
-    const interval = Math.max(1, Math.min(250, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
-    this.#zombieTimer = setInterval(() => {
-      if (this.#closed || this.#ws?.readyState !== WebSocket.OPEN || this.#lastMessageAt === 0)
-        return;
-      const silentFor = Date.now() - this.#lastMessageAt;
-      const deadline = Math.max(this.#options.zombieTimeout, this.#heartbeatInterval + this.#options.heartbeatAckTimeout);
-      if (silentFor < deadline || this.#zombieReported)
-        return;
-      this.#zombieReported = true;
-      const error = new GatewayError(`Gateway connection appears stale after ${silentFor}ms without traffic.`);
-      this.#emit("zombie", { silentFor, timeout: deadline });
-      this.#emitError(error);
-      try {
-        this.#ws.close(1001, "Zombie Gateway connection");
-      } catch (closeError) {
-        this.#emitError(closeError);
-      }
-    }, interval);
   }
-  #message(ws, raw) {
-    let payload;
-    try {
-      payload = JSON.parse(raw);
-    } catch (error) {
-      this.#emitError(new GatewayError("Gateway returned invalid JSON", undefined, {
-        cause: error
-      }));
-      ws.close(1002, "Invalid JSON");
-      return;
-    }
-    if (!payload || typeof payload.op !== "number") {
-      this.#emitError(new GatewayError("Gateway returned an invalid payload"));
-      ws.close(1002, "Invalid payload");
+  #onOpen() {
+    this.#heartbeat.watch();
+    this.#emit("open", undefined);
+    this.#settleConnect();
+  }
+  #message(raw, token) {
+    if (!this.#session.owns(token))
       return;
-    }
-    if (typeof payload.s === "number")
-      this.#sequence = payload.s;
-    switch (payload.op) {
-      case GatewayOpcodes.Dispatch:
+    const { sequence, action } = classifyFrame(raw);
+    if (sequence !== null)
+      this.#session.recordSequence(sequence, token);
+    this.#apply(action, token);
+  }
+  #apply(action, token) {
+    switch (action.type) {
+      case "dispatch":
         this.#setState("DISPATCH" /* Dispatch */);
-        this.#handleDispatch(payload.t, payload.d);
-        break;
-      case GatewayOpcodes.Hello:
-        this.#handleHello(payload.d);
-        break;
-      case GatewayOpcodes.Heartbeat:
+        this.#handleDispatch(action.event, action.data, token);
+        return;
+      case "hello":
+        this.#handleHello(action.heartbeatInterval);
+        return;
+      case "heartbeat":
         this.#setState("HEARTBEAT" /* Heartbeat */);
-        this.#sendHeartbeat();
-        break;
-      case GatewayOpcodes.HeartbeatAck:
-        this.#heartbeatACK = true;
-        this.#clearHeartbeatAckTimer();
-        this.#emit("heartbeatAck", payload.d);
-        break;
-      case GatewayOpcodes.Reconnect:
-        ws.close(1001, "Server requested reconnect");
-        break;
-      case GatewayOpcodes.InvalidSession:
-        this.#sessionId = undefined;
-        this.#sequence = null;
-        this.#emit("invalidSession", payload.d);
-        ws.close(1000, "Invalid session");
-        break;
+        this.#heartbeat.sendHeartbeat();
+        return;
+      case "heartbeat-ack":
+        this.#heartbeat.acknowledge();
+        this.ping = this.#heartbeat.latency;
+        this.#emit("heartbeatAck", action.data);
+        return;
+      case "reconnect":
+        this.#transport.close(1001, "Server requested reconnect");
+        return;
+      case "invalid-session": {
+        if (!action.resumable)
+          this.#session.invalidate(token, "invalid-session");
+        this.#emit("invalidSession", action.resumable);
+        this.#transport.close(action.resumable ? GatewayCloseCodes.UnknownError : 1000, action.resumable ? "Invalid session (resumable)" : "Invalid session");
+        return;
+      }
+      case "invalid":
+        this.#emitError(new GatewayError(action.message, undefined, action.cause === undefined ? undefined : { cause: action.cause }));
+        this.#transport.close(1002, action.violation === "invalid-json" ? "Invalid JSON" : action.violation === "invalid-hello" ? "Invalid heartbeat interval" : "Invalid payload");
+        return;
+      case "unknown":
+        return;
     }
   }
-  #handleDispatch(event, data) {
+  #handleDispatch(event, data, token) {
     if (event === "READY") {
-      const ready = data;
-      if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string") {
-        this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
+      if (!this.#session.activate(data, token)) {
+        if (this.#session.owns(token))
+          this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
         return;
       }
-      this.#sessionId = ready.session_id;
-      this.#resumeURL = ready.resume_gateway_url;
-      this.#attempt = 0;
+      this.#reconnect.reset();
       this.#setState("READY" /* Ready */);
       this.#emit("ready", data);
+    } else if (event === "RESUMED") {
+      this.#reconnect.reset();
+      this.#setState("READY" /* Ready */);
+      this.#emit("resumed", data);
     }
     this.#emit("RAW", { event: event ?? "UNKNOWN", data });
     if (this.#closed)
       return;
     this.#emit(event ?? "dispatch", data);
   }
-  #handleHello(data) {
-    const interval = data?.heartbeat_interval;
-    if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0) {
-      this.#emitError(new GatewayError("Gateway HELLO payload contains an invalid heartbeat interval"));
-      this.#ws?.close(1002, "Invalid heartbeat interval");
-      return;
-    }
-    this.#heartbeatInterval = interval;
-    this.#setState(this.#sessionId && this.#sequence !== null && this.#resumeURL ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
-    this.#startHeartbeat(interval);
+  #handleHello(interval) {
+    this.#setState(this.#session.canResume ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
+    this.#heartbeat.start(interval);
     this.#identifyOrResume();
   }
   #identifyOrResume() {
-    if (this.#sessionId && this.#sequence !== null && this.#resumeURL) {
+    const intent = this.#session.handshake();
+    if (intent.type === "resume") {
       this.#setState("RESUME" /* Resume */);
-      this.send({
-        op: GatewayOpcodes.Resume,
-        d: {
-          token: this.#options.token,
-          session_id: this.#sessionId,
-          seq: this.#sequence
-        },
-        s: null,
-        t: null
-      });
+      this.#dispatch(resumePayload(this.#options.token, intent), true);
       return;
     }
     this.#setState("IDENTIFY" /* Identify */);
-    const props = this.#options.properties ?? {
-      os: "Android",
-      browser: "Discord Android",
-      device: "Discord Android"
-    };
-    const os = props.os ?? "Android";
-    const browser = props.browser ?? "Discord Android";
-    const device = props.device ?? "Discord Android";
-    this.send({
-      op: GatewayOpcodes.Identify,
-      d: {
-        token: this.#options.token,
-        intents: this.#options.intents,
-        properties: {
-          os,
-          browser,
-          device,
-          $os: os,
-          $browser: browser,
-          $device: device,
-          ...props
-        },
-        presence: {
-          since: this.#options.presence?.since ?? null,
-          activities: this.#options.presence?.activities ?? [],
-          status: this.#options.presence?.status ?? "online",
-          afk: Boolean(this.#options.presence?.afk)
-        },
-        shard: [this.#options.shardId, this.#options.shardCount]
-      },
-      s: null,
-      t: null
-    });
-  }
-  #startHeartbeat(interval) {
-    this.#clearHeartbeatTimers();
-    this.#heartbeatACK = true;
-    this.#initialHeartbeat = setTimeout(() => this.#sendHeartbeat(), Math.random() * interval);
-    this.#heartbeatTimer = setInterval(() => this.#sendHeartbeat(), interval);
-  }
-  #sendHeartbeat() {
-    this.#heartbeatACK = false;
-    this.#heartbeatSentAt = Date.now();
-    if (!this.send({
-      op: GatewayOpcodes.Heartbeat,
-      d: this.#sequence,
-      s: null,
-      t: null
-    })) {
-      this.#emitError(new GatewayError("Unable to send Gateway heartbeat because the WebSocket is not open."));
-      return;
-    }
-    this.#clearHeartbeatAckTimer();
-    this.#heartbeatAckTimer = setTimeout(() => {
-      if (!this.#heartbeatACK) {
-        const elapsed = Date.now() - this.#heartbeatSentAt;
-        this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${elapsed}ms.`));
-        try {
-          this.#ws?.close(1001, "Heartbeat timeout");
-        } catch (error) {
-          this.#emitError(error);
-        }
-      }
-    }, this.#options.heartbeatAckTimeout);
-  }
-  #close(ws, code) {
-    if (this.#ws !== ws)
-      return;
-    this.#ws = undefined;
+    this.#dispatch(identifyPayload({
+      token: this.#options.token,
+      intents: this.#options.intents,
+      shardId: this.#options.shardId,
+      shardCount: this.#options.shardCount,
+      properties: this.#options.properties,
+      presence: this.#options.presence
+    }), true);
+  }
+  #close(code, token) {
     this.#clearTimers();
-    const action = this.#closeAction(code);
+    const action = this.#reconnect.classifyClose(code, this.#session.canResume);
     this.#emit("close", { code, action });
-    if (this.#closed || !this.#options.reconnect || action === "stop") {
+    if (this.#closed || !this.#reconnect.enabled || action === "stop") {
+      if (action === "stop")
+        this.#closed = true;
       this.#setState(this.#closed ? "CLOSED" /* Closed */ : "CONNECT" /* Connect */);
-      if (this.#connectPromise)
-        this.#settleConnect(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
+      if (this.#reconnect.connecting)
+        this.#reconnect.settle(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
       return;
     }
-    if (action === "identify") {
-      this.#sequence = null;
-      this.#sessionId = undefined;
-    }
+    if (action === "identify")
+      this.#session.invalidate(token, "session-timeout");
     this.#setState("RECONNECT" /* Reconnect */);
     this.#scheduleReconnect();
   }
-  #closeAction(code) {
-    if ([4004, 4010, 4011, 4012, 4013, 4014].includes(code))
-      return "stop";
-    if ([4007, 4009].includes(code))
-      return "identify";
-    return this.#sessionId && this.#sequence !== null ? "resume" : "identify";
-  }
   #scheduleReconnect() {
-    if (this.#closed || !this.#options.reconnect || this.#reconnectTimer)
+    if (this.#closed)
       return;
-    if (this.#attempt >= this.#options.maxReconnectAttempts) {
-      this.#settleConnect(new GatewayError("Gateway reconnect attempts exhausted."));
-      this.#setState("CONNECT" /* Connect */);
+    const result = this.#reconnect.schedule(() => this.#open(this.#session.connectURL(DEFAULT_GATEWAY_URL)));
+    if (result.scheduled || result.reason !== "exhausted")
       return;
-    }
-    const delay = Math.min(this.#options.reconnectMaxDelay, this.#options.reconnectBaseDelay * 2 ** this.#attempt++);
-    const jitter = Math.random() * Math.min(250, Math.max(1, delay * 0.25));
-    this.#reconnectTimer = setTimeout(() => {
-      this.#reconnectTimer = undefined;
-      this.#open(this.#resumeURL ?? "wss://gateway.discord.gg/?v=10&encoding=json");
-    }, delay + jitter);
+    this.#reconnect.settle(new GatewayError("Gateway reconnect attempts exhausted."));
+    this.#setState("CONNECT" /* Connect */);
   }
   #settleConnect(error) {
-    const resolve = this.#resolveConnect;
-    const reject = this.#rejectConnect;
-    this.#resolveConnect = undefined;
-    this.#rejectConnect = undefined;
-    this.#connectPromise = undefined;
-    if (error)
-      reject?.(error);
-    else
-      resolve?.();
-  }
-  #clearHeartbeatAckTimer() {
-    if (this.#heartbeatAckTimer)
-      clearTimeout(this.#heartbeatAckTimer);
-    this.#heartbeatAckTimer = undefined;
-  }
-  #clearHeartbeatTimers() {
-    if (this.#heartbeatTimer)
-      clearInterval(this.#heartbeatTimer);
-    if (this.#initialHeartbeat)
-      clearTimeout(this.#initialHeartbeat);
-    this.#clearHeartbeatAckTimer();
-    this.#heartbeatTimer = undefined;
-    this.#initialHeartbeat = undefined;
+    this.#reconnect.settle(error);
   }
   #clearTimers() {
-    if (this.#reconnectTimer)
-      clearTimeout(this.#reconnectTimer);
-    if (this.#zombieTimer)
-      clearInterval(this.#zombieTimer);
-    this.#reconnectTimer = undefined;
-    this.#zombieTimer = undefined;
-    this.#clearHeartbeatTimers();
+    this.#reconnect.cancel();
+    this.#heartbeat.stop();
   }
   #normalizeError(error) {
     return error instanceof GatewayError ? error : new GatewayError("Gateway connection failed.", undefined, {
@@ -2669,7 +4206,7 @@ class Gateway {
 }
 
 // packages/core/src/index.ts
-class EventEmitter {
+class EventEmitter2 {
   #listeners = new Map;
   on(event, listener) {
     if (typeof listener !== "function")
@@ -2691,6 +4228,9 @@ class EventEmitter {
     this.#listeners.get(event)?.delete(listener);
     return this;
   }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
   removeAllListeners(event) {
     if (event === undefined)
       this.#listeners.clear();
@@ -2727,12 +4267,13 @@ class EventEmitter {
   }
 }
 
-class Client extends EventEmitter {
+class Client extends EventEmitter2 {
   options;
   rest;
   users;
   guilds;
   channels;
+  stageInstances;
   application;
   get ws() {
     return this.#gateway;
@@ -2743,14 +4284,26 @@ class Client extends EventEmitter {
   user;
   readyAt;
   state = "idle";
+  get token() {
+    return this.state === "destroyed" ? null : this.options.token ?? null;
+  }
   get uptime() {
     return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
   }
+  get ping() {
+    return this.#gateway.ping;
+  }
   isReady() {
     return this.state === "ready";
   }
   setPresence(data) {
-    return this.#gateway.setPresence?.(data) ?? false;
+    return this.#gateway.setPresence(data);
+  }
+  setVoiceState(data) {
+    return this.#gateway.setVoiceState(data);
+  }
+  requestGuildMembers(data) {
+    return this.#gateway.requestGuildMembers(data);
   }
   #gateway;
   #resourceContext;
@@ -2763,14 +4316,15 @@ class Client extends EventEmitter {
     this.users = new UserManager(this.rest);
     this.guilds = new GuildManager(this.rest);
     this.channels = new ChannelManager(this.rest);
+    this.stageInstances = new StageInstanceManager(this.rest);
     const placeholderAppCommands = new ApplicationCommandManager(this.rest, "0");
     this.application = { commands: placeholderAppCommands };
     this.#resourceContext = {
-      sendMessage: (channelId, options2) => this.channels.send(channelId, options2),
-      editMessage: (channelId, messageId, options2) => this.channels.editMessage(channelId, messageId, options2),
+      sendMessage: (channelId, options) => this.channels.send(channelId, options),
+      editMessage: (channelId, messageId, options) => this.channels.editMessage(channelId, messageId, options),
       deleteMessage: (channelId, messageId) => this.channels.deleteMessage(channelId, messageId),
       crosspostMessage: (channelId, messageId) => this.channels.crosspostMessage(channelId, messageId),
-      editChannel: (channelId, options2) => this.channels.edit(channelId, options2),
+      editChannel: (channelId, options) => this.channels.edit(channelId, options),
       deleteChannel: (channelId) => this.channels.deleteChannel(channelId),
       addReaction: (channelId, messageId, emoji) => this.channels.addReaction(channelId, messageId, emoji),
       removeOwnReaction: (channelId, messageId, emoji) => this.channels.removeOwnReaction(channelId, messageId, emoji),
@@ -2794,6 +4348,13 @@ class Client extends EventEmitter {
       this.application.commands = new ApplicationCommandManager(this.rest, appId);
       this.emit("ready" /* Ready */, this.user);
     });
+    this.#gateway.on("RESUMED", () => {
+      this.state = "ready";
+      this.emit("resumed" /* Resumed */);
+    });
+    this.#gateway.on("invalidSession", (isRecoverable) => {
+      this.emit("invalidSession" /* InvalidSession */, isRecoverable);
+    });
     this.#gateway.on("open", () => this.emit("open" /* Open */));
     this.#gateway.on("close", (data) => {
       if (this.state !== "destroyed")
@@ -2826,6 +4387,7 @@ class Client extends EventEmitter {
         this.emit("guildUnavailable" /* GuildUnavailable */, payload);
         return;
       }
+      const wasCached = this.guilds.has(payload.id);
       const guild = new Guild(payload);
       this.guilds.set(guild.id, guild);
       for (const member of payload.members ?? [])
@@ -2834,8 +4396,8 @@ class Client extends EventEmitter {
         ...payload.channels ?? [],
         ...payload.threads ?? []
       ])
-        this.channels.set(channelData.id, new Channel(channelData, this.#resourceContext));
-      this.emit("guildCreate" /* GuildCreate */, payload);
+        this.channels.set(channelData.id, createChannel(channelData, this.#resourceContext));
+      this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
     });
     this.#gateway.on("GUILD_UPDATE", (data) => {
       const guild = new Guild(data);
@@ -2881,12 +4443,12 @@ class Client extends EventEmitter {
     this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, data));
     this.#gateway.on("AUTO_MODERATION_ACTION_EXECUTION", (data) => this.emit("autoModerationActionExecution" /* AutoModerationActionExecution */, data));
     this.#gateway.on("CHANNEL_CREATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("channelCreate" /* ChannelCreate */, channel);
     });
     this.#gateway.on("CHANNEL_UPDATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("channelUpdate" /* ChannelUpdate */, channel);
     });
@@ -2897,12 +4459,12 @@ class Client extends EventEmitter {
     });
     this.#gateway.on("CHANNEL_PINS_UPDATE", (data) => this.emit("channelPinsUpdate" /* ChannelPinsUpdate */, data));
     this.#gateway.on("THREAD_CREATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("threadCreate" /* ThreadCreate */, channel);
     });
     this.#gateway.on("THREAD_UPDATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("threadUpdate" /* ThreadUpdate */, channel);
     });
@@ -2964,13 +4526,57 @@ class Client extends EventEmitter {
       return Promise.reject(new Error("Client is unauthenticated."));
     return this.rest.post(`/webhooks/${this.user.id}/${token}`, data);
   }
+  fetchWebhook(id, token) {
+    return this.rest.get(token ? `/webhooks/${id}/${token}` : `/webhooks/${id}`);
+  }
+  fetchGuildPreview(guildId) {
+    return this.rest.get(`/guilds/${guildId}/preview`);
+  }
+  fetchVoiceRegions() {
+    return this.rest.get("/voice/regions");
+  }
+  fetchInvite(code, options) {
+    const query = new URLSearchParams;
+    if (options?.withCounts)
+      query.set("with_counts", "true");
+    if (options?.withExpiration)
+      query.set("with_expiration", "true");
+    if (options?.guildScheduledEventId)
+      query.set("guild_scheduled_event_id", options.guildScheduledEventId);
+    const qs = query.toString();
+    return this.rest.get(`/invites/${encodeURIComponent(code)}${qs ? `?${qs}` : ""}`);
+  }
+  fetchSticker(id) {
+    return this.rest.get(`/stickers/${id}`);
+  }
+  fetchPremiumStickerPacks() {
+    return this.rest.get(`/sticker-packs`);
+  }
+  fetchGuildTemplate(code) {
+    return this.rest.get(`/guilds/templates/${encodeURIComponent(code)}`);
+  }
+  generateInvite(options) {
+    if (!this.user)
+      throw new Error("Client must be ready to generate invite.");
+    const params = new URLSearchParams({
+      client_id: this.user.id,
+      scope: (options?.scopes ?? ["bot"]).join(" ")
+    });
+    if (options?.permissions) {
+      params.set("permissions", String(options.permissions));
+    }
+    return `https://discord.com/api/oauth2/authorize?${params.toString()}`;
+  }
 }
 export {
   Client,
   ClientEvent,
+  Collector,
+  ClientEvent as Events,
   GatewayIntentBits,
   IntentBits,
   Intents,
+  IntentsBitField,
   Permission,
   PermissionFlagsBits,
   PermissionOverwriteType,
@@ -2980,4 +4586,4 @@ export {
   resolveGatewayIntents
 };
 
-//# debugId=813519968046205864756E2164756E21
+//# debugId=B9E28396E97D857564756E2164756E21