lunibee 0.1.0 → 0.1.2

package/dist/core/index.js

@@ -0,0 +1,3188 @@
+// @bun
+// packages/core/src/permissions.ts
+var PermissionOverwriteType;
+((PermissionOverwriteType2) => {
+  PermissionOverwriteType2[PermissionOverwriteType2["Role"] = 0] = "Role";
+  PermissionOverwriteType2[PermissionOverwriteType2["Member"] = 1] = "Member";
+})(PermissionOverwriteType ||= {});
+var Permission = {
+  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
+};
+var Permissions = {
+  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
+};
+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 ||= {});
+
+class PermissionSet {
+  bitfield;
+  constructor(value = 0n) {
+    try {
+      if (Array.isArray(value)) {
+        let bit = 0n;
+        for (const item of value) {
+          bit |= this.#resolve(item);
+        }
+        this.bitfield = bit;
+      } else if (value instanceof PermissionSet) {
+        this.bitfield = value.bitfield;
+      } else {
+        const bitfield = this.#resolve(value);
+        if (bitfield < 0n)
+          throw new RangeError("Permission bitfield cannot be negative.");
+        this.bitfield = bitfield;
+      }
+    } catch (error) {
+      if (error instanceof RangeError)
+        throw error;
+      throw new TypeError("Permission bitfield must be a valid non-negative integer.", { cause: error });
+    }
+  }
+  get createInstantInvite() {
+    return (this.bitfield & Permission.createInstantInvite) === Permission.createInstantInvite;
+  }
+  get kickMembers() {
+    return (this.bitfield & Permission.kickMembers) === Permission.kickMembers;
+  }
+  get banMembers() {
+    return (this.bitfield & Permission.banMembers) === Permission.banMembers;
+  }
+  get administrator() {
+    return (this.bitfield & Permission.administrator) === Permission.administrator;
+  }
+  get manageChannels() {
+    return (this.bitfield & Permission.manageChannels) === Permission.manageChannels;
+  }
+  get manageGuild() {
+    return (this.bitfield & Permission.manageGuild) === Permission.manageGuild;
+  }
+  get addReactions() {
+    return (this.bitfield & Permission.addReactions) === Permission.addReactions;
+  }
+  get viewAuditLog() {
+    return (this.bitfield & Permission.viewAuditLog) === Permission.viewAuditLog;
+  }
+  get prioritySpeaker() {
+    return (this.bitfield & Permission.prioritySpeaker) === Permission.prioritySpeaker;
+  }
+  get stream() {
+    return (this.bitfield & Permission.stream) === Permission.stream;
+  }
+  get viewChannel() {
+    return (this.bitfield & Permission.viewChannel) === Permission.viewChannel;
+  }
+  get sendMessages() {
+    return (this.bitfield & Permission.sendMessages) === Permission.sendMessages;
+  }
+  get sendTTSMessages() {
+    return (this.bitfield & Permission.sendTTSMessages) === Permission.sendTTSMessages;
+  }
+  get manageMessages() {
+    return (this.bitfield & Permission.manageMessages) === Permission.manageMessages;
+  }
+  get embedLinks() {
+    return (this.bitfield & Permission.embedLinks) === Permission.embedLinks;
+  }
+  get attachFiles() {
+    return (this.bitfield & Permission.attachFiles) === Permission.attachFiles;
+  }
+  get readMessageHistory() {
+    return (this.bitfield & Permission.readMessageHistory) === Permission.readMessageHistory;
+  }
+  get mentionEveryone() {
+    return (this.bitfield & Permission.mentionEveryone) === Permission.mentionEveryone;
+  }
+  get useExternalEmojis() {
+    return (this.bitfield & Permission.useExternalEmojis) === Permission.useExternalEmojis;
+  }
+  get viewGuildInsights() {
+    return (this.bitfield & Permission.viewGuildInsights) === Permission.viewGuildInsights;
+  }
+  get connect() {
+    return (this.bitfield & Permission.connect) === Permission.connect;
+  }
+  get speak() {
+    return (this.bitfield & Permission.speak) === Permission.speak;
+  }
+  get muteMembers() {
+    return (this.bitfield & Permission.muteMembers) === Permission.muteMembers;
+  }
+  get deafenMembers() {
+    return (this.bitfield & Permission.deafenMembers) === Permission.deafenMembers;
+  }
+  get moveMembers() {
+    return (this.bitfield & Permission.moveMembers) === Permission.moveMembers;
+  }
+  get useVAD() {
+    return (this.bitfield & Permission.useVAD) === Permission.useVAD;
+  }
+  get changeNickname() {
+    return (this.bitfield & Permission.changeNickname) === Permission.changeNickname;
+  }
+  get manageNicknames() {
+    return (this.bitfield & Permission.manageNicknames) === Permission.manageNicknames;
+  }
+  get manageRoles() {
+    return (this.bitfield & Permission.manageRoles) === Permission.manageRoles;
+  }
+  get manageWebhooks() {
+    return (this.bitfield & Permission.manageWebhooks) === Permission.manageWebhooks;
+  }
+  get manageGuildExpressions() {
+    return (this.bitfield & Permission.manageGuildExpressions) === Permission.manageGuildExpressions;
+  }
+  get useApplicationCommands() {
+    return (this.bitfield & Permission.useApplicationCommands) === Permission.useApplicationCommands;
+  }
+  get requestToSpeak() {
+    return (this.bitfield & Permission.requestToSpeak) === Permission.requestToSpeak;
+  }
+  get manageEvents() {
+    return (this.bitfield & Permission.manageEvents) === Permission.manageEvents;
+  }
+  get manageThreads() {
+    return (this.bitfield & Permission.manageThreads) === Permission.manageThreads;
+  }
+  get createPublicThreads() {
+    return (this.bitfield & Permission.createPublicThreads) === Permission.createPublicThreads;
+  }
+  get createPrivateThreads() {
+    return (this.bitfield & Permission.createPrivateThreads) === Permission.createPrivateThreads;
+  }
+  get useExternalStickers() {
+    return (this.bitfield & Permission.useExternalStickers) === Permission.useExternalStickers;
+  }
+  get sendMessagesInThreads() {
+    return (this.bitfield & Permission.sendMessagesInThreads) === Permission.sendMessagesInThreads;
+  }
+  get useEmbeddedActivities() {
+    return (this.bitfield & Permission.useEmbeddedActivities) === Permission.useEmbeddedActivities;
+  }
+  get moderateMembers() {
+    return (this.bitfield & Permission.moderateMembers) === Permission.moderateMembers;
+  }
+  get viewCreatorMonetizationAnalytics() {
+    return (this.bitfield & Permission.viewCreatorMonetizationAnalytics) === Permission.viewCreatorMonetizationAnalytics;
+  }
+  get useSoundboard() {
+    return (this.bitfield & Permission.useSoundboard) === Permission.useSoundboard;
+  }
+  get createGuildExpressions() {
+    return (this.bitfield & Permission.createGuildExpressions) === Permission.createGuildExpressions;
+  }
+  get createEvents() {
+    return (this.bitfield & Permission.createEvents) === Permission.createEvents;
+  }
+  get useExternalSounds() {
+    return (this.bitfield & Permission.useExternalSounds) === Permission.useExternalSounds;
+  }
+  get sendVoiceMessages() {
+    return (this.bitfield & Permission.sendVoiceMessages) === Permission.sendVoiceMessages;
+  }
+  get sendPolls() {
+    return (this.bitfield & Permission.sendPolls) === Permission.sendPolls;
+  }
+  get useExternalApps() {
+    return (this.bitfield & Permission.useExternalApps) === Permission.useExternalApps;
+  }
+  has(...permissions) {
+    if (permissions.length === 1) {
+      const p = permissions[0];
+      const bit = typeof p === "bigint" ? p : this.#resolve(p);
+      return (this.bitfield & bit) === bit;
+    }
+    for (let i = 0;i < permissions.length; i++) {
+      const p = permissions[i];
+      const bit = typeof p === "bigint" ? p : this.#resolve(p);
+      if ((this.bitfield & bit) !== bit)
+        return false;
+    }
+    return true;
+  }
+  any(...permissions) {
+    if (permissions.length === 1) {
+      const p = permissions[0];
+      const bit = typeof p === "bigint" ? p : this.#resolve(p);
+      return (this.bitfield & bit) !== 0n;
+    }
+    for (let i = 0;i < permissions.length; i++) {
+      const p = permissions[i];
+      const bit = typeof p === "bigint" ? p : this.#resolve(p);
+      if ((this.bitfield & bit) !== 0n)
+        return true;
+    }
+    return false;
+  }
+  add(...permissions) {
+    let bitfield = this.bitfield;
+    for (let i = 0;i < permissions.length; i++) {
+      const p = permissions[i];
+      bitfield |= typeof p === "bigint" ? p : this.#resolve(p);
+    }
+    return new PermissionSet(bitfield);
+  }
+  remove(...permissions) {
+    let bitfield = this.bitfield;
+    for (let i = 0;i < permissions.length; i++) {
+      const p = permissions[i];
+      bitfield &= ~(typeof p === "bigint" ? p : this.#resolve(p));
+    }
+    return new PermissionSet(bitfield);
+  }
+  equals(other) {
+    return this.bitfield === (other instanceof PermissionSet ? other.bitfield : new PermissionSet(other).bitfield);
+  }
+  toString() {
+    return this.bitfield.toString();
+  }
+  toArray() {
+    return Object.keys(Permission).filter((permission) => this.has(permission));
+  }
+  #resolve(permission) {
+    if (typeof permission === "bigint")
+      return permission;
+    if (typeof permission === "number")
+      return BigInt(permission);
+    if (permission instanceof PermissionSet)
+      return permission.bitfield;
+    if (Array.isArray(permission)) {
+      let bit = 0n;
+      for (let i = 0;i < permission.length; i++)
+        bit |= this.#resolve(permission[i]);
+      return bit;
+    }
+    if (typeof permission === "string") {
+      if (permission in Permission)
+        return Permission[permission];
+      if (permission in Permissions)
+        return Permissions[permission];
+      if (permission in PermissionFlagsBits)
+        return BigInt(PermissionFlagsBits[permission]);
+      const lower = permission.charAt(0).toLowerCase() + permission.slice(1);
+      if (lower in Permission)
+        return Permission[lower];
+      return BigInt(permission);
+    }
+    return 0n;
+  }
+}
+
+class PermissionsBitField extends PermissionSet {
+  static Flags = PermissionFlagsBits;
+  static All = Permission;
+  constructor(value = 0n) {
+    super(value);
+  }
+}
+// packages/collection/src/index.ts
+class Collection extends Map {
+  first() {
+    for (const value of this.values())
+      return value;
+    return;
+  }
+  firstKey() {
+    for (const key of this.keys())
+      return key;
+    return;
+  }
+  last() {
+    let value;
+    for (const item of this.values())
+      value = item;
+    return value;
+  }
+  lastKey() {
+    let key;
+    for (const item of this.keys())
+      key = item;
+    return key;
+  }
+  find(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return value;
+    }
+    return;
+  }
+  filter(predicate) {
+    const result = new Collection;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        result.set(key, value);
+    }
+    return result;
+  }
+  map(transform) {
+    const result = [];
+    for (const [key, value] of this) {
+      result.push(transform(value, key, this));
+    }
+    return result;
+  }
+  some(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const [key, value] of this) {
+      if (!predicate(value, key, this))
+        return false;
+    }
+    return true;
+  }
+  each(callback) {
+    for (const [key, value] of this) {
+      callback(value, key, this);
+    }
+    return this;
+  }
+  array() {
+    return [...this.values()];
+  }
+  keyArray() {
+    return [...this.keys()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  clone() {
+    const copy = new Collection;
+    for (const [key, value] of this)
+      copy.set(key, value);
+    return copy;
+  }
+  hasAll(...keys) {
+    for (let i = 0;i < keys.length; i++) {
+      if (!this.has(keys[i]))
+        return false;
+    }
+    return true;
+  }
+  hasAny(...keys) {
+    for (let i = 0;i < keys.length; i++) {
+      if (this.has(keys[i]))
+        return true;
+    }
+    return false;
+  }
+  findKey(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return key;
+    }
+    return;
+  }
+  someEntry(predicate) {
+    return this.some(predicate);
+  }
+  sweep(predicate) {
+    let removed = 0;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this) && this.delete(key))
+        removed++;
+    }
+    return removed;
+  }
+  firstEntry() {
+    for (const [key, value] of this)
+      return [key, value];
+    return;
+  }
+  lastEntry() {
+    let entry;
+    for (const item of this)
+      entry = [item[0], item[1]];
+    return entry;
+  }
+}
+
+// packages/managers/src/base.ts
+class Manager {
+  cache = new Collection;
+  get(id) {
+    return this.cache.get(id);
+  }
+  has(id) {
+    return this.cache.has(id);
+  }
+  set(id, value) {
+    this.cache.set(id, value);
+    return this;
+  }
+  delete(id) {
+    return this.cache.delete(id);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  first() {
+    return this.cache.first();
+  }
+  values() {
+    return this.cache.array();
+  }
+  find(predicate) {
+    return this.cache.find(predicate);
+  }
+  [Symbol.iterator]() {
+    return this.cache[Symbol.iterator]();
+  }
+}
+
+class ResourceManager extends Manager {
+  #fetcher;
+  #key;
+  constructor(fetcher, key) {
+    super();
+    if (typeof fetcher !== "function" || typeof key !== "function")
+      throw new TypeError("ResourceManager requires fetcher and key functions.");
+    this.#fetcher = fetcher;
+    this.#key = key;
+  }
+  async resolve(id) {
+    return this.get(id) ?? this.fetch(id);
+  }
+  async fetch(id) {
+    const resource = await this.#fetcher(id);
+    this.set(id, resource);
+    return resource;
+  }
+  async fetchMany(ids) {
+    return Promise.all([...ids].map((id) => this.resolve(id)));
+  }
+  upsert(resource) {
+    const key = this.#key(resource);
+    this.set(key, resource);
+    return resource;
+  }
+  update(resource) {
+    return this.upsert(resource);
+  }
+}
+// packages/rest/src/routes.ts
+var Routes = {
+  user: () => "/users/@me",
+  userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
+  guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  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`,
+  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
+  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/index.ts
+class RESTError extends Error {
+  status;
+  code;
+  errors;
+  method;
+  path;
+  constructor(message, status, code, errors, options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "RESTError";
+    this.status = status;
+    this.code = code;
+    this.errors = errors;
+    this.method = options.method;
+    this.path = options.path;
+  }
+}
+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();
+      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;
+    }
+  };
+}
+
+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;
+  }
+  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;
+    });
+    await this.#abortable(previous, options.signal, path);
+    try {
+      for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
+        await this.#wait(bucket, options.signal, path);
+        await this.#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);
+        try {
+          const response = await fetch(`${this.#baseURL}${path}`, {
+            method: normalizedMethod,
+            headers: {
+              ...this.#token ? { Authorization: `Bot ${this.#token}` } : {},
+              "Content-Type": "application/json",
+              "User-Agent": "Lunibee/0.1.0"
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            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 });
+    } finally {
+      release();
+    }
+  }
+  get(path, options) {
+    return this.request("GET", path, undefined, options);
+  }
+  post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+  put(path, body, options) {
+    return this.request("PUT", path, body, options);
+  }
+  delete(path, options) {
+    return this.request("DELETE", path, undefined, options);
+  }
+  async#wait(bucket, signal, path) {
+    const delay = bucket.resetAt - Date.now();
+    if (bucket.remaining <= 0 && delay > 0)
+      await this.#sleep(delay, signal, path);
+  }
+  async#waitGlobal(signal, path) {
+    const delay = this.#globalResetAt - Date.now();
+    if (delay > 0)
+      await this.#sleep(delay, signal, path);
+  }
+  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 });
+    });
+  }
+  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 }))
+    ]);
+  }
+  #abortError(path, reason) {
+    return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+  }
+  async#readPayload(response) {
+    if (response.status === 204)
+      return;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json"))
+      return response.json().catch(() => {
+        return;
+      });
+    return response.text().catch(() => {
+      return;
+    });
+  }
+  #errorData(payload) {
+    if (!payload || typeof payload !== "object")
+      return {};
+    const data = payload;
+    return {
+      message: typeof data.message === "string" ? data.message : undefined,
+      code: typeof data.code === "number" ? data.code : undefined,
+      retry_after: typeof data.retry_after === "number" ? data.retry_after : undefined,
+      global: data.global === true
+    };
+  }
+  #retryAfter(response, data) {
+    const header = Number(response.headers.get("Retry-After"));
+    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");
+  }
+  #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;
+      }
+    }
+    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);
+    }
+    return bucket;
+  }
+}
+
+// packages/structures/src/base.ts
+class BaseStructure {
+  id;
+  constructor(id) {
+    if (!/^\d{1,20}$/.test(id))
+      throw new TypeError("A Discord structure requires a valid snowflake ID.");
+    this.id = id;
+  }
+  toString() {
+    return this.id;
+  }
+}
+
+class User extends BaseStructure {
+  username;
+  globalName;
+  avatar;
+  bot;
+  system;
+  flags;
+  constructor(data) {
+    super(data.id);
+    if (!data.username)
+      throw new TypeError("A Discord user requires a username.");
+    this.username = data.username;
+    this.globalName = data.global_name ?? null;
+    this.avatar = data.avatar ?? null;
+    this.bot = data.bot ?? false;
+    this.system = data.system ?? false;
+    this.flags = data.public_flags ?? 0;
+  }
+  get displayName() {
+    return this.globalName ?? this.username;
+  }
+  avatarURL(options = {}) {
+    if (!this.avatar)
+      return null;
+    const extension = options.extension ?? (this.avatar.startsWith("a_") ? "gif" : "png");
+    return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${extension}${options.size ? `?size=${options.size}` : ""}`;
+  }
+  defaultAvatarURL() {
+    return `https://cdn.discordapp.com/embed/avatars/${Number(BigInt(this.id) % 5n)}.png`;
+  }
+  displayAvatarURL(options = {}) {
+    return this.avatarURL(options) ?? this.defaultAvatarURL();
+  }
+}
+
+class Channel extends BaseStructure {
+  type;
+  name;
+  guildId;
+  #context;
+  constructor(data, context) {
+    super(data.id);
+    if (!Number.isInteger(data.type) || data.type < 0)
+      throw new RangeError("A Discord channel requires a valid channel type.");
+    this.type = data.type;
+    this.name = data.name;
+    this.guildId = data.guild_id;
+    this.#context = context;
+  }
+  sendMessage(options) {
+    if (!this.#context)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.sendMessage(this.id, options);
+  }
+}
+
+class Guild extends BaseStructure {
+  name;
+  preferredLocale;
+  ownerId;
+  constructor(data) {
+    super(data.id);
+    if (!data.name)
+      throw new TypeError("A Discord guild requires a name.");
+    this.name = data.name;
+    this.preferredLocale = data.preferred_locale;
+    this.ownerId = data.owner_id;
+  }
+}
+// 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
+};
+var InteractionResponseType = {
+  Pong: 1,
+  ChannelMessage: 4,
+  DeferredChannelMessage: 5,
+  DeferredMessageUpdate: 6,
+  MessageUpdate: 7,
+  Autocomplete: 8,
+  Modal: 9
+};
+
+class InteractionResponse {
+  type;
+  data;
+  constructor(type, data) {
+    if (!Number.isFinite(type))
+      throw new TypeError("Interaction response type must be finite.");
+    this.type = type;
+    this.data = data;
+  }
+  toJSON() {
+    return this.data === undefined ? { type: this.type } : { type: this.type, data: this.data };
+  }
+  static message(options) {
+    const data = { ...options };
+    if (options.ephemeral) {
+      data.flags = (typeof options.flags === "number" ? options.flags : 0) | 64;
+    }
+    return new InteractionResponse(InteractionResponseType.ChannelMessage, data);
+  }
+  static defer(ephemeral = false) {
+    return new InteractionResponse(InteractionResponseType.DeferredChannelMessage, ephemeral ? { flags: 64 } : undefined);
+  }
+  static pong() {
+    return new InteractionResponse(InteractionResponseType.Pong);
+  }
+}
+
+class Interaction {
+  id;
+  applicationId;
+  token;
+  guildId;
+  channelId;
+  type;
+  data;
+  replied = false;
+  deferred = false;
+  #client;
+  constructor(client, data) {
+    if (!data.id || !data.token)
+      throw new TypeError("Interaction ID and token are required.");
+    this.#client = client;
+    this.id = data.id;
+    this.applicationId = data.application_id;
+    this.token = data.token;
+    this.guildId = data.guild_id;
+    this.channelId = data.channel_id;
+    this.type = data.type;
+    this.data = data;
+  }
+  isChatInputCommand() {
+    return this.type === InteractionType.ApplicationCommand;
+  }
+  isMessageComponent() {
+    return this.type === InteractionType.MessageComponent;
+  }
+  isModalSubmit() {
+    return this.type === InteractionType.ModalSubmit;
+  }
+  isAutocomplete() {
+    return this.type === InteractionType.ApplicationCommandAutocomplete;
+  }
+  assertUnacknowledged() {
+    if (this.replied || this.deferred)
+      throw new Error("Interaction has already been acknowledged.");
+  }
+  assertAcknowledged() {
+    if (!this.replied && !this.deferred)
+      throw new Error("Interaction has not been acknowledged.");
+  }
+  postResponse(response) {
+    return this.#client.postInteractionResponse(this.id, this.token, response);
+  }
+  async reply(options) {
+    this.assertUnacknowledged();
+    const payload = typeof options === "string" ? { content: options } : options;
+    const result = await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.message(payload));
+    this.replied = true;
+    return result;
+  }
+  async deferReply(ephemeral = false) {
+    this.assertUnacknowledged();
+    await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.defer(ephemeral));
+    this.deferred = true;
+  }
+  editReply(options) {
+    this.assertAcknowledged();
+    return this.#client.editInteractionReply(this.token, options);
+  }
+  deleteReply() {
+    this.assertAcknowledged();
+    return this.#client.deleteInteractionReply(this.token);
+  }
+  followUp(options) {
+    const payload = typeof options === "string" ? { content: options } : options;
+    return this.#client.followUpInteraction(this.token, payload);
+  }
+  async update(options) {
+    this.assertUnacknowledged();
+    const payload = typeof options === "string" ? { content: options } : options;
+    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
+    this.replied = true;
+    return result;
+  }
+  async showModal(modal) {
+    this.assertUnacknowledged();
+    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.Modal, modal));
+    this.replied = true;
+    return result;
+  }
+}
+
+class CommandInteraction extends Interaction {
+  get commandName() {
+    return typeof this.data.data?.name === "string" ? this.data.data.name : "";
+  }
+}
+
+class ComponentInteraction extends Interaction {
+  get customId() {
+    return this.data?.data?.custom_id ?? "";
+  }
+  get componentType() {
+    return this.data?.data?.component_type ?? 0;
+  }
+  get values() {
+    return this.data?.data?.values ?? [];
+  }
+  async deferUpdate() {
+    this.assertUnacknowledged();
+    await this.postResponse(new InteractionResponse(InteractionResponseType.DeferredMessageUpdate));
+    this.deferred = true;
+  }
+  async update(options) {
+    this.assertUnacknowledged();
+    const payload = typeof options === "string" ? { content: options } : options;
+    const result = await this.postResponse(new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
+    this.replied = true;
+    return result;
+  }
+}
+function createInteraction(client, data) {
+  switch (data.type) {
+    case InteractionType.ApplicationCommand:
+    case InteractionType.ApplicationCommandAutocomplete:
+      return new CommandInteraction(client, data);
+    case InteractionType.MessageComponent:
+    case InteractionType.ModalSubmit:
+      return new ComponentInteraction(client, data);
+    default:
+      return new Interaction(client, data);
+  }
+}
+
+// packages/structures/src/index.ts
+class Message extends BaseStructure {
+  content;
+  author;
+  channelId;
+  channel;
+  guildId;
+  flags;
+  createdAt;
+  attachments;
+  embeds;
+  mentions;
+  mentionRoles;
+  pinned;
+  mentionEveryone;
+  type;
+  reference;
+  referencedMessage;
+  #context;
+  constructor(data, context) {
+    super(data.id);
+    if (!/^\d{1,20}$/.test(data.channel_id))
+      throw new TypeError("Message channel_id must be a valid snowflake.");
+    this.content = data.content ?? "";
+    this.author = new User(data.author);
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id;
+    this.flags = data.flags ?? 0;
+    this.createdAt = new Date(data.timestamp ?? Number((BigInt(this.id) >> 22n) + 1420070400000n));
+    this.attachments = data.attachments ?? [];
+    this.embeds = data.embeds ?? [];
+    this.mentions = (data.mentions ?? []).map((user) => new User(user));
+    this.mentionRoles = data.mention_roles ?? [];
+    this.pinned = data.pinned ?? false;
+    this.mentionEveryone = data.mention_everyone ?? false;
+    this.type = data.type ?? 0;
+    this.reference = data.message_reference;
+    this.referencedMessage = data.referenced_message ? new Message(data.referenced_message, context) : data.referenced_message === null ? null : undefined;
+    this.#context = context;
+    this.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
+  }
+  get embedsSuppressed() {
+    return (this.flags & 4) !== 0;
+  }
+  edit(options) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.editMessage(this.channelId, this.id, options);
+  }
+  delete() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.deleteMessage(this.channelId, this.id);
+  }
+  crosspost() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.crosspostMessage(this.channelId, this.id);
+  }
+  reply(options) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    const payload = typeof options === "string" ? { content: options } : { ...options };
+    payload.message_reference = {
+      message_id: this.id,
+      channel_id: this.channelId,
+      guild_id: this.guildId
+    };
+    return this.#context.sendMessage(this.channelId, payload);
+  }
+}
+
+// packages/managers/src/message.ts
+class MessageManager {
+  cache = new Collection;
+  #rest;
+  #context;
+  #channelId;
+  constructor(rest, context, channelId) {
+    if (!channelId)
+      throw new TypeError("Channel ID is required.");
+    this.#rest = rest;
+    this.#context = context;
+    this.#channelId = channelId;
+  }
+  async resolve(messageId) {
+    return this.cache.get(messageId) ?? this.fetch(messageId);
+  }
+  async send(options) {
+    const data = await this.#rest.post(Routes.channelMessages(this.#channelId), options);
+    return this.upsert(data);
+  }
+  async fetch(messageId) {
+    const data = await this.#rest.get(Routes.message(this.#channelId, messageId));
+    const message = Array.isArray(data) ? data[0] : data;
+    if (!message)
+      throw new Error("Discord returned no message payload.");
+    return this.upsert(message);
+  }
+  fetchMany(messageIds) {
+    return Promise.all(Array.from(messageIds, (messageId) => this.fetch(messageId)));
+  }
+  upsert(data) {
+    const existing = this.cache.get(data.id);
+    const message = new Message(data, this.#context);
+    if (existing) {
+      Object.assign(existing, message);
+      return existing;
+    }
+    this.cache.set(message.id, message);
+    return message;
+  }
+  delete(messageId) {
+    return this.cache.delete(messageId);
+  }
+}
+
+// packages/managers/src/thread.ts
+class ThreadManager {
+  #rest;
+  #context;
+  #channelId;
+  constructor(rest, context, channelId) {
+    if (!channelId)
+      throw new TypeError("Channel ID is required.");
+    this.#rest = rest;
+    this.#context = context;
+    this.#channelId = channelId;
+  }
+  async createFromMessage(messageId, options) {
+    const data = await this.#rest.post(Routes.messageThread(this.#channelId, messageId), {
+      name: options.name,
+      auto_archive_duration: options.autoArchiveDuration,
+      rate_limit_per_user: options.rateLimitPerUser
+    });
+    return new Channel(data, this.#context);
+  }
+}
+// packages/managers/src/application.ts
+class ApplicationCommandManager {
+  #rest;
+  #applicationId;
+  constructor(rest, applicationId) {
+    this.#rest = rest;
+    this.#applicationId = applicationId;
+  }
+  fetch() {
+    return this.#rest.get(Routes.applicationCommands(this.#applicationId));
+  }
+  create(data) {
+    return this.#rest.post(Routes.applicationCommands(this.#applicationId), data);
+  }
+  set(commands) {
+    return this.#rest.put(Routes.applicationCommands(this.#applicationId), commands);
+  }
+  edit(commandId, data) {
+    return this.#rest.patch(Routes.applicationCommand(this.#applicationId, commandId), data);
+  }
+  async delete(commandId) {
+    await this.#rest.delete(Routes.applicationCommand(this.#applicationId, commandId));
+  }
+  fetchGuild(guildId) {
+    return this.#rest.get(Routes.guildApplicationCommands(this.#applicationId, guildId));
+  }
+  createGuild(guildId, data) {
+    return this.#rest.post(Routes.guildApplicationCommands(this.#applicationId, guildId), data);
+  }
+  setGuild(guildId, commands) {
+    return this.#rest.put(Routes.guildApplicationCommands(this.#applicationId, guildId), commands);
+  }
+  editGuild(guildId, commandId, data) {
+    return this.#rest.patch(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId), data);
+  }
+  async deleteGuild(guildId, commandId) {
+    await this.#rest.delete(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId));
+  }
+}
+
+// packages/managers/src/index.ts
+class UserManager extends ResourceManager {
+  constructor(rest) {
+    super(async (id) => new User(await rest.get(Routes.userById(id))), (user) => user.id);
+  }
+}
+
+class GuildManager extends ResourceManager {
+  constructor(rest) {
+    super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
+  }
+}
+var MessageCreateOptions = undefined;
+var MessageEditOptions = undefined;
+var MessageFetchOptions = undefined;
+var MessageThreadOptions = undefined;
+var ReactionFetchOptions = undefined;
+
+class ChannelManager extends Manager {
+  #rest;
+  #context;
+  #messageManagers = new Map;
+  constructor(rest) {
+    super();
+    this.#rest = rest;
+    this.#context = {
+      sendMessage: (channelId, options) => this.send(channelId, options),
+      editMessage: (channelId, messageId, options) => this.editMessage(channelId, messageId, options),
+      deleteMessage: (channelId, messageId) => this.deleteMessage(channelId, messageId),
+      crosspostMessage: (channelId, messageId) => this.crosspostMessage(channelId, messageId)
+    };
+  }
+  messages(channelId) {
+    let manager = this.#messageManagers.get(channelId);
+    if (!manager) {
+      manager = new MessageManager(this.#rest, this.#context, channelId);
+      this.#messageManagers.set(channelId, manager);
+    }
+    return manager;
+  }
+  threads(channelId) {
+    return new ThreadManager(this.#rest, this.#context, channelId);
+  }
+  async fetch(channelId) {
+    const data = await this.#rest.get(Routes.channel(channelId));
+    return this.upsert(data);
+  }
+  async resolve(channelId) {
+    return this.get(channelId) ?? this.fetch(channelId);
+  }
+  upsert(data) {
+    const existing = this.get(data.id);
+    const channel = new Channel(data, this.#context);
+    if (existing) {
+      Object.assign(existing, channel);
+      return existing;
+    }
+    this.set(channel.id, channel);
+    return channel;
+  }
+  update(channel) {
+    return this.set(channel.id, channel);
+  }
+  send(channelId, options) {
+    return this.messages(channelId).send(options);
+  }
+  sendMessage(channelId, options) {
+    return this.send(channelId, options);
+  }
+  async fetchMessage(channelId, messageId, options = {}) {
+    return this.messages(channelId).fetch(messageId);
+  }
+  fetchMessages(channelId, query) {
+    if (isMessageQuery(query)) {
+      const params = new URLSearchParams;
+      if (query.before)
+        params.set("before", query.before);
+      if (query.after)
+        params.set("after", query.after);
+      if (query.around)
+        params.set("around", query.around);
+      if (query.limit !== undefined)
+        params.set("limit", String(query.limit));
+      const suffix = params.toString();
+      return this.#rest.get(`${Routes.channelMessages(channelId)}${suffix ? `?${suffix}` : ""}`).then((data) => data.map((item) => this.messages(channelId).upsert(item)));
+    }
+    return this.messages(channelId).fetchMany(query);
+  }
+  upsertMessage(data) {
+    return this.messages(data.channel_id).upsert(data);
+  }
+  async editMessage(channelId, messageId, options) {
+    const data = await this.#rest.patch(Routes.message(channelId, messageId), options);
+    return this.messages(channelId).upsert(data);
+  }
+  async deleteMessage(channelId, messageId) {
+    await this.#rest.delete(Routes.message(channelId, messageId));
+    this.messages(channelId).delete(messageId);
+  }
+  deleteCachedMessage(channelId, messageId) {
+    return this.messages(channelId).delete(messageId);
+  }
+  async crosspostMessage(channelId, messageId) {
+    const data = await this.#rest.post(Routes.crosspostMessage(channelId, messageId));
+    return this.messages(channelId).upsert(data);
+  }
+  async bulkDeleteMessages(channelId, messageIds) {
+    const ids = [...messageIds];
+    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));
+  }
+  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);
+  }
+  delete(channelId) {
+    this.#messageManagers.delete(channelId);
+    return super.delete(channelId);
+  }
+  clear() {
+    this.#messageManagers.clear();
+    super.clear();
+  }
+}
+function isMessageQuery(value) {
+  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
+}
+
+// packages/types/src/index.ts
+var GatewayIntentBits = {
+  Guilds: 1 << 0,
+  GuildMembers: 1 << 1,
+  GuildModeration: 1 << 2,
+  GuildExpressions: 1 << 3,
+  GuildIntegrations: 1 << 4,
+  GuildWebhooks: 1 << 5,
+  GuildInvites: 1 << 6,
+  GuildVoiceStates: 1 << 7,
+  GuildPresences: 1 << 8,
+  GuildMessages: 1 << 9,
+  GuildMessageReactions: 1 << 10,
+  GuildMessageTyping: 1 << 11,
+  DirectMessages: 1 << 12,
+  DirectMessageReactions: 1 << 13,
+  DirectMessageTyping: 1 << 14,
+  MessageContent: 1 << 15,
+  GuildScheduledEvents: 1 << 16,
+  AutoModerationConfiguration: 1 << 20,
+  AutoModerationExecution: 1 << 21,
+  GuildMessagePolls: 1 << 24,
+  DirectMessagePolls: 1 << 25
+};
+var IntentBits = {
+  guild: 1 << 0,
+  guilds: 1 << 0,
+  guildMembers: 1 << 1,
+  guildModeration: 1 << 2,
+  guildBans: 1 << 2,
+  guildExpressions: 1 << 3,
+  guildEmojis: 1 << 3,
+  guildEmojisAndStickers: 1 << 3,
+  guildIntegrations: 1 << 4,
+  guildWebhooks: 1 << 5,
+  guildInvites: 1 << 6,
+  guildVoiceStates: 1 << 7,
+  guildPresences: 1 << 8,
+  guildMessages: 1 << 9,
+  guildMessage: 1 << 9,
+  guildMessageReactions: 1 << 10,
+  guildMessageTyping: 1 << 11,
+  directMessages: 1 << 12,
+  directMessageReactions: 1 << 13,
+  directMessageTyping: 1 << 14,
+  messageContent: 1 << 15,
+  guildScheduledEvents: 1 << 16,
+  autoModerationConfiguration: 1 << 20,
+  autoModerationExecution: 1 << 21,
+  guildMessagePolls: 1 << 24,
+  directMessagePolls: 1 << 25
+};
+var Intents = IntentBits;
+function resolveGatewayIntents(intents) {
+  if (typeof intents === "number")
+    return intents;
+  if (Array.isArray(intents)) {
+    return intents.reduce((acc, intent) => {
+      return acc | resolveGatewayIntents(intent);
+    }, 0);
+  }
+  if (typeof intents === "string") {
+    if (intents in GatewayIntentBits)
+      return GatewayIntentBits[intents];
+    if (intents in IntentBits)
+      return IntentBits[intents];
+    const lower = intents.charAt(0).toLowerCase() + intents.slice(1);
+    if (lower in IntentBits)
+      return IntentBits[lower];
+    const num = Number(intents);
+    if (!Number.isNaN(num))
+      return num;
+  }
+  return 0;
+}
+var MessageFlags = {
+  Crossposted: 1,
+  IsCrosspost: 2,
+  SuppressEmbeds: 4,
+  SourceMessageDeleted: 8,
+  Urgent: 16,
+  HasThread: 32,
+  Ephemeral: 64,
+  Loading: 128,
+  IsComponentsV2: 32768
+};
+var ChannelType = {
+  GuildText: 0,
+  DM: 1,
+  GuildVoice: 2,
+  GroupDM: 3,
+  GuildCategory: 4,
+  GuildAnnouncement: 5,
+  AnnouncementThread: 10,
+  PublicThread: 11,
+  PrivateThread: 12,
+  GuildStageVoice: 13,
+  GuildDirectory: 14,
+  GuildForum: 15,
+  GuildMedia: 16
+};
+var ApplicationCommandOptionType = {
+  SubCommand: 1,
+  SubCommandGroup: 2,
+  String: 3,
+  Integer: 4,
+  Boolean: 5,
+  User: 6,
+  Channel: 7,
+  Role: 8,
+  Mentionable: 9,
+  Number: 10,
+  Attachment: 11
+};
+var ApplicationCommandType = {
+  ChatInput: 1,
+  User: 2,
+  Message: 3
+};
+
+// packages/ws/src/index.ts
+var GatewayOpcodes = {
+  Dispatch: 0,
+  Heartbeat: 1,
+  Identify: 2,
+  PresenceUpdate: 3,
+  VoiceStateUpdate: 4,
+  Resume: 6,
+  Reconnect: 7,
+  RequestGuildMembers: 8,
+  InvalidSession: 9,
+  Hello: 10,
+  HeartbeatAck: 11
+};
+class GatewayError extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = "GatewayError";
+    this.code = code;
+  }
+}
+
+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;
+  #closed = false;
+  #attempt = 0;
+  #reconnectTimer;
+  #connectPromise;
+  #resolveConnect;
+  #rejectConnect;
+  #listeners = new Map;
+  #sendTimestamps = [];
+  constructor(options) {
+    if (!options.token?.trim())
+      throw new TypeError("A Gateway token is required.");
+    const resolvedIntents = resolveGatewayIntents(options.intents);
+    if (!Number.isInteger(resolvedIntents) || resolvedIntents < 0)
+      throw new TypeError("Gateway intents must be a non-negative integer.");
+    this.#options = {
+      shardId: 0,
+      shardCount: 1,
+      reconnect: true,
+      maxReconnectAttempts: Infinity,
+      reconnectBaseDelay: 1000,
+      reconnectMaxDelay: 30000,
+      heartbeatAckTimeout: 1e4,
+      zombieTimeout: 30000,
+      properties: {
+        os: "Android",
+        browser: "Discord Android",
+        device: "Discord Android"
+      },
+      presence: { status: "online", activities: [], afk: false, since: null },
+      ...options
+    };
+    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");
+  }
+  connect(url = "wss://gateway.discord.gg/?v=10&encoding=json") {
+    if (this.state === "CLOSED" /* Closed */)
+      throw new GatewayError("Gateway has been permanently closed.");
+    if (this.#connectPromise)
+      return this.#connectPromise;
+    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;
+  }
+  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.#setState("CLOSED" /* Closed */);
+  }
+  emit(event, data) {
+    this.#emit(event, data);
+  }
+  on(event, listener) {
+    if (!event || typeof listener !== "function")
+      throw new TypeError("Gateway event and listener are required.");
+    let listeners = this.#listeners.get(event);
+    if (!listeners)
+      this.#listeners.set(event, listeners = new Set);
+    listeners.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  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 false;
+    const now = Date.now();
+    while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
+      this.#sendTimestamps.shift();
+    if (this.#sendTimestamps.length >= 115) {
+      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);
+      return false;
+    }
+  }
+  setPresence(data) {
+    this.#options.presence = { ...this.#options.presence, ...data };
+    const payload = {
+      since: this.#options.presence.since ?? null,
+      activities: this.#options.presence.activities ?? [],
+      status: this.#options.presence.status ?? "online",
+      afk: Boolean(this.#options.presence.afk)
+    };
+    return this.send({
+      op: GatewayOpcodes.PresenceUpdate,
+      d: payload,
+      s: null,
+      t: null
+    });
+  }
+  setVoiceState(data) {
+    return this.send({
+      op: GatewayOpcodes.VoiceStateUpdate,
+      d: data,
+      s: null,
+      t: null
+    });
+  }
+  requestGuildMembers(data) {
+    return this.send({
+      op: GatewayOpcodes.RequestGuildMembers,
+      d: data,
+      s: null,
+      t: null
+    });
+  }
+  #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);
+      return;
+    }
+    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");
+      return;
+    }
+    if (typeof payload.s === "number")
+      this.#sequence = payload.s;
+    switch (payload.op) {
+      case GatewayOpcodes.Dispatch:
+        this.#setState("DISPATCH" /* Dispatch */);
+        this.#handleDispatch(payload.t, payload.d);
+        break;
+      case GatewayOpcodes.Hello:
+        this.#handleHello(payload.d);
+        break;
+      case GatewayOpcodes.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;
+    }
+  }
+  #handleDispatch(event, data) {
+    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"));
+        return;
+      }
+      this.#sessionId = ready.session_id;
+      this.#resumeURL = ready.resume_gateway_url;
+      this.#attempt = 0;
+      this.#setState("READY" /* Ready */);
+      this.#emit("ready", data);
+    }
+    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);
+    this.#identifyOrResume();
+  }
+  #identifyOrResume() {
+    if (this.#sessionId && this.#sequence !== null && this.#resumeURL) {
+      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
+      });
+      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.#clearTimers();
+    const action = this.#closeAction(code);
+    this.#emit("close", { code, action });
+    if (this.#closed || !this.#options.reconnect || action === "stop") {
+      this.#setState(this.#closed ? "CLOSED" /* Closed */ : "CONNECT" /* Connect */);
+      if (this.#connectPromise)
+        this.#settleConnect(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
+      return;
+    }
+    if (action === "identify") {
+      this.#sequence = null;
+      this.#sessionId = undefined;
+    }
+    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)
+      return;
+    if (this.#attempt >= this.#options.maxReconnectAttempts) {
+      this.#settleConnect(new GatewayError("Gateway reconnect attempts exhausted."));
+      this.#setState("CONNECT" /* Connect */);
+      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);
+  }
+  #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;
+  }
+  #clearTimers() {
+    if (this.#reconnectTimer)
+      clearTimeout(this.#reconnectTimer);
+    if (this.#zombieTimer)
+      clearInterval(this.#zombieTimer);
+    this.#reconnectTimer = undefined;
+    this.#zombieTimer = undefined;
+    this.#clearHeartbeatTimers();
+  }
+  #normalizeError(error) {
+    return error instanceof GatewayError ? error : new GatewayError("Gateway connection failed.", undefined, {
+      cause: error
+    });
+  }
+  #emitError(error) {
+    this.#emit("error", error instanceof Error ? error : new GatewayError(String(error)));
+  }
+  #emit(event, data) {
+    for (const listener of this.#listeners.get(event) ?? []) {
+      try {
+        const result = listener(data);
+        if (result && typeof result.then === "function")
+          Promise.resolve(result).catch((error) => {
+            if (event !== "error")
+              this.#emitError(error);
+          });
+      } catch (error) {
+        if (event !== "error")
+          this.#emitError(error);
+      }
+    }
+  }
+  #setState(next) {
+    if (this.state === next)
+      return;
+    const previous = this.state;
+    this.state = next;
+    this.#emit("stateChange", { previous, next });
+  }
+}
+// packages/builders/src/embed.ts
+class EmbedBuilder {
+  #data = {};
+  setTitle(value) {
+    this.#data.title = validate(value, 256, "Embed title");
+    return this;
+  }
+  setDescription(value) {
+    this.#data.description = validate(value, 4096, "Embed description");
+    return this;
+  }
+  setURL(value) {
+    this.#data.url = url(value, "Embed URL");
+    return this;
+  }
+  setColor(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 16777215)
+      throw new RangeError("Embed color must be an integer between 0 and 16777215.");
+    this.#data.color = value;
+    return this;
+  }
+  setTimestamp(value = new Date) {
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime()))
+      throw new RangeError("Embed timestamp must be a valid date.");
+    this.#data.timestamp = date.toISOString();
+    return this;
+  }
+  setFooter(value) {
+    this.#data.footer = {
+      text: validate(value.text, 2048, "Footer text"),
+      ...value.icon_url ? { icon_url: url(value.icon_url, "Footer icon URL") } : {}
+    };
+    return this;
+  }
+  setAuthor(value) {
+    this.#data.author = {
+      name: validate(value.name, 256, "Author name"),
+      ...value.url ? { url: url(value.url, "Author URL") } : {},
+      ...value.icon_url ? { icon_url: url(value.icon_url, "Author icon URL") } : {}
+    };
+    return this;
+  }
+  setThumbnail(value) {
+    const valueURL = typeof value === "string" ? value : value.url;
+    this.#data.thumbnail = { url: url(valueURL, "Thumbnail URL") };
+    return this;
+  }
+  setImage(value) {
+    const valueURL = typeof value === "string" ? value : value.url;
+    this.#data.image = { url: url(valueURL, "Image URL") };
+    return this;
+  }
+  addFields(...fields) {
+    if (!fields.length)
+      throw new TypeError("At least one embed field is required.");
+    const current = this.#data.fields ?? [];
+    if (current.length + fields.length > 25)
+      throw new RangeError("An embed cannot contain more than 25 fields.");
+    for (const field of fields) {
+      validate(field.name, 256, "Embed field name");
+      validate(field.value, 1024, "Embed field value");
+    }
+    this.#data.fields = [...current, ...fields.map((field) => ({ ...field }))];
+    return this;
+  }
+  setFields(fields) {
+    this.#data.fields = [];
+    return this.addFields(...fields);
+  }
+  spliceFields(index, deleteCount, ...fields) {
+    const current = [...this.#data.fields ?? []];
+    if (!Number.isInteger(index) || !Number.isInteger(deleteCount) || index < 0 || deleteCount < 0)
+      throw new RangeError("Field index and delete count must be non-negative integers.");
+    current.splice(index, deleteCount, ...fields);
+    if (current.length > 25)
+      throw new RangeError("An embed cannot contain more than 25 fields.");
+    this.#data.fields = current;
+    return this;
+  }
+  clearFields() {
+    delete this.#data.fields;
+    return this;
+  }
+  clearTitle() {
+    delete this.#data.title;
+    return this;
+  }
+  clearDescription() {
+    delete this.#data.description;
+    return this;
+  }
+  get data() {
+    return this.toJSON();
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+function validate(value, max, field) {
+  if (typeof value !== "string" || value.length === 0 || value.length > max)
+    throw new RangeError(`${field} must contain 1-${max} characters.`);
+  return value;
+}
+function url(value, field) {
+  try {
+    return new URL(value).toString();
+  } catch (error) {
+    throw new TypeError(`${field} must be a valid URL.`, { cause: error });
+  }
+}
+// packages/builders/src/components.ts
+var ComponentType = {
+  ActionRow: 1,
+  Button: 2,
+  StringSelect: 3,
+  TextInput: 4,
+  UserSelect: 5,
+  RoleSelect: 6,
+  MentionableSelect: 7,
+  ChannelSelect: 8
+};
+var ButtonStyle = {
+  Primary: 1,
+  Secondary: 2,
+  Success: 3,
+  Danger: 4,
+  Link: 5
+};
+class ActionRowBuilder {
+  #components = [];
+  addComponents(...components) {
+    if (!components.length)
+      throw new TypeError("At least one component is required.");
+    if (this.#components.length + components.length > 5)
+      throw new RangeError("An action row cannot contain more than 5 components.");
+    this.#components.push(...components);
+    return this;
+  }
+  clearComponents() {
+    this.#components.length = 0;
+    return this;
+  }
+  toJSON() {
+    return {
+      type: ComponentType.ActionRow,
+      components: this.#components.map((component) => component.toJSON())
+    };
+  }
+}
+
+class StringSelectBuilder {
+  #data = {
+    type: ComponentType.StringSelect
+  };
+  setCustomId(value) {
+    validateText(value, 100, "Component custom ID");
+    this.#data.custom_id = value;
+    return this;
+  }
+  setPlaceholder(value) {
+    validateText(value, 150, "Component placeholder");
+    this.#data.placeholder = value;
+    return this;
+  }
+  setMinValues(value) {
+    validateCount(value, "min_values", 0);
+    this.#data.min_values = value;
+    return this;
+  }
+  setMaxValues(value) {
+    validateCount(value, "max_values", 1);
+    this.#data.max_values = value;
+    return this;
+  }
+  setRequired(value = true) {
+    this.#data.required = value;
+    return this;
+  }
+  setDisabled(value = true) {
+    this.#data.disabled = value;
+    return this;
+  }
+  addOptions(...options) {
+    if (!options.length)
+      throw new TypeError("At least one select option is required.");
+    const current = this.#data.options ?? [];
+    if (current.length + options.length > 25)
+      throw new RangeError("A string select cannot contain more than 25 options.");
+    for (const option of options) {
+      validateText(option.label, 100, "Select option label");
+      validateText(option.value, 100, "Select option value");
+      if (option.description)
+        validateText(option.description, 100, "Select option description");
+    }
+    this.#data.options = [
+      ...current,
+      ...options.map((option) => ({ ...option }))
+    ];
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+
+class ButtonBuilder {
+  #data = {
+    type: ComponentType.Button,
+    style: ButtonStyle.Secondary
+  };
+  setStyle(style) {
+    this.#data.style = style;
+    if (style === ButtonStyle.Link)
+      delete this.#data.custom_id;
+    return this;
+  }
+  setCustomId(value) {
+    validateText(value, 100, "Button custom ID");
+    if (this.#data.style === ButtonStyle.Link)
+      throw new TypeError("Link buttons cannot use custom IDs.");
+    this.#data.custom_id = value;
+    return this;
+  }
+  setLabel(value) {
+    validateText(value, 80, "Button label");
+    this.#data.label = value;
+    return this;
+  }
+  setURL(value) {
+    validateText(value, 512, "Button URL");
+    let url2;
+    try {
+      url2 = new URL(value);
+    } catch (error) {
+      throw new TypeError("Button URL must be a valid URL.", { cause: error });
+    }
+    this.#data.style = ButtonStyle.Link;
+    delete this.#data.custom_id;
+    this.#data.url = url2.toString();
+    return this;
+  }
+  setEmoji(emoji) {
+    this.#data.emoji = typeof emoji === "string" ? { name: emoji } : { ...emoji };
+    return this;
+  }
+  setDisabled(value = true) {
+    this.#data.disabled = value;
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+function validateText(value, max, field) {
+  if (typeof value !== "string")
+    throw new TypeError(`${field} must be a string.`);
+  if (!value.trim())
+    throw new RangeError(`${field} must be a non-empty string.`);
+  if (value.length > max)
+    throw new RangeError(`${field} cannot exceed ${max} characters.`);
+}
+function validateCount(value, field, min, max = 25) {
+  if (!Number.isInteger(value) || value < min || value > max)
+    throw new RangeError(`${field} must be an integer between ${min} and ${max}.`);
+}
+// packages/builders/src/commands.ts
+var ApplicationCommandOptionType2 = {
+  Subcommand: 1,
+  SubcommandGroup: 2,
+  String: 3,
+  Integer: 4,
+  Boolean: 5,
+  User: 6,
+  Channel: 7,
+  Role: 8,
+  Mentionable: 9,
+  Number: 10,
+  Attachment: 11
+};
+
+class SlashCommandBuilder {
+  #data = { type: 1 };
+  setName(name) {
+    validateName(name, "Command name");
+    this.#data.name = name;
+    return this;
+  }
+  setDescription(description) {
+    validateText2(description, "Command description", 100);
+    this.#data.description = description;
+    return this;
+  }
+  setDMPermission(enabled) {
+    this.#data.dm_permission = enabled;
+    return this;
+  }
+  setNSFW(nsfw = true) {
+    this.#data.nsfw = nsfw;
+    return this;
+  }
+  setNsfw(nsfw = true) {
+    return this.setNSFW(nsfw);
+  }
+  setDefaultMemberPermissions(permissions) {
+    this.#data.default_member_permissions = permissions === null ? null : BigInt(permissions).toString();
+    return this;
+  }
+  setIntegrationTypes(...types) {
+    this.#data.integration_types = [...types];
+    return this;
+  }
+  addStringOption(configure) {
+    return this.addOption(configure(new StringOptionBuilder));
+  }
+  addIntegerOption(configure) {
+    return this.addOption(configure(new IntegerOptionBuilder));
+  }
+  addNumberOption(configure) {
+    return this.addOption(configure(new NumberOptionBuilder));
+  }
+  addBooleanOption(configure) {
+    return this.addOption(configure(new BooleanOptionBuilder));
+  }
+  addUserOption(configure) {
+    return this.addOption(configure(new UserOptionBuilder));
+  }
+  addChannelOption(configure) {
+    return this.addOption(configure(new ChannelOptionBuilder));
+  }
+  addRoleOption(configure) {
+    return this.addOption(configure(new RoleOptionBuilder));
+  }
+  addMentionableOption(configure) {
+    return this.addOption(configure(new MentionableOptionBuilder));
+  }
+  addAttachmentOption(configure) {
+    return this.addOption(configure(new AttachmentOptionBuilder));
+  }
+  addSubcommand(configure) {
+    return this.addOption(configure(new SubcommandBuilder));
+  }
+  addSubcommandGroup(configure) {
+    return this.addOption(configure(new SubcommandGroupBuilder));
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+  addOption(option) {
+    const options = this.#data.options ?? [];
+    if (options.length >= 25)
+      throw new RangeError("An application command cannot contain more than 25 options.");
+    const payload = option.toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
+    if (payload.required === true && options.some((existing) => existing.required !== true))
+      throw new RangeError("Required application command options must be placed before optional options.");
+    options.push(payload);
+    this.#data.options = options;
+    return this;
+  }
+}
+
+class CommandOptionBuilder {
+  data;
+  constructor(type) {
+    this.data = { type };
+  }
+  setName(name) {
+    validateName(name, "Option name");
+    this.data.name = name;
+    return this;
+  }
+  setDescription(description) {
+    validateText2(description, "Option description", 100);
+    this.data.description = description;
+    return this;
+  }
+  setRequired(required = true) {
+    this.data.required = required;
+    return this;
+  }
+  setAutocomplete(enabled = true) {
+    this.data.autocomplete = enabled;
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.data);
+  }
+}
+
+class StringOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.String);
+  }
+  addChoices(...choices) {
+    const current = this.data.choices ?? [];
+    if (!choices.length)
+      throw new TypeError("At least one choice is required.");
+    if (this.data.autocomplete === true)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    if (current.length + choices.length > 25)
+      throw new RangeError("An option cannot contain more than 25 choices.");
+    for (const choice of choices) {
+      validateText2(choice.name, "Choice name", 100);
+      validateText2(choice.value, "Choice value", 100);
+    }
+    this.data.choices = [
+      ...current,
+      ...choices.map((choice) => ({ ...choice }))
+    ];
+    return this;
+  }
+  setMinLength(value) {
+    validateIntegerRange(value, 0, 6000, "min_length");
+    this.data.min_length = value;
+    return this;
+  }
+  setMaxLength(value) {
+    validateIntegerRange(value, 1, 6000, "max_length");
+    if (this.data.min_length !== undefined && this.data.min_length > value)
+      throw new RangeError("min_length cannot exceed max_length.");
+    this.data.max_length = value;
+    return this;
+  }
+}
+
+class IntegerOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Integer);
+  }
+  setMinValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "min_value", true);
+    this.data.min_value = value;
+    return this;
+  }
+  setMaxValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "max_value", true);
+    if (this.data.min_value !== undefined && this.data.min_value > value)
+      throw new RangeError("min_value cannot exceed max_value.");
+    this.data.max_value = value;
+    return this;
+  }
+  setAutocomplete(enabled = true) {
+    if (enabled && Array.isArray(this.data.choices) && this.data.choices.length)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    this.data.autocomplete = enabled;
+    return this;
+  }
+  addChoices(...choices) {
+    const current = this.data.choices ?? [];
+    if (!choices.length)
+      throw new TypeError("At least one choice is required.");
+    if (this.data.autocomplete === true)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    if (current.length + choices.length > 25)
+      throw new RangeError("An option cannot contain more than 25 choices.");
+    this.data.choices = [...current, ...choices];
+    return this;
+  }
+}
+
+class NumberOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Number);
+  }
+  setMinValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "min_value", false);
+    this.data.min_value = value;
+    return this;
+  }
+  setMaxValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "max_value", false);
+    if (this.data.min_value !== undefined && this.data.min_value > value)
+      throw new RangeError("min_value cannot exceed max_value.");
+    this.data.max_value = value;
+    return this;
+  }
+  setAutocomplete(enabled = true) {
+    if (enabled && Array.isArray(this.data.choices) && this.data.choices.length)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    this.data.autocomplete = enabled;
+    return this;
+  }
+  addChoices(...choices) {
+    const current = this.data.choices ?? [];
+    if (!choices.length)
+      throw new TypeError("At least one choice is required.");
+    if (this.data.autocomplete === true)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    if (current.length + choices.length > 25)
+      throw new RangeError("An option cannot contain more than 25 choices.");
+    this.data.choices = [...current, ...choices];
+    return this;
+  }
+}
+
+class BooleanOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Boolean);
+  }
+}
+
+class UserOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.User);
+  }
+}
+
+class RoleOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Role);
+  }
+}
+
+class MentionableOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Mentionable);
+  }
+}
+
+class AttachmentOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Attachment);
+  }
+}
+
+class ChannelOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Channel);
+  }
+  addChannelTypes(...types) {
+    if (types.some((type) => !Number.isInteger(type) || type < 0))
+      throw new RangeError("Channel types must be non-negative integers.");
+    this.data.channel_types = [...new Set(types)];
+    return this;
+  }
+}
+
+class SubcommandBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.Subcommand);
+  }
+  addStringOption(configure) {
+    return this.addChildOption(configure(new StringOptionBuilder));
+  }
+  addIntegerOption(configure) {
+    return this.addChildOption(configure(new IntegerOptionBuilder));
+  }
+  addNumberOption(configure) {
+    return this.addChildOption(configure(new NumberOptionBuilder));
+  }
+  addBooleanOption(configure) {
+    return this.addChildOption(configure(new BooleanOptionBuilder));
+  }
+  addUserOption(configure) {
+    return this.addChildOption(configure(new UserOptionBuilder));
+  }
+  addChannelOption(configure) {
+    return this.addChildOption(configure(new ChannelOptionBuilder));
+  }
+  addRoleOption(configure) {
+    return this.addChildOption(configure(new RoleOptionBuilder));
+  }
+  addMentionableOption(configure) {
+    return this.addChildOption(configure(new MentionableOptionBuilder));
+  }
+  addAttachmentOption(configure) {
+    return this.addChildOption(configure(new AttachmentOptionBuilder));
+  }
+  addChildOption(option) {
+    const options = this.data.options ?? [];
+    if (options.length >= 25)
+      throw new RangeError("A subcommand cannot contain more than 25 options.");
+    const payload = option.toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
+    if (payload.required === true && options.some((existing) => existing.required !== true))
+      throw new RangeError("Required subcommand options must be placed before optional options.");
+    if (options.some((existing) => existing.type === ApplicationCommandOptionType2.Subcommand))
+      throw new RangeError("Subcommands cannot contain nested subcommands.");
+    options.push(payload);
+    this.data.options = options;
+    return this;
+  }
+}
+
+class SubcommandGroupBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType2.SubcommandGroup);
+  }
+  addSubcommand(configure) {
+    const options = this.data.options ?? [];
+    if (options.length >= 25)
+      throw new RangeError("A subcommand group cannot contain more than 25 subcommands.");
+    const payload = configure(new SubcommandBuilder).toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate subcommand name: ${String(payload.name)}.`);
+    if (payload.type !== ApplicationCommandOptionType2.Subcommand)
+      throw new TypeError("Subcommand group children must be subcommands.");
+    options.push(payload);
+    this.data.options = options;
+    return this;
+  }
+}
+function validateName(value, field) {
+  if (!/^[\p{L}\p{N}_-]{1,32}$/u.test(value) || value !== value.toLowerCase())
+    throw new RangeError(`${field} must contain 1-32 lowercase letters, numbers, underscores, or hyphens.`);
+}
+function validateText2(value, field, max) {
+  if (typeof value !== "string" || !value.trim() || value.length > max)
+    throw new RangeError(`${field} must contain 1-${max} characters.`);
+}
+function validateIntegerRange(value, minimum, maximum, field) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum)
+    throw new RangeError(`${field} must be an integer between ${minimum} and ${maximum}.`);
+}
+function validateNumberRange(value, minimum, maximum, field, integerOnly = true) {
+  if (!Number.isFinite(value) || integerOnly && !Number.isInteger(value) || value < minimum || value > maximum)
+    throw new RangeError(`${field} must be ${integerOnly ? "an integer" : "a number"} between ${minimum} and ${maximum}.`);
+}
+// 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++;
+    if (this.options.filter) {
+      const passed = await this.options.filter(item);
+      if (!passed)
+        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 (this.options.maxProcessed && this.totalProcessed >= this.options.maxProcessed) {
+      this.stop("processedLimit");
+      return true;
+    }
+    return true;
+  }
+  stop(reason = "user") {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.endReason = reason;
+    if (this.#timeoutTimer)
+      clearTimeout(this.#timeoutTimer);
+    this.emit("end", this.collected, reason);
+    this.removeAllListeners();
+  }
+  next() {
+    return new Promise((resolve, reject) => {
+      if (this.ended) {
+        return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
+      }
+      this.once("collect", (item) => {
+        resolve(item);
+      });
+      this.once("end", (_collected, reason) => {
+        reject(new Error(`Collector ended before item was collected: ${reason}`));
+      });
+    });
+  }
+}
+
+// packages/core/src/index.ts
+class EventEmitter2 {
+  #listeners = new Map;
+  on(event, listener) {
+    if (typeof listener !== "function")
+      throw new TypeError("Event listener must be a function.");
+    let listeners = this.#listeners.get(event);
+    if (!listeners)
+      this.#listeners.set(event, listeners = new Set);
+    listeners.add(listener);
+    return this;
+  }
+  once(event, listener) {
+    const wrapped = (...args) => {
+      this.off(event, wrapped);
+      return listener(...args);
+    };
+    return this.on(event, wrapped);
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  removeAllListeners(event) {
+    if (event === undefined)
+      this.#listeners.clear();
+    else
+      this.#listeners.delete(event);
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this.#listeners.get(event);
+    if (!listeners?.size)
+      return false;
+    for (const listener of [...listeners]) {
+      try {
+        const result = listener(...args);
+        if (result && typeof result.then === "function")
+          Promise.resolve(result).catch((error) => this.#handleError(event, error));
+      } catch (error) {
+        this.#handleError(event, error);
+      }
+    }
+    return true;
+  }
+  #handleError(event, error) {
+    if (event === "error")
+      return;
+    const normalized = error instanceof Error ? error : new Error(String(error), { cause: error });
+    for (const listener of [
+      ...this.#listeners.get("error") ?? []
+    ]) {
+      try {
+        listener(normalized);
+      } catch {}
+    }
+  }
+}
+
+class Client extends EventEmitter2 {
+  options;
+  rest;
+  users;
+  guilds;
+  channels;
+  application;
+  get ws() {
+    return this.#gateway;
+  }
+  get gateway() {
+    return this.#gateway;
+  }
+  user;
+  readyAt;
+  state = "idle";
+  get uptime() {
+    return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
+  }
+  #gateway;
+  #resourceContext;
+  constructor(options) {
+    super();
+    this.options = options;
+    if (!options.token?.trim())
+      throw new TypeError("Client token is required.");
+    this.rest = new REST({ token: options.token, ...options.rest });
+    this.users = new UserManager(this.rest);
+    this.guilds = new GuildManager(this.rest);
+    this.channels = new ChannelManager(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),
+      deleteMessage: (channelId, messageId) => this.channels.deleteMessage(channelId, messageId),
+      crosspostMessage: (channelId, messageId) => this.channels.crosspostMessage(channelId, messageId)
+    };
+    this.#gateway = new Gateway({
+      token: options.token,
+      intents: options.intents,
+      ...options.gateway
+    });
+    this.#gateway.on("READY", (data) => {
+      const ready = data;
+      this.user = ready.user;
+      this.users.set(this.user.id, new User(this.user));
+      this.readyAt = new Date;
+      this.state = "ready";
+      const appId = ready.application?.id ?? this.user.id;
+      this.application.commands = new ApplicationCommandManager(this.rest, appId);
+      this.emit("ready", this.user);
+    });
+    this.#gateway.on("open", () => this.emit("open"));
+    this.#gateway.on("close", (data) => {
+      if (this.state !== "destroyed")
+        this.state = "idle";
+      this.emit("close", data);
+    });
+    this.#gateway.on("MESSAGE_CREATE", (data) => {
+      const message = new Message(data, this.#resourceContext);
+      this.channels.set(message.channelId, message.channel);
+      this.users.set(message.author.id, message.author);
+      this.emit("messageCreate", message);
+    });
+    this.#gateway.on("MESSAGE_UPDATE", (data) => {
+      const message = new Message(data, this.#resourceContext);
+      this.channels.set(message.channelId, message.channel);
+      this.users.set(message.author.id, message.author);
+      this.emit("messageUpdate", message);
+    });
+    this.#gateway.on("MESSAGE_DELETE", (data) => this.emit("messageDelete", data));
+    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => this.emit("messageDeleteBulk", data));
+    this.#gateway.on("GUILD_CREATE", (data) => {
+      const guild = new Guild(data);
+      this.guilds.set(guild.id, guild);
+      const payload = data;
+      for (const member of payload.members ?? [])
+        this.users.set(member.user.id, new User(member.user));
+      for (const channelData of [
+        ...payload.channels ?? [],
+        ...payload.threads ?? []
+      ]) {
+        const channel = new Channel(channelData, this.#resourceContext);
+        this.channels.set(channel.id, channel);
+      }
+      this.emit("guildCreate", data);
+    });
+    this.#gateway.on("GUILD_UPDATE", (data) => {
+      const guild = new Guild(data);
+      this.guilds.update(guild);
+      this.emit("guildUpdate", data);
+    });
+    this.#gateway.on("GUILD_DELETE", (data) => {
+      const payload = data;
+      if (!payload.unavailable)
+        this.guilds.delete(payload.id);
+      this.emit("guildDelete", payload);
+    });
+    this.#gateway.on("CHANNEL_CREATE", (data) => {
+      const channel = new Channel(data, this.#resourceContext);
+      this.channels.update(channel);
+      this.emit("channelCreate", channel);
+    });
+    this.#gateway.on("CHANNEL_UPDATE", (data) => {
+      const channel = new Channel(data, this.#resourceContext);
+      this.channels.update(channel);
+      this.emit("channelUpdate", channel);
+    });
+    this.#gateway.on("CHANNEL_DELETE", (data) => {
+      const payload = data;
+      this.channels.delete(payload.id);
+      this.emit("channelDelete", payload);
+    });
+    this.#gateway.on("THREAD_CREATE", (data) => {
+      const channel = new Channel(data, this.#resourceContext);
+      this.channels.update(channel);
+      this.emit("threadCreate", channel);
+    });
+    this.#gateway.on("THREAD_UPDATE", (data) => {
+      const channel = new Channel(data, this.#resourceContext);
+      this.channels.update(channel);
+      this.emit("threadUpdate", channel);
+    });
+    this.#gateway.on("THREAD_DELETE", (data) => {
+      const payload = data;
+      this.channels.delete(payload.id);
+      this.emit("threadDelete", payload);
+    });
+    this.#gateway.on("GUILD_MEMBER_ADD", (data) => {
+      const member = data;
+      this.users.set(member.user.id, new User(member.user));
+      this.emit("guildMemberAdd", member);
+    });
+    this.#gateway.on("GUILD_MEMBER_UPDATE", (data) => {
+      const member = data;
+      this.users.set(member.user.id, new User(member.user));
+      this.emit("guildMemberUpdate", member);
+    });
+    this.#gateway.on("GUILD_MEMBER_REMOVE", (data) => this.emit("guildMemberRemove", data));
+    this.#gateway.on("MESSAGE_REACTION_ADD", (data) => this.emit("messageReactionAdd", data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE", (data) => this.emit("messageReactionRemove", data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE_ALL", (data) => this.emit("messageReactionRemoveAll", data));
+    this.#gateway.on("INTERACTION_CREATE", (data) => this.emit("interactionCreate", createInteraction(this, data)));
+    this.#gateway.on("GUILD_ROLE_CREATE", (data) => this.emit("guildRoleCreate", data));
+    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => this.emit("guildRoleUpdate", data));
+    this.#gateway.on("GUILD_ROLE_DELETE", (data) => this.emit("guildRoleDelete", data));
+    this.#gateway.on("GUILD_BAN_ADD", (data) => this.emit("guildBanAdd", data));
+    this.#gateway.on("GUILD_BAN_REMOVE", (data) => this.emit("guildBanRemove", data));
+    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => this.emit("guildEmojisUpdate", data));
+    for (const event of [
+      "READY",
+      "MESSAGE_CREATE",
+      "MESSAGE_UPDATE",
+      "MESSAGE_DELETE",
+      "MESSAGE_DELETE_BULK",
+      "GUILD_CREATE",
+      "GUILD_UPDATE",
+      "GUILD_DELETE",
+      "CHANNEL_CREATE",
+      "CHANNEL_UPDATE",
+      "CHANNEL_DELETE",
+      "THREAD_CREATE",
+      "THREAD_UPDATE",
+      "THREAD_DELETE",
+      "GUILD_MEMBER_ADD",
+      "GUILD_MEMBER_UPDATE",
+      "GUILD_MEMBER_REMOVE",
+      "MESSAGE_REACTION_ADD",
+      "MESSAGE_REACTION_REMOVE",
+      "MESSAGE_REACTION_REMOVE_ALL",
+      "INTERACTION_CREATE",
+      "GUILD_ROLE_CREATE",
+      "GUILD_ROLE_UPDATE",
+      "GUILD_ROLE_DELETE",
+      "GUILD_BAN_ADD",
+      "GUILD_BAN_REMOVE",
+      "GUILD_EMOJIS_UPDATE"
+    ])
+      this.#gateway.on(event, (data) => this.emit("raw", { event, data }));
+    this.#gateway.on("error", (data) => this.emit("error", data));
+  }
+  isReady() {
+    return this.state === "ready" && this.user !== undefined && this.readyAt !== undefined;
+  }
+  async login() {
+    if (this.state === "destroyed")
+      throw new Error("Cannot login a destroyed client.");
+    if (this.state === "connecting" || this.state === "ready")
+      return;
+    this.state = "connecting";
+    try {
+      this.user = await this.rest.get(Routes.user());
+      this.users.set(this.user.id, new User(this.user));
+      await this.#gateway.connect();
+    } catch (error) {
+      this.state = "idle";
+      throw error;
+    }
+  }
+  destroy() {
+    if (this.state === "destroyed")
+      return;
+    this.#gateway.close();
+    this.users.clear();
+    this.guilds.clear();
+    this.channels.clear();
+    this.state = "destroyed";
+    this.readyAt = undefined;
+    this.user = undefined;
+  }
+  postInteractionResponse(id, token, response) {
+    return this.rest.post(Routes.interactionCallback(id, token), response.toJSON());
+  }
+  editInteractionReply(token, data) {
+    if (!this.user?.id)
+      throw new Error("Client user is unavailable; login is required.");
+    return this.rest.patch(Routes.interactionOriginalResponse(this.user.id, token), data);
+  }
+  async deleteInteractionReply(token) {
+    if (!this.user?.id)
+      throw new Error("Client user is unavailable; login is required.");
+    await this.rest.delete(Routes.interactionOriginalResponse(this.user.id, token));
+  }
+  setPresence(presence) {
+    return this.#gateway.setPresence(presence);
+  }
+  followUpInteraction(token, data) {
+    if (!this.user?.id)
+      throw new Error("Client user is unavailable; login is required.");
+    return this.rest.post(Routes.webhook(this.user.id, token), data);
+  }
+}
+export {
+  ActionRowBuilder,
+  ApplicationCommandManager,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ButtonBuilder,
+  Channel,
+  ChannelManager,
+  ChannelType,
+  Client,
+  Collection,
+  Collector,
+  EmbedBuilder,
+  Gateway,
+  GatewayError,
+  GatewayIntentBits,
+  GatewayOpcodes,
+  Guild,
+  GuildManager,
+  IntentBits,
+  Intents,
+  Manager,
+  Message,
+  MessageCreateOptions,
+  MessageEditOptions,
+  MessageFetchOptions,
+  MessageFlags,
+  MessageThreadOptions,
+  Permission,
+  PermissionFlagsBits,
+  PermissionOverwriteType,
+  PermissionSet,
+  Permissions,
+  PermissionsBitField,
+  REST,
+  RESTError,
+  ReactionFetchOptions,
+  ResourceManager,
+  Routes,
+  SlashCommandBuilder,
+  StringOptionBuilder,
+  StringSelectBuilder,
+  User,
+  UserManager,
+  resolveGatewayIntents
+};
+
+//# debugId=8E6F3C716D06EF5664756E2164756E21