lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-0wn81eng.js

@@ -0,0 +1,2492 @@
+// @bun
+import {
+  ChannelKinds2,
+  GatewayIntentBits2,
+  resolveGatewayIntents2,
+  ActivityEnum2
+} from "./index-gyvps8b9.js";
+import {
+  User2,
+  PermissionSet2,
+  computePermissions2,
+  GuildMember2,
+  Role2,
+  createChannel2,
+  createInteraction2,
+  Message2
+} from "./index-57c5n3ms.js";
+import {
+  CreateSlashCommand2,
+  CreateStringOption2,
+  CreateIntegerOption2,
+  CreateNumberOption2,
+  CreateBooleanOption2,
+  CreateUserOption2,
+  CreateRoleOption2,
+  CreateMentionableOption2,
+  CreateAttachmentOption2,
+  CreateChannelOption2
+} from "./index-5yx92e36.js";
+import {
+  parsePrefixArgs2
+} from "./index-3hyps48a.js";
+import {
+  Routes2,
+  REST2
+} from "./index-7fp2hvmg.js";
+import {
+  toRequest2,
+  UserManager2,
+  MonetizationManager2,
+  ApplicationEmojiManager2,
+  StageInstanceManager2,
+  GuildManager2,
+  ApplicationCommandManager2,
+  ChannelManager2
+} from "./index-jzg4bh99.js";
+import {
+  Gateway2
+} from "./index-fdvgk2sw.js";
+import {
+  VoiceManager2
+} from "./index-yh76b55h.js";
+import {
+  readClusterContext2,
+  ClusterWorker2,
+  connectInQueue2
+} from "./index-mgw2yvrm.js";
+// packages/core/src/events.ts
+var ClientEvent2;
+((ClientEvent) => {
+  ClientEvent["Ready"] = "ready";
+  ClientEvent["Resumed"] = "resumed";
+  ClientEvent["InvalidSession"] = "invalidSession";
+  ClientEvent["Raw"] = "raw";
+  ClientEvent["Error"] = "error";
+  ClientEvent["Open"] = "open";
+  ClientEvent["Close"] = "close";
+  ClientEvent["MessageCreate"] = "messageCreate";
+  ClientEvent["MessageUpdate"] = "messageUpdate";
+  ClientEvent["MessageDelete"] = "messageDelete";
+  ClientEvent["MessageDeleteBulk"] = "messageDeleteBulk";
+  ClientEvent["MessageReactionAdd"] = "messageReactionAdd";
+  ClientEvent["MessageReactionRemove"] = "messageReactionRemove";
+  ClientEvent["MessageReactionRemoveAll"] = "messageReactionRemoveAll";
+  ClientEvent["MessageReactionRemoveEmoji"] = "messageReactionRemoveEmoji";
+  ClientEvent["MessagePollVoteAdd"] = "messagePollVoteAdd";
+  ClientEvent["MessagePollVoteRemove"] = "messagePollVoteRemove";
+  ClientEvent["GuildCreate"] = "guildCreate";
+  ClientEvent["GuildUpdate"] = "guildUpdate";
+  ClientEvent["GuildDelete"] = "guildDelete";
+  ClientEvent["GuildAvailable"] = "guildAvailable";
+  ClientEvent["GuildUnavailable"] = "guildUnavailable";
+  ClientEvent["GuildMemberAdd"] = "guildMemberAdd";
+  ClientEvent["GuildMemberUpdate"] = "guildMemberUpdate";
+  ClientEvent["GuildMemberRemove"] = "guildMemberRemove";
+  ClientEvent["GuildMembersChunk"] = "guildMembersChunk";
+  ClientEvent["GuildBanAdd"] = "guildBanAdd";
+  ClientEvent["GuildBanRemove"] = "guildBanRemove";
+  ClientEvent["GuildRoleCreate"] = "guildRoleCreate";
+  ClientEvent["GuildRoleUpdate"] = "guildRoleUpdate";
+  ClientEvent["GuildRoleDelete"] = "guildRoleDelete";
+  ClientEvent["GuildEmojisUpdate"] = "guildEmojisUpdate";
+  ClientEvent["GuildStickersUpdate"] = "guildStickersUpdate";
+  ClientEvent["EntitlementCreate"] = "entitlementCreate";
+  ClientEvent["EntitlementUpdate"] = "entitlementUpdate";
+  ClientEvent["EntitlementDelete"] = "entitlementDelete";
+  ClientEvent["SoundboardSoundCreate"] = "soundboardSoundCreate";
+  ClientEvent["SoundboardSoundUpdate"] = "soundboardSoundUpdate";
+  ClientEvent["SoundboardSoundDelete"] = "soundboardSoundDelete";
+  ClientEvent["SoundboardSoundsUpdate"] = "soundboardSoundsUpdate";
+  ClientEvent["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
+  ClientEvent["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
+  ClientEvent["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
+  ClientEvent["GuildScheduledEventDelete"] = "guildScheduledEventDelete";
+  ClientEvent["GuildScheduledEventUserAdd"] = "guildScheduledEventUserAdd";
+  ClientEvent["GuildScheduledEventUserRemove"] = "guildScheduledEventUserRemove";
+  ClientEvent["AutoModerationRuleCreate"] = "autoModerationRuleCreate";
+  ClientEvent["AutoModerationRuleUpdate"] = "autoModerationRuleUpdate";
+  ClientEvent["AutoModerationRuleDelete"] = "autoModerationRuleDelete";
+  ClientEvent["AutoModerationActionExecution"] = "autoModerationActionExecution";
+  ClientEvent["ChannelCreate"] = "channelCreate";
+  ClientEvent["ChannelUpdate"] = "channelUpdate";
+  ClientEvent["ChannelDelete"] = "channelDelete";
+  ClientEvent["ChannelPinsUpdate"] = "channelPinsUpdate";
+  ClientEvent["ThreadCreate"] = "threadCreate";
+  ClientEvent["ThreadUpdate"] = "threadUpdate";
+  ClientEvent["ThreadDelete"] = "threadDelete";
+  ClientEvent["ThreadListSync"] = "threadListSync";
+  ClientEvent["ThreadMembersUpdate"] = "threadMembersUpdate";
+  ClientEvent["ThreadMemberUpdate"] = "threadMemberUpdate";
+  ClientEvent["StageInstanceCreate"] = "stageInstanceCreate";
+  ClientEvent["StageInstanceUpdate"] = "stageInstanceUpdate";
+  ClientEvent["StageInstanceDelete"] = "stageInstanceDelete";
+  ClientEvent["InviteCreate"] = "inviteCreate";
+  ClientEvent["InviteDelete"] = "inviteDelete";
+  ClientEvent["WebhooksUpdate"] = "webhooksUpdate";
+  ClientEvent["VoiceStateUpdate"] = "voiceStateUpdate";
+  ClientEvent["VoiceServerUpdate"] = "voiceServerUpdate";
+  ClientEvent["PresenceUpdate"] = "presenceUpdate";
+  ClientEvent["TypingStart"] = "typingStart";
+  ClientEvent["InteractionCreate"] = "interactionCreate";
+})(ClientEvent2 ||= {});
+// packages/core/src/collector.ts
+import { EventEmitter } from "events";
+
+class Collector2 extends EventEmitter {
+  collected = new Map;
+  options;
+  ended = false;
+  endReason;
+  totalProcessed = 0;
+  #timeoutTimer;
+  #idleTimer;
+  #onAbort = () => this.stop("abort");
+  #cleanup = [];
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    if (options.time && options.time > 0) {
+      this.#timeoutTimer = setTimeout(() => {
+        this.stop("time");
+      }, options.time);
+    }
+    this.#resetIdle();
+    if (options.signal?.aborted)
+      this.stop("abort");
+    else
+      options.signal?.addEventListener("abort", this.#onAbort, {
+        once: true
+      });
+  }
+  onDispose(cleanup) {
+    if (this.ended)
+      cleanup();
+    else
+      this.#cleanup.push(cleanup);
+    return this;
+  }
+  #resetIdle() {
+    if (!this.options.idle || this.options.idle <= 0)
+      return;
+    if (this.#idleTimer)
+      clearTimeout(this.#idleTimer);
+    this.#idleTimer = setTimeout(() => this.stop("idle"), this.options.idle);
+  }
+  async handle(key, item) {
+    if (this.ended)
+      return false;
+    this.totalProcessed++;
+    const reachedProcessed = !!this.options.maxProcessed && this.totalProcessed >= this.options.maxProcessed;
+    let passed = true;
+    if (this.options.filter)
+      passed = !!await this.options.filter(item);
+    if (this.ended)
+      return false;
+    if (!passed) {
+      if (reachedProcessed)
+        this.stop("processedLimit");
+      return false;
+    }
+    this.collected.set(key, item);
+    this.#resetIdle();
+    this.emit("collect", item);
+    if (this.options.max && this.collected.size >= this.options.max) {
+      this.stop("limit");
+      return true;
+    }
+    if (reachedProcessed) {
+      this.stop("processedLimit");
+      return true;
+    }
+    return true;
+  }
+  stop(reason = "user") {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.endReason = reason;
+    if (this.#timeoutTimer)
+      clearTimeout(this.#timeoutTimer);
+    if (this.#idleTimer)
+      clearTimeout(this.#idleTimer);
+    this.options.signal?.removeEventListener("abort", this.#onAbort);
+    for (const cleanup of this.#cleanup.splice(0)) {
+      try {
+        cleanup();
+      } catch {}
+    }
+    this.emit("end", this.collected, reason);
+    this.removeAllListeners();
+  }
+  wait() {
+    if (this.ended)
+      return Promise.resolve(this.collected);
+    return new Promise((resolve) => this.once("end", (collected) => resolve(collected)));
+  }
+  async* [Symbol.asyncIterator]() {
+    const queue = [];
+    let wake;
+    const onCollect = (item) => {
+      queue.push(item);
+      wake?.();
+    };
+    const onEnd = () => wake?.();
+    if (!this.ended) {
+      this.on("collect", onCollect);
+      this.on("end", onEnd);
+    }
+    try {
+      for (;; ) {
+        if (queue.length > 0) {
+          yield queue.shift();
+          continue;
+        }
+        if (this.ended)
+          return;
+        await new Promise((resolve) => wake = resolve);
+        wake = undefined;
+      }
+    } finally {
+      this.off("collect", onCollect);
+      this.off("end", onEnd);
+    }
+  }
+  [Symbol.dispose]() {
+    this.stop("disposed");
+  }
+  next() {
+    return new Promise((resolve, reject) => {
+      if (this.ended) {
+        return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
+      }
+      const onCollect = (item) => {
+        this.off("end", onEnd);
+        resolve(item);
+      };
+      const onEnd = (_collected, reason) => {
+        this.off("collect", onCollect);
+        reject(new Error(`Collector ended before item was collected: ${reason}`));
+      };
+      this.once("collect", onCollect);
+      this.once("end", onEnd);
+    });
+  }
+}
+// packages/core/src/redis-cache.ts
+var GUILD_LISTS = [
+  "members",
+  "channels",
+  "threads",
+  "roles",
+  "presences",
+  "voice_states",
+  "stage_instances",
+  "guild_scheduled_events",
+  "soundboard_sounds"
+];
+var CHUNK = 1000;
+var id = (value) => typeof value === "string" && /^\d{1,20}$/.test(value) ? value : undefined;
+
+class RedisCache2 {
+  #redis;
+  #prefix;
+  #members;
+  #ttl;
+  #onError;
+  #chains = new Map;
+  #attached = new Map;
+  #writes = 0;
+  #failures = 0;
+  #pending = 0;
+  constructor(options) {
+    this.#redis = options.client;
+    this.#prefix = `${options.prefix ?? "lunibee:cache:"}v1:`;
+    this.#members = options.members ?? true;
+    if (options.ttlSeconds !== undefined && !(Number.isInteger(options.ttlSeconds) && options.ttlSeconds > 0))
+      throw new RangeError("ttlSeconds must be a positive integer.");
+    this.#ttl = options.ttlSeconds;
+    this.#onError = options.onError;
+  }
+  attach(source) {
+    if (this.#attached.has(source))
+      return this;
+    const event = "gateway" in source ? "raw" : "RAW";
+    const listener = (payload) => {
+      const { event: name, data } = payload;
+      if (typeof name === "string")
+        this.handle(name, data);
+    };
+    source.on(event, listener);
+    this.#attached.set(source, { event, listener });
+    return this;
+  }
+  detach(source) {
+    for (const [s, { event, listener }] of this.#attached)
+      if (!source || s === source) {
+        s.off(event, listener);
+        this.#attached.delete(s);
+      }
+    return this;
+  }
+  async flush() {
+    while (this.#chains.size > 0)
+      await Promise.all([...this.#chains.values()]);
+  }
+  diagnostics() {
+    return {
+      writes: this.#writes,
+      failures: this.#failures,
+      pending: this.#pending
+    };
+  }
+  handle(event, data) {
+    if (!data || typeof data !== "object")
+      return;
+    const d = data;
+    const users = this.#usersOf(event, d);
+    if (users.length)
+      this.#enqueue("users", event, async () => {
+        for (const user of users)
+          await this.#setJSON(this.#k("user", user.id), user);
+      });
+    const write = this.#writer(event, d);
+    if (!write)
+      return;
+    const guild = id(d.guild_id) ?? id(d.id) ?? "-";
+    const key = event.startsWith("GUILD_") || d.guild_id ? guild : "-";
+    this.#enqueue(key, event, write);
+  }
+  #usersOf(event, d) {
+    const list = event === "USER_UPDATE" ? [d] : !this.#members ? [] : event === "GUILD_CREATE" || event === "GUILD_MEMBERS_CHUNK" ? (d.members ?? []).map((m) => m?.user) : event === "GUILD_MEMBER_ADD" || event === "GUILD_MEMBER_UPDATE" ? [d.user] : [];
+    return list.filter((u) => !!u && typeof u === "object" && !!id(u.id));
+  }
+  #enqueue(key, event, write) {
+    this.#pending++;
+    const previous = this.#chains.get(key) ?? Promise.resolve();
+    const next = previous.then(async () => {
+      try {
+        await write();
+        this.#writes++;
+      } catch (error) {
+        this.#failures++;
+        try {
+          this.#onError?.(event, error);
+        } catch {}
+      } finally {
+        this.#pending--;
+      }
+    });
+    this.#chains.set(key, next);
+    next.then(() => {
+      if (this.#chains.get(key) === next)
+        this.#chains.delete(key);
+    });
+  }
+  #k(...parts) {
+    return this.#prefix + parts.join(":");
+  }
+  async#cmd(command, ...args) {
+    return this.#redis.send(command, args);
+  }
+  async#setJSON(key, value) {
+    const args = [key, JSON.stringify(value)];
+    if (this.#ttl)
+      args.push("EX", String(this.#ttl));
+    await this.#redis.send("SET", args);
+  }
+  async#touch(key) {
+    if (this.#ttl)
+      await this.#cmd("EXPIRE", key, String(this.#ttl));
+  }
+  async#hset(key, entries) {
+    for (let i = 0;i < entries.length; i += CHUNK) {
+      const args = [key];
+      for (const [field, value] of entries.slice(i, i + CHUNK))
+        args.push(field, JSON.stringify(value));
+      await this.#redis.send("HSET", args);
+    }
+    if (entries.length)
+      await this.#touch(key);
+  }
+  async#channel(channel, guildId) {
+    const channelId = id(channel.id);
+    if (!channelId)
+      return;
+    const value = guildId ? { ...channel, guild_id: guildId } : channel;
+    await this.#setJSON(this.#k("channel", channelId), value);
+    if (guildId)
+      await this.#hset(this.#k("guild", guildId, "channels"), [
+        [channelId, value]
+      ]);
+  }
+  async#member(guildId, member) {
+    if (!this.#members)
+      return;
+    const userId = id(member.user?.id);
+    if (!userId)
+      return;
+    const { user: _user, ...rest } = member;
+    await this.#hset(this.#k("guild", guildId, "members"), [
+      [userId, { ...rest, user_id: userId }]
+    ]);
+  }
+  async#dropGuild(guildId) {
+    const channels = await this.#cmd("HKEYS", this.#k("guild", guildId, "channels"));
+    const keys = [
+      this.#k("guild", guildId),
+      this.#k("guild", guildId, "channels"),
+      this.#k("guild", guildId, "roles"),
+      this.#k("guild", guildId, "members"),
+      ...(channels ?? []).map((c) => this.#k("channel", c))
+    ];
+    await this.#redis.send("DEL", keys);
+    await this.#cmd("SREM", this.#k("guilds"), guildId);
+  }
+  async#patchGuild(guildId, patch) {
+    const current = await this.guild(guildId);
+    if (!current)
+      return;
+    await this.#setJSON(this.#k("guild", guildId), {
+      ...current,
+      ...patch
+    });
+  }
+  #writer(event, d) {
+    const guildId = id(d.guild_id);
+    switch (event) {
+      case "GUILD_CREATE":
+      case "GUILD_UPDATE":
+        return async () => {
+          const gid = id(d.id);
+          if (!gid)
+            return;
+          const doc = {};
+          for (const [k, v] of Object.entries(d))
+            if (!GUILD_LISTS.includes(k))
+              doc[k] = v;
+          if (event === "GUILD_CREATE") {
+            await this.#dropGuild(gid);
+            await this.#hset(this.#k("guild", gid, "roles"), (d.roles ?? []).filter((r) => id(r.id)).map((r) => [r.id, r]));
+            for (const c of [
+              ...d.channels ?? [],
+              ...d.threads ?? []
+            ])
+              await this.#channel(c, gid);
+            if (this.#members) {
+              const members = (d.members ?? []).filter((m) => id(m.user?.id));
+              await this.#hset(this.#k("guild", gid, "members"), members.map((m) => {
+                const { user, ...rest } = m;
+                const uid = user.id;
+                return [uid, { ...rest, user_id: uid }];
+              }));
+            }
+            await this.#setJSON(this.#k("guild", gid), doc);
+          } else {
+            if (Array.isArray(d.roles))
+              await this.#hset(this.#k("guild", gid, "roles"), d.roles.filter((r) => id(r.id)).map((r) => [r.id, r]));
+            const current = await this.guild(gid);
+            await this.#setJSON(this.#k("guild", gid), {
+              ...current,
+              ...doc
+            });
+          }
+          await this.#cmd("SADD", this.#k("guilds"), gid);
+        };
+      case "GUILD_DELETE":
+        return async () => {
+          const gid = id(d.id);
+          if (!gid)
+            return;
+          if (d.unavailable === true)
+            await this.#patchGuild(gid, { unavailable: true });
+          else
+            await this.#dropGuild(gid);
+        };
+      case "CHANNEL_CREATE":
+      case "CHANNEL_UPDATE":
+      case "THREAD_CREATE":
+      case "THREAD_UPDATE":
+        return () => this.#channel(d, guildId);
+      case "CHANNEL_DELETE":
+      case "THREAD_DELETE":
+        return async () => {
+          const channelId = id(d.id);
+          if (!channelId)
+            return;
+          await this.#cmd("DEL", this.#k("channel", channelId));
+          if (guildId)
+            await this.#cmd("HDEL", this.#k("guild", guildId, "channels"), channelId);
+        };
+      case "GUILD_ROLE_CREATE":
+      case "GUILD_ROLE_UPDATE":
+        return async () => {
+          const role = d.role;
+          if (!guildId || !role || !id(role.id))
+            return;
+          await this.#hset(this.#k("guild", guildId, "roles"), [
+            [role.id, role]
+          ]);
+        };
+      case "GUILD_ROLE_DELETE":
+        return async () => {
+          const roleId = id(d.role_id);
+          if (!guildId || !roleId)
+            return;
+          await this.#cmd("HDEL", this.#k("guild", guildId, "roles"), roleId);
+        };
+      case "GUILD_MEMBER_ADD":
+      case "GUILD_MEMBER_UPDATE":
+        return async () => {
+          if (!guildId)
+            return;
+          if (event === "GUILD_MEMBER_UPDATE" && this.#members) {
+            const userId = id(d.user?.id);
+            const current = userId ? await this.#hget(this.#k("guild", guildId, "members"), userId) : undefined;
+            await this.#member(guildId, { ...current, ...d });
+          } else
+            await this.#member(guildId, d);
+        };
+      case "GUILD_MEMBER_REMOVE":
+        return async () => {
+          const userId = id(d.user?.id);
+          if (!guildId || !userId || !this.#members)
+            return;
+          await this.#cmd("HDEL", this.#k("guild", guildId, "members"), userId);
+        };
+      case "GUILD_MEMBERS_CHUNK":
+        return async () => {
+          if (!guildId)
+            return;
+          for (const m of d.members ?? [])
+            await this.#member(guildId, m);
+        };
+      case "GUILD_EMOJIS_UPDATE":
+        return async () => {
+          if (guildId)
+            await this.#patchGuild(guildId, { emojis: d.emojis });
+        };
+      case "GUILD_STICKERS_UPDATE":
+        return async () => {
+          if (guildId)
+            await this.#patchGuild(guildId, {
+              stickers: d.stickers
+            });
+        };
+      default:
+        return;
+    }
+  }
+  async#get(key) {
+    const raw = await this.#cmd("GET", key);
+    return raw ? JSON.parse(raw) : undefined;
+  }
+  async#hget(key, field) {
+    const raw = await this.#cmd("HGET", key, field);
+    return raw ? JSON.parse(raw) : undefined;
+  }
+  async#hvals(key) {
+    const raw = await this.#cmd("HVALS", key) ?? [];
+    return raw.map((v) => JSON.parse(v));
+  }
+  guild(guildId) {
+    return this.#get(this.#k("guild", guildId));
+  }
+  async guildIds() {
+    return await this.#cmd("SMEMBERS", this.#k("guilds")) ?? [];
+  }
+  channel(channelId) {
+    return this.#get(this.#k("channel", channelId));
+  }
+  channels(guildId) {
+    return this.#hvals(this.#k("guild", guildId, "channels"));
+  }
+  role(guildId, roleId) {
+    return this.#hget(this.#k("guild", guildId, "roles"), roleId);
+  }
+  roles(guildId) {
+    return this.#hvals(this.#k("guild", guildId, "roles"));
+  }
+  user(userId) {
+    return this.#get(this.#k("user", userId));
+  }
+  async member(guildId, userId) {
+    const member = await this.#hget(this.#k("guild", guildId, "members"), userId);
+    if (!member)
+      return;
+    return { ...member, user: await this.user(userId) };
+  }
+  async members(guildId) {
+    const members = await this.#hvals(this.#k("guild", guildId, "members"));
+    if (members.length === 0)
+      return [];
+    const users = await this.#redis.send("MGET", members.map((m) => this.#k("user", String(m.user_id))));
+    return members.map((m, i) => ({
+      ...m,
+      user: users[i] ? JSON.parse(users[i]) : undefined
+    }));
+  }
+}
+// packages/core/src/api.ts
+var SAFE_WORD = /^[a-z][a-zA-Z0-9]*$/;
+var SAFE_SEGMENT = /^[A-Za-z0-9_@.%-]+$/;
+var PAGING = {
+  members: {
+    limit: 1000,
+    cursor: "after",
+    idOf: (member) => member.user.id
+  },
+  bans: {
+    limit: 1000,
+    cursor: "after",
+    idOf: (ban) => ban.user.id
+  },
+  messages: { limit: 100, cursor: "before" },
+  guilds: { limit: 200, cursor: "after" }
+};
+var DEFAULT_PAGING = { limit: 100, cursor: "after" };
+var DEFAULT_MAX = 1e4;
+function kebab(word) {
+  return word.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function idSegment(id) {
+  if (typeof id !== "string" && typeof id !== "number" && typeof id !== "bigint")
+    throw new TypeError("A route id must be a string, number or bigint.");
+  const text = String(id);
+  if (text === "")
+    throw new TypeError("A route id cannot be empty.");
+  return encodeURIComponent(text).replace(/%40/g, "@");
+}
+function defaultId(item) {
+  const record = item;
+  const id = record?.id ?? record?.user?.id;
+  if (typeof id !== "string")
+    throw new TypeError("Cannot find an id on a page item; pass idOf to pages().");
+  return id;
+}
+function node(rest, segments) {
+  const path = `/${segments.join("/")}`;
+  const send = (method, hasBody) => (first, second) => rest.request(method, path, hasBody ? first : undefined, (hasBody ? second : first) ?? {});
+  const last = segments[segments.length - 1] ?? "";
+  const pages = async function* (options = {}) {
+    const paging = { ...DEFAULT_PAGING, ...PAGING[last] };
+    const cursorName = options.cursor ?? paging.cursor;
+    const limit = options.limit ?? paging.limit;
+    const idOf = options.idOf ?? paging.idOf ?? defaultId;
+    let cursor = options.start;
+    for (;; ) {
+      const batch = await rest.request("GET", path, undefined, {
+        signal: options.signal,
+        query: {
+          ...options.query,
+          limit,
+          ...cursor === undefined ? {} : { [cursorName]: cursor }
+        }
+      });
+      if (!Array.isArray(batch) || batch.length === 0)
+        return;
+      yield batch;
+      if (batch.length < limit)
+        return;
+      cursor = idOf(batch[batch.length - 1]);
+    }
+  };
+  const all = async (options = {}) => {
+    const max = options.max ?? DEFAULT_MAX;
+    const paging = { ...DEFAULT_PAGING, ...PAGING[last] };
+    const items = [];
+    if (max <= 0)
+      return items;
+    for await (const page of pages({
+      ...options,
+      limit: Math.min(options.limit ?? paging.limit, max)
+    })) {
+      items.push(...page);
+      if (items.length >= max)
+        break;
+    }
+    return items.slice(0, max);
+  };
+  const members = {
+    path,
+    get: send("GET", false),
+    post: send("POST", true),
+    put: send("PUT", true),
+    patch: send("PATCH", true),
+    delete: send("DELETE", false),
+    pages,
+    all,
+    toString: () => path
+  };
+  return new Proxy(function route() {}, {
+    get(_target, property) {
+      if (typeof property !== "string")
+        return;
+      if (property in members)
+        return members[property];
+      if (property === "then" || !SAFE_WORD.test(property))
+        return;
+      return node(rest, [...segments, kebab(property)]);
+    },
+    apply(_target, _this, args) {
+      if (args.length !== 1)
+        throw new TypeError(`Call a route with exactly one id, e.g. ${path}(id).`);
+      return node(rest, [...segments, idSegment(args[0])]);
+    }
+  });
+}
+function createApi2(rest) {
+  const root = node(rest, []);
+  return new Proxy(root, {
+    get(target, property, receiver) {
+      if (property === "to")
+        return (...segments) => {
+          if (segments.length === 0)
+            throw new TypeError("to() needs at least one segment.");
+          const cleaned = segments.map((segment) => {
+            const text = String(segment);
+            if (!SAFE_SEGMENT.test(text))
+              throw new TypeError(`Invalid route segment: ${JSON.stringify(text)}.`);
+            return text;
+          });
+          return node(rest, cleaned);
+        };
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
+// packages/core/src/commands.ts
+function settings(def) {
+  return def.config;
+}
+function define(kind, config, words) {
+  return { kind, config: config ?? {}, words };
+}
+var option2 = {
+  string: (config) => define("string", config),
+  integer: (config) => define("integer", config),
+  number: (config) => define("number", config),
+  boolean: (config) => define("boolean", config),
+  user: (config) => define("user", config),
+  role: (config) => define("role", config),
+  channel: (config) => define("channel", config),
+  mentionable: (config) => define("mentionable", config),
+  attachment: (config) => define("attachment", config),
+  choice: (words, config) => define("string", config, words)
+};
+var COMMAND_NAME = /^[-_\p{Ll}\p{Lo}\p{N}\p{sc=Deva}\p{sc=Thai}]{1,32}$/u;
+var channelTypes = (kinds) => [
+  ...new Set(kinds.flatMap((kind) => ChannelKinds2[kind]))
+];
+function named(builder, name, def) {
+  const config = settings(def);
+  return builder.setName(name).setDescription(config.description ?? name).setRequired(config.required === true);
+}
+function addOptionTo(slash, name, def) {
+  switch (def.kind) {
+    case "string": {
+      const config = def.config;
+      const text = named(new CreateStringOption2, name, def);
+      if (config.min !== undefined)
+        text.setMinLength(config.min);
+      if (config.max !== undefined)
+        text.setMaxLength(config.max);
+      const choices = def.words ?? config.choices;
+      if (choices?.length)
+        text.addChoices(...choices.map((choice) => typeof choice === "string" ? { name: choice, value: choice } : choice));
+      slash.addStringOption(() => text);
+      break;
+    }
+    case "integer":
+    case "number": {
+      const config = def.config;
+      const numeric = named(def.kind === "integer" ? new CreateIntegerOption2 : new CreateNumberOption2, name, def);
+      if (config.min !== undefined)
+        numeric.setMinValue(config.min);
+      if (config.max !== undefined)
+        numeric.setMaxValue(config.max);
+      if (config.choices?.length)
+        numeric.addChoices(...config.choices.map((choice) => typeof choice === "number" ? { name: String(choice), value: choice } : choice));
+      if (def.kind === "integer")
+        slash.addIntegerOption(() => numeric);
+      else
+        slash.addNumberOption(() => numeric);
+      break;
+    }
+    case "boolean":
+      slash.addBooleanOption(() => named(new CreateBooleanOption2, name, def));
+      break;
+    case "user":
+      slash.addUserOption(() => named(new CreateUserOption2, name, def));
+      break;
+    case "role":
+      slash.addRoleOption(() => named(new CreateRoleOption2, name, def));
+      break;
+    case "mentionable":
+      slash.addMentionableOption(() => named(new CreateMentionableOption2, name, def));
+      break;
+    case "attachment":
+      slash.addAttachmentOption(() => named(new CreateAttachmentOption2, name, def));
+      break;
+    case "channel": {
+      const config = def.config;
+      const channel = named(new CreateChannelOption2, name, def);
+      if (config.kinds?.length)
+        channel.addChannelTypes(...channelTypes(config.kinds));
+      slash.addChannelOption(() => channel);
+      break;
+    }
+  }
+}
+var PREFIX_TYPES = {
+  string: "string",
+  integer: "integer",
+  number: "number",
+  boolean: "boolean",
+  user: "user",
+  role: "role",
+  channel: "channel",
+  mentionable: "mentionable",
+  attachment: null
+};
+function prefixSpecs(options) {
+  const entries = Object.entries(options);
+  const specs = [];
+  for (const [index, [name, def]] of entries.entries()) {
+    const type = PREFIX_TYPES[def.kind];
+    if (type === null)
+      continue;
+    const config = def.config;
+    const choices = (def.words ?? config.choices)?.map((choice) => typeof choice === "object" ? choice.value : choice);
+    specs.push({
+      name,
+      type: type === "string" && index === entries.length - 1 ? "rest" : type,
+      required: settings(def).required === true && config.default === undefined,
+      min: config.min,
+      max: config.max,
+      maxLength: def.kind === "string" ? config.max : undefined,
+      choices
+    });
+  }
+  return specs;
+}
+function command2(definition) {
+  const slash = definition.slash ?? true;
+  const prefix = definition.prefix ? {
+    aliases: typeof definition.prefix === "object" ? [...definition.prefix.aliases ?? []] : []
+  } : false;
+  if (!COMMAND_NAME.test(definition.name))
+    throw new RangeError(`Invalid command name: ${definition.name}. Use 1-32 lowercase letters, digits, - or _.`);
+  if (definition.description.length < 1 || definition.description.length > 100)
+    throw new RangeError("A command description must be 1-100 characters.");
+  if (!slash && !prefix)
+    throw new TypeError(`Command ${definition.name} is neither a slash nor a prefix command.`);
+  for (const alias of prefix ? prefix.aliases : [])
+    if (!COMMAND_NAME.test(alias))
+      throw new RangeError(`Invalid alias for ${definition.name}: ${alias}.`);
+  const options = definition.options ?? {};
+  let optionalSeen;
+  for (const [name, def] of Object.entries(options)) {
+    const needed = settings(def).required === true;
+    if (needed && optionalSeen !== undefined)
+      throw new TypeError(`Option ${name} is required but follows the optional option ${optionalSeen}; put required options first.`);
+    if (!needed)
+      optionalSeen ??= name;
+  }
+  const permissions = definition.permissions ?? [];
+  const guildOnly = definition.guildOnly ?? permissions.length > 0;
+  const toJSON = () => {
+    const builder = new CreateSlashCommand2().setName(definition.name).setDescription(definition.description);
+    for (const [name, def] of Object.entries(options))
+      addOptionTo(builder, name, def);
+    if (permissions.length)
+      builder.setDefaultMemberPermissions(new PermissionSet2([...permissions]).bitfield);
+    if (guildOnly)
+      builder.setContexts(0);
+    if (definition.nsfw)
+      builder.setNSFW(true);
+    return builder.toJSON();
+  };
+  if (slash)
+    toJSON();
+  return Object.freeze({
+    name: definition.name,
+    description: definition.description,
+    options,
+    permissions,
+    guildOnly,
+    nsfw: definition.nsfw ?? false,
+    slash,
+    prefix,
+    run: definition.run,
+    toJSON,
+    usage(prefixText) {
+      const parts = Object.entries(options).map(([name, def]) => {
+        const required = settings(def).required === true && settings(def).default === undefined;
+        const label = def.kind === "attachment" ? `${name}\uD83D\uDCCE` : name;
+        return required ? `<${label}>` : `[${label}]`;
+      });
+      return [`${prefixText}${definition.name}`, ...parts].join(" ");
+    }
+  });
+}
+function applyDefault(def, value) {
+  if (value !== null && value !== undefined)
+    return value;
+  return settings(def).default;
+}
+function readSlashOptions(options, interaction) {
+  const values = {};
+  for (const [name, def] of Object.entries(options)) {
+    const source = interaction.options;
+    let value;
+    switch (def.kind) {
+      case "string":
+        value = source.getString(name);
+        break;
+      case "integer":
+        value = source.getInteger(name);
+        break;
+      case "number":
+        value = source.getNumber(name);
+        break;
+      case "boolean":
+        value = source.getBoolean(name);
+        break;
+      case "user":
+        value = idOf(source.getUser(name));
+        break;
+      case "role":
+        value = idOf(source.getRole(name));
+        break;
+      case "channel":
+        value = idOf(source.getChannel(name));
+        break;
+      case "mentionable": {
+        const id = idOf(source.getMentionable(name));
+        value = id ? { id, type: source.getMentionableType(name) ?? "user" } : null;
+        break;
+      }
+      case "attachment":
+        value = source.getAttachment(name);
+        break;
+    }
+    values[name] = applyDefault(def, value);
+  }
+  return values;
+}
+function idOf(record) {
+  return record === null ? null : String(record.id);
+}
+function words(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2");
+}
+
+class CommandRegistry2 {
+  #bot;
+  #commands = new Map;
+  #names = new Map;
+  #listening = false;
+  constructor(bot) {
+    this.#bot = bot;
+  }
+  add(...commands) {
+    for (const added of commands) {
+      const taken = [
+        added.name,
+        ...added.prefix ? added.prefix.aliases : []
+      ];
+      for (const name of taken) {
+        const owner = this.#names.get(name);
+        if (owner && owner.name !== added.name)
+          throw new TypeError(`The name "${name}" is already used by the ${owner.name} command.`);
+      }
+      const previous = this.#commands.get(added.name);
+      if (previous)
+        for (const name of [
+          previous.name,
+          ...previous.prefix ? previous.prefix.aliases : []
+        ])
+          this.#names.delete(name);
+      this.#commands.set(added.name, added);
+      if (added.slash || added.prefix)
+        for (const name of taken)
+          this.#names.set(name, added);
+    }
+    return this;
+  }
+  get(name) {
+    return this.#names.get(name.toLowerCase());
+  }
+  list() {
+    return [...this.#commands.values()];
+  }
+  async deploy(options = {}) {
+    if (!this.#bot.isReady())
+      throw new Error('Deploy commands after the client is ready: bot.once("ready", () => bot.commands.deploy()).');
+    const payloads = this.list().filter((entry) => entry.slash).map((entry) => entry.toJSON());
+    await (options.guildId === undefined ? this.#bot.application.commands.set(payloads) : this.#bot.application.commands.setGuild(options.guildId, payloads));
+    return payloads.length;
+  }
+  listen(options = {}) {
+    if (this.#listening)
+      throw new TypeError("bot.commands.listen() was already called.");
+    this.#listening = true;
+    const prefixes = options.prefix === undefined ? [] : typeof options.prefix === "string" ? [options.prefix] : [...options.prefix];
+    if (prefixes.some((prefix) => prefix === ""))
+      throw new TypeError("A command prefix cannot be empty.");
+    this.#bot.on("interactionCreate", async (interaction) => {
+      if (!interaction.isChatInputCommand())
+        return;
+      const found = this.#commands.get(interaction.commandName);
+      if (found?.slash)
+        await this.#runSlash(found, interaction);
+    });
+    if (prefixes.length) {
+      this.#warnAboutIntents();
+      this.#bot.on("messageCreate", async (message) => {
+        if (message.author.bot)
+          return;
+        const prefix = prefixes.find((p) => message.content.startsWith(p));
+        if (prefix !== undefined)
+          await this.#runPrefix(message, prefix);
+      });
+    }
+    return this;
+  }
+  #warnAboutIntents() {
+    const intents = resolveGatewayIntents2(this.#bot.options.intents);
+    const missing = [];
+    if ((intents & 1 << 15) === 0)
+      missing.push("MessageContent");
+    if ((intents & (1 << 9 | 1 << 12)) === 0)
+      missing.push("GuildMessages or DirectMessages");
+    if (missing.length === 0)
+      return;
+    process.emitWarning(`Prefix commands need the ${missing.join(" and ")} intent${missing.length > 1 ? "s" : ""}; without ${missing.length > 1 ? "them" : "it"} Discord sends empty message content and no prefix command will match.`, { type: "LunibeeWarning", code: "LUNIBEE_MESSAGE_CONTENT_INTENT" });
+  }
+  async#runSlash(found, interaction) {
+    let answered = false;
+    const reply = async (content) => {
+      const body = typeof content === "string" ? { content } : content;
+      if (answered)
+        await interaction.followUp(body);
+      else if (interaction.deferred)
+        await interaction.editReply(body);
+      else
+        await interaction.reply(body);
+      answered = true;
+    };
+    await found.run({
+      bot: this.#bot,
+      options: readSlashOptions(found.options, interaction),
+      source: "slash",
+      guildId: interaction.guildId,
+      channelId: interaction.channelId,
+      userId: interaction.user?.id ?? "",
+      member: interaction.member,
+      interaction,
+      message: undefined,
+      reply,
+      defer: async (deferOptions) => {
+        await interaction.deferReply({
+          ephemeral: deferOptions?.ephemeral ?? false
+        });
+      }
+    });
+  }
+  async#outOfScope(options, values, message) {
+    const guildId = message.guildId ?? undefined;
+    for (const [key, def] of Object.entries(options)) {
+      const value = values[key];
+      if (value === undefined || value === null)
+        continue;
+      if (def.kind === "channel") {
+        const id = String(value);
+        const channel = await this.#channel(id);
+        const inScope = guildId ? channel?.guildId === guildId : id === message.channelId;
+        if (!channel || !inScope)
+          return {
+            key,
+            error: guildId ? "must be a channel in this server" : "must be this channel"
+          };
+        const kinds = def.config.kinds;
+        if (kinds?.length && !channelTypes(kinds).includes(channel.type))
+          return {
+            key,
+            error: `must be a ${kinds.join(" or ")} channel`
+          };
+      }
+      const roleId = def.kind === "role" ? String(value) : def.kind === "mentionable" && value.type === "role" ? value.id : undefined;
+      if (roleId !== undefined && !(guildId && await this.#hasRole(guildId, roleId)))
+        return { key, error: "must be a role in this server" };
+    }
+    return;
+  }
+  async#channel(id) {
+    const cached = this.#bot.channels.get(id);
+    if (cached && !cached.partial)
+      return cached;
+    try {
+      return await this.#bot.channels.fetch(id);
+    } catch {
+      return;
+    }
+  }
+  async#hasRole(guildId, roleId) {
+    if (roleId === guildId)
+      return true;
+    const roles = this.#bot.guilds.roles(guildId);
+    if (roles.get(roleId))
+      return true;
+    try {
+      return (await roles.fetchAll()).some((role) => role.id === roleId);
+    } catch {
+      return false;
+    }
+  }
+  async#runPrefix(message, prefix) {
+    const text = message.content.slice(prefix.length).trim();
+    const [name = "", ...rest] = text.split(/\s+/);
+    const found = this.get(name);
+    if (!found?.prefix)
+      return;
+    const reply = async (content) => {
+      const { ephemeral: _ephemeral, ...body } = typeof content === "string" ? { content } : content;
+      await message.reply(body);
+    };
+    if (found.guildOnly && !message.guildId) {
+      await reply("This command only works in servers.");
+      return;
+    }
+    if (found.permissions.length) {
+      const lacking = found.permissions.filter((permission) => !message.member?.permissions.has(permission));
+      if (lacking.length) {
+        await reply(`You need ${lacking.map((p) => `**${words(p)}**`).join(", ")}.`);
+        return;
+      }
+    }
+    const parsed = parsePrefixArgs2(rest.join(" "), prefixSpecs(found.options));
+    const attachments = [...message.attachments];
+    const values = {};
+    if (parsed.ok)
+      for (const [key, def] of Object.entries(found.options)) {
+        if (def.kind === "attachment") {
+          const attachment = attachments.shift();
+          if (!attachment && settings(def).required === true) {
+            await reply(`\`${key}\` is required. Usage: \`${found.usage(prefix)}\``);
+            return;
+          }
+          values[key] = applyDefault(def, attachment);
+        } else
+          values[key] = applyDefault(def, parsed.values[key]);
+      }
+    else {
+      await reply(`\`${parsed.arg}\` ${parsed.error}. Usage: \`${found.usage(prefix)}\``);
+      return;
+    }
+    const outOfScope = await this.#outOfScope(found.options, values, message);
+    if (outOfScope) {
+      await reply(`\`${outOfScope.key}\` ${outOfScope.error}. Usage: \`${found.usage(prefix)}\``);
+      return;
+    }
+    await found.run({
+      bot: this.#bot,
+      options: values,
+      source: "prefix",
+      guildId: message.guildId,
+      channelId: message.channelId,
+      userId: message.author.id,
+      member: message.member ?? null,
+      interaction: undefined,
+      message,
+      reply,
+      defer: async () => {}
+    });
+  }
+}
+// packages/core/src/channel-create.ts
+var CREATABLE = [
+  "text",
+  "announcement",
+  "voice",
+  "stage",
+  "category",
+  "forum",
+  "media"
+];
+function emoji(value) {
+  return /^\d+$/.test(value) ? { emoji_id: value, emoji_name: null } : { emoji_id: null, emoji_name: value };
+}
+function channelCreatePayload2(options) {
+  if (!CREATABLE.includes(options.kind))
+    throw new TypeError(`Cannot create a ${String(options.kind)} channel here. Use one of: ${CREATABLE.join(", ")}.`);
+  if (options.name.length < 1 || options.name.length > 100)
+    throw new RangeError("A channel name must be 1-100 characters.");
+  const body = {
+    name: options.name,
+    type: ChannelKinds2[options.kind][0],
+    parent_id: options.parent,
+    position: options.position,
+    permission_overwrites: options.permissionOverwrites,
+    reason: options.reason
+  };
+  switch (options.kind) {
+    case "text":
+    case "announcement":
+    case "forum":
+    case "media": {
+      if (options.slowmode !== undefined && (!Number.isInteger(options.slowmode) || options.slowmode < 0 || options.slowmode > 21600))
+        throw new RangeError("slowmode must be 0-21600 seconds.");
+      body.topic = options.topic;
+      body.nsfw = options.nsfw;
+      body.rate_limit_per_user = options.slowmode;
+      body.default_auto_archive_duration = options.autoArchive;
+      if (options.kind === "forum" || options.kind === "media") {
+        body.default_thread_rate_limit_per_user = options.threadSlowmode;
+        body.available_tags = options.tags?.map((tag) => ({
+          name: tag.name,
+          moderated: tag.moderated ?? false,
+          ...tag.emoji ? emoji(tag.emoji) : {}
+        }));
+        if (options.defaultReaction)
+          body.default_reaction_emoji = emoji(options.defaultReaction);
+        if (options.sortOrder)
+          body.default_sort_order = options.sortOrder === "latest-activity" ? 0 : 1;
+        if (options.layout)
+          body.default_forum_layout = options.layout === "list" ? 1 : 2;
+      }
+      break;
+    }
+    case "voice":
+    case "stage":
+      if (options.userLimit !== undefined && (!Number.isInteger(options.userLimit) || options.userLimit < 0 || options.userLimit > 99))
+        throw new RangeError("userLimit must be 0-99.");
+      body.bitrate = options.bitrate;
+      body.user_limit = options.userLimit;
+      body.rtc_region = options.region;
+      body.nsfw = options.nsfw;
+      if (options.videoQuality)
+        body.video_quality_mode = options.videoQuality === "auto" ? 1 : 2;
+      break;
+    case "category":
+      break;
+  }
+  return body;
+}
+// packages/core/src/handles.ts
+var UNIT_MS = {
+  ms: 1,
+  s: 1000,
+  m: 60000,
+  h: 3600000,
+  d: 86400000,
+  w: 604800000
+};
+function parseDuration2(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0)
+      throw new RangeError("A duration must be a non-negative, finite number of milliseconds.");
+    return value;
+  }
+  const text = value.replace(/\s+/g, "").toLowerCase();
+  if (!/^(?:\d+(?:\.\d+)?(?:ms|s|m|h|d|w))+$/.test(text))
+    throw new RangeError(`Invalid duration: ${JSON.stringify(value)}. Use a number of milliseconds or text such as "90s", "10m" or "1h30m".`);
+  let total = 0;
+  for (const [, amount, unit] of text.matchAll(/(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/g))
+    total += Number(amount) * UNIT_MS[unit];
+  return Math.round(total);
+}
+function payload(input) {
+  return typeof input === "string" ? { content: input } : input;
+}
+
+class UserHandle2 {
+  bot;
+  id;
+  constructor(bot, id) {
+    this.bot = bot;
+    this.id = id;
+  }
+  peek() {
+    return this.bot.users.get(this.id);
+  }
+  get() {
+    return this.bot.users.resolve(this.id);
+  }
+  fetch() {
+    return this.bot.users.fetch(this.id);
+  }
+  async dm() {
+    const data = await this.bot.users.createDM(this.id);
+    this.bot.channels.upsert(data);
+    return new ChannelHandle2(this.bot, data.id);
+  }
+  async send(message) {
+    return (await this.dm()).send(message);
+  }
+}
+
+class GuildHandle2 {
+  bot;
+  id;
+  constructor(bot, id) {
+    this.bot = bot;
+    this.id = id;
+  }
+  peek() {
+    return this.bot.guilds.get(this.id);
+  }
+  get() {
+    return this.bot.guilds.resolve(this.id);
+  }
+  fetch() {
+    return this.bot.guilds.fetch(this.id);
+  }
+  get members() {
+    return this.bot.guilds.members(this.id).cache;
+  }
+  get roles() {
+    return this.bot.guilds.roles(this.id).cache;
+  }
+  get channels() {
+    return this.bot.channels.cache.filter((channel) => channel.guildId === this.id);
+  }
+  member(userId) {
+    return new MemberHandle2(this.bot, this.id, userId);
+  }
+  role(roleId) {
+    return new RoleHandle2(this.bot, this.id, roleId);
+  }
+  channel(channelId) {
+    return new ChannelHandle2(this.bot, channelId);
+  }
+  async createChannel(options) {
+    const channel = await this.bot.channels.create(this.id, channelCreatePayload2(options));
+    return channel.as(options.kind);
+  }
+  ban(userId, options) {
+    return this.bot.guilds.members(this.id).ban(userId, options);
+  }
+  unban(userId, reason) {
+    return this.bot.guilds.members(this.id).unban(userId, reason);
+  }
+  edit(options) {
+    return this.bot.guilds.edit(this.id, options);
+  }
+  leave() {
+    return this.bot.users.leaveGuild(this.id);
+  }
+}
+
+class MemberHandle2 {
+  bot;
+  guildId;
+  userId;
+  constructor(bot, guildId, userId) {
+    this.bot = bot;
+    this.guildId = guildId;
+    this.userId = userId;
+  }
+  get members() {
+    return this.bot.guilds.members(this.guildId);
+  }
+  peek() {
+    return this.members.get(this.userId);
+  }
+  get() {
+    return this.members.resolve(this.userId);
+  }
+  fetch() {
+    return this.members.fetch(this.userId);
+  }
+  guild() {
+    return new GuildHandle2(this.bot, this.guildId);
+  }
+  user() {
+    return new UserHandle2(this.bot, this.userId);
+  }
+  kick(reason) {
+    return this.members.kick(this.userId, reason);
+  }
+  ban(options) {
+    return this.members.ban(this.userId, options);
+  }
+  unban(reason) {
+    return this.members.unban(this.userId, reason);
+  }
+  edit(options) {
+    return this.members.edit(this.userId, options);
+  }
+  addRole(roleId, reason) {
+    return this.members.addRole(this.userId, roleId, reason);
+  }
+  removeRole(roleId, reason) {
+    return this.members.removeRole(this.userId, roleId, reason);
+  }
+  async timeout(duration, reason) {
+    return this.members.timeout(this.userId, duration === null ? null : parseDuration2(duration), reason);
+  }
+}
+
+class RoleHandle2 {
+  bot;
+  guildId;
+  roleId;
+  constructor(bot, guildId, roleId) {
+    this.bot = bot;
+    this.guildId = guildId;
+    this.roleId = roleId;
+  }
+  get roles() {
+    return this.bot.guilds.roles(this.guildId);
+  }
+  peek() {
+    return this.roles.get(this.roleId);
+  }
+  get() {
+    return this.roles.resolve(this.roleId);
+  }
+  fetch() {
+    return this.roles.fetch(this.roleId);
+  }
+  edit(options) {
+    return this.roles.edit(this.roleId, options);
+  }
+  delete(reason) {
+    return this.roles.remove(this.roleId, reason);
+  }
+}
+
+class ChannelHandle2 {
+  bot;
+  id;
+  constructor(bot, id) {
+    this.bot = bot;
+    this.id = id;
+  }
+  peek() {
+    return this.bot.channels.get(this.id);
+  }
+  get() {
+    return this.bot.channels.resolve(this.id);
+  }
+  fetch() {
+    return this.bot.channels.fetch(this.id);
+  }
+  message(messageId) {
+    return new MessageHandle2(this.bot, this.id, messageId);
+  }
+  async as(...kinds) {
+    return (await this.get()).as(...kinds);
+  }
+  send(message) {
+    return this.bot.channels.send(this.id, payload(message));
+  }
+  messages(query = {}) {
+    return this.bot.channels.fetchMessages(this.id, query);
+  }
+  edit(options) {
+    return this.bot.channels.edit(this.id, options);
+  }
+  delete(reason) {
+    return this.bot.channels.remove(this.id, reason);
+  }
+  bulkDelete(messageIds, reason) {
+    return this.bot.channels.bulkDeleteMessages(this.id, messageIds, reason);
+  }
+}
+
+class MessageHandle2 {
+  bot;
+  channelId;
+  messageId;
+  constructor(bot, channelId, messageId) {
+    this.bot = bot;
+    this.channelId = channelId;
+    this.messageId = messageId;
+  }
+  peek() {
+    return this.bot.channels.cachedMessages(this.channelId)?.cache.peek(this.messageId);
+  }
+  async get() {
+    return this.peek() ?? this.fetch();
+  }
+  fetch() {
+    return this.bot.channels.fetchMessage(this.channelId, this.messageId);
+  }
+  channel() {
+    return new ChannelHandle2(this.bot, this.channelId);
+  }
+  edit(message) {
+    return this.bot.channels.editMessage(this.channelId, this.messageId, typeof message === "string" ? { content: message } : message);
+  }
+  delete(reason) {
+    return this.bot.channels.deleteMessage(this.channelId, this.messageId, reason);
+  }
+  reply(message) {
+    return this.bot.channels.send(this.channelId, {
+      ...payload(message),
+      message_reference: {
+        message_id: this.messageId,
+        channel_id: this.channelId
+      }
+    });
+  }
+  react(emoji) {
+    return this.bot.channels.addReaction(this.channelId, this.messageId, emoji);
+  }
+  pin(reason) {
+    return this.bot.channels.pinMessage(this.channelId, this.messageId, reason);
+  }
+  unpin(reason) {
+    return this.bot.channels.unpinMessage(this.channelId, this.messageId, reason);
+  }
+  crosspost() {
+    return this.bot.channels.crosspostMessage(this.channelId, this.messageId);
+  }
+}
+// packages/core/src/index.ts
+class EventEmitter2 {
+  #listeners = {};
+  redactSecrets = (text) => text;
+  on(event, listener) {
+    if (typeof listener !== "function")
+      throw new TypeError("Event listener must be a function.");
+    (this.#listeners[event] ??= new Set).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[event]?.delete(listener);
+    return this;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  listenerCount(event) {
+    return this.#listeners[event]?.size ?? 0;
+  }
+  removeAllListeners(event) {
+    if (event === undefined)
+      this.#listeners = {};
+    else
+      delete this.#listeners[event];
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this.#listeners[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) {
+    const normalized = error instanceof Error ? error : new Error(String(error), { cause: error });
+    const errorListeners = this.#listeners["error" /* Error */];
+    const listeners = event === "error" /* Error */ ? [] : [...errorListeners ?? []];
+    if (listeners.length === 0)
+      return warnListenerError(event, normalized, this.redactSecrets);
+    for (const listener of listeners) {
+      try {
+        const result = listener(normalized);
+        if (result && typeof result.then === "function")
+          Promise.resolve(result).catch((failure) => warnListenerError("error" /* Error */, failure, this.redactSecrets));
+      } catch (failure) {
+        warnListenerError("error" /* Error */, failure, this.redactSecrets);
+      }
+    }
+  }
+}
+function warnListenerError(event, error, redact = (text) => text) {
+  const failure = error instanceof Error ? error : new Error(String(error));
+  process.emitWarning(redact(`A "${String(event)}" listener threw and no error listener handled it: ${failure.message}`), {
+    type: "LunibeeWarning",
+    code: "LUNIBEE_UNHANDLED_LISTENER_ERROR",
+    detail: failure.stack === undefined ? undefined : redact(failure.stack)
+  });
+}
+
+class Client2 extends EventEmitter2 {
+  options;
+  rest;
+  users;
+  guilds;
+  channels;
+  stageInstances;
+  application;
+  #api;
+  get api() {
+    return this.#api ??= createApi2(this.rest);
+  }
+  commands = new CommandRegistry2(this);
+  monetization;
+  applicationEmojis;
+  get ws() {
+    return this.#gateway;
+  }
+  get gateway() {
+    return this.#gateway;
+  }
+  user;
+  voice;
+  readyAt;
+  state = "idle";
+  redactSecrets = (text) => {
+    const token = this.options.token;
+    return token && token.length >= 8 ? text.split(token).join("[token]") : text;
+  };
+  get token() {
+    return this.state === "destroyed" ? null : this.options.token ?? null;
+  }
+  get uptime() {
+    return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
+  }
+  get ping() {
+    return this.#gateway.ping;
+  }
+  isReady() {
+    return this.state === "ready";
+  }
+  setPresence(data) {
+    return this.#gateway.setPresence(data);
+  }
+  setActivity(name, options = {}) {
+    const type = options.type ?? ActivityEnum2.Playing;
+    return this.setPresence({
+      status: options.status ?? "online",
+      activities: name === null ? [] : [
+        {
+          name,
+          type,
+          url: options.url,
+          state: options.state ?? (type === ActivityEnum2.Custom ? name : undefined)
+        }
+      ]
+    });
+  }
+  setVoiceState(data) {
+    return this.#gateway.setVoiceState(data);
+  }
+  sendVoiceState(guildId, channelId, options = {}) {
+    return this.#gateway.sendVoiceState(guildId, channelId, options);
+  }
+  requestGuildMembers(data) {
+    return this.#gateway.requestGuildMembers(data);
+  }
+  #gateway;
+  #cluster;
+  #identifyGate;
+  #collectors = new Set;
+  #cache;
+  #resourceContext;
+  #guildsIntent;
+  constructor(options) {
+    super();
+    this.options = options;
+    const client = this;
+    this.voice = new VoiceManager2({
+      get userId() {
+        return client.user?.id;
+      },
+      canSendVoiceState: (guildId) => client.#gateway.ownsGuild(guildId),
+      sendVoiceState: (guildId, channelId, voiceOptions) => client.#gateway.sendVoiceState(guildId, channelId, voiceOptions)
+    });
+    if (!options.token?.trim())
+      throw new TypeError("Client token is required.");
+    this.rest = new REST2({ token: options.token, ...options.rest });
+    this.#cache = {
+      users: true,
+      members: true,
+      roles: true,
+      emojis: true,
+      presences: false,
+      ...options.cache
+    };
+    this.#guildsIntent = Array.isArray(options.intents) && (resolveGatewayIntents2(options.intents) & GatewayIntentBits2.Guilds) !== 0;
+    this.users = new UserManager2(this.rest, {
+      maxSize: options.cache?.maxUsers
+    });
+    this.guilds = new GuildManager2(this.rest, {
+      maxMembers: options.cache?.maxMembers
+    });
+    this.channels = new ChannelManager2(this.rest, {
+      messageCache: options.messageCache,
+      allowedMentions: options.allowedMentions
+    });
+    this.stageInstances = new StageInstanceManager2(this.rest);
+    const placeholderAppCommands = new ApplicationCommandManager2(this.rest, "0");
+    this.application = { commands: placeholderAppCommands };
+    this.#resourceContext = this.#createResourceContext();
+    this.guilds.attachContext(this.#resourceContext);
+    this.#cluster = readClusterContext2();
+    const shardId = options.gateway?.shardId;
+    const gate = this.#cluster?.coordinatedIdentify && shardId !== undefined ? ClusterWorker2.current()?.identifyGate : undefined;
+    this.#identifyGate = gate;
+    this.#gateway = new Gateway2({
+      token: options.token,
+      intents: options.intents,
+      ...options.compress === undefined ? {} : { compress: options.compress },
+      ...gate ? {
+        identifyGate: {
+          acquire: () => gate.acquire(shardId),
+          release: () => gate.release(shardId)
+        }
+      } : {},
+      ...options.gateway
+    });
+    this.#wireLifecycle();
+    this.#wireMessages();
+    this.#wireGuilds();
+    this.#wireGuildFeatures();
+    this.#wireChannels();
+    this.#wireMisc();
+  }
+  #createResourceContext() {
+    return {
+      sendMessage: (channelId, options) => this.channels.send(channelId, options),
+      editMessage: (channelId, messageId, options) => this.channels.editMessage(channelId, messageId, options),
+      deleteMessage: (channelId, messageId, reason) => this.channels.deleteMessage(channelId, messageId, reason),
+      crosspostMessage: (channelId, messageId) => this.channels.crosspostMessage(channelId, messageId),
+      editChannel: (channelId, options) => this.channels.edit(channelId, options),
+      deleteChannel: (channelId, reason) => this.channels.remove(channelId, reason),
+      addReaction: (channelId, messageId, emoji) => this.channels.addReaction(channelId, messageId, emoji),
+      removeOwnReaction: (channelId, messageId, emoji) => this.channels.removeOwnReaction(channelId, messageId, emoji),
+      removeReaction: (channelId, messageId, emoji, userId) => this.channels.removeReaction(channelId, messageId, emoji, userId),
+      removeAllReactions: (channelId, messageId) => this.channels.removeAllReactions(channelId, messageId),
+      pinMessage: (channelId, messageId, reason) => this.channels.pinMessage(channelId, messageId, reason),
+      unpinMessage: (channelId, messageId, reason) => this.channels.unpinMessage(channelId, messageId, reason),
+      collectInteractions: (options) => this.createCollector("interactionCreate" /* InteractionCreate */, options),
+      cachedChannel: (channelId) => {
+        const channel = this.channels.get(channelId);
+        return channel && !channel.partial ? channel : undefined;
+      },
+      memberPermissions: (guildId, memberId, roleIds, channelId, timedOutUntil) => this.#memberPermissions(guildId, memberId, roleIds, channelId, timedOutUntil),
+      kickMember: (guildId, userId, reason) => this.guilds.members(guildId).kick(userId, reason),
+      banMember: (guildId, userId, options) => this.guilds.members(guildId).ban(userId, options),
+      editMember: (guildId, userId, options, reason) => this.guilds.members(guildId).edit(userId, {
+        ...options,
+        reason: typeof options.reason === "string" ? options.reason : reason
+      }),
+      addMemberRole: (guildId, userId, roleId, reason) => this.guilds.members(guildId).addRole(userId, roleId, reason),
+      removeMemberRole: (guildId, userId, roleId, reason) => this.guilds.members(guildId).removeRole(userId, roleId, reason),
+      editPermissionOverwrite: async (channelId, targetId, changes, options) => {
+        const bits = { allow: 0n, deny: 0n, inherit: 0n };
+        for (const [name, value] of Object.entries(changes)) {
+          if (!/^[A-Za-z]+$/.test(name))
+            throw new TypeError(`Unknown permission: ${name}`);
+          let bit;
+          try {
+            bit = new PermissionSet2(name).bitfield;
+          } catch {
+            throw new TypeError(`Unknown permission: ${name}`);
+          }
+          const key = value === true ? "allow" : value === false ? "deny" : "inherit";
+          bits[key] |= bit;
+        }
+        return this.channels.permissionOverwrites(channelId).update(targetId, bits, options);
+      }
+    };
+  }
+  #wireLifecycle() {
+    this.#gateway.on("READY", (data) => {
+      const ready = data;
+      this.user = ready.user;
+      this.users.set(this.user.id, new User2(this.user));
+      this.readyAt = new Date;
+      this.state = "ready";
+      const appId = ready.application?.id ?? this.user.id;
+      this.application.commands = new ApplicationCommandManager2(this.rest, appId);
+      if (this.monetization?.applicationId !== appId)
+        this.monetization = new MonetizationManager2(this.rest, appId);
+      if (this.applicationEmojis?.applicationId !== appId)
+        this.applicationEmojis = new ApplicationEmojiManager2(this.rest, appId);
+      this.emit("ready" /* Ready */, this.user);
+    });
+    this.#gateway.on("RESUMED", () => {
+      this.state = "ready";
+      this.emit("resumed" /* Resumed */);
+    });
+    this.#gateway.on("invalidSession", (isRecoverable) => {
+      this.emit("invalidSession" /* InvalidSession */, isRecoverable);
+    });
+    this.#gateway.on("open", () => this.emit("open" /* Open */));
+    this.#gateway.on("close", (data) => {
+      if (this.state !== "destroyed")
+        this.state = "idle";
+      this.emit("close" /* Close */, data);
+    });
+  }
+  #wireMessages() {
+    this.#gateway.on("MESSAGE_CREATE", (data) => {
+      const payload = data;
+      const message = new Message2(payload, this.#resourceContext);
+      this.#observeMessage(message);
+      if (payload.member && payload.guild_id && this.guilds.has(payload.guild_id))
+        this.#upsertMember(payload.guild_id, {
+          ...payload.member,
+          user: payload.member.user ?? payload.author
+        });
+      const cached = this.options.messageCache ? this.channels.messages(message.channelId).upsert(data) : message;
+      this.emit("messageCreate" /* MessageCreate */, cached);
+    });
+    this.#gateway.on("MESSAGE_UPDATE", (data) => {
+      const partial = data;
+      if (!partial.author) {
+        const cachedMessage = this.channels.cachedMessages(partial.channel_id)?.cache.peek(partial.id);
+        if (!cachedMessage)
+          return;
+        const before = this.listenerCount("messageUpdate" /* MessageUpdate */) ? this.#snapshot(cachedMessage) : null;
+        if (partial.content !== undefined)
+          cachedMessage.content = partial.content;
+        this.emit("messageUpdate" /* MessageUpdate */, cachedMessage, before);
+        return;
+      }
+      const message = new Message2(data, this.#resourceContext);
+      this.#observeMessage(message);
+      const messages = this.channels.cachedMessages(message.channelId);
+      const previous = messages?.cache.peek(message.id);
+      if (previous)
+        messages.set(message.id, message);
+      this.emit("messageUpdate" /* MessageUpdate */, message, previous ?? null);
+    });
+    this.#gateway.on("MESSAGE_DELETE", (data) => {
+      const payload = data;
+      const messages = this.channels.cachedMessages(payload.channel_id);
+      const removed = messages?.cache.peek(payload.id);
+      messages?.delete(payload.id);
+      this.emit("messageDelete" /* MessageDelete */, payload, removed);
+    });
+    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => {
+      const payload = data;
+      const messages = this.channels.cachedMessages(payload.channel_id);
+      const removed = [];
+      if (messages)
+        for (const id of payload.ids) {
+          const message = messages.cache.peek(id);
+          if (message)
+            removed.push(message);
+          messages.delete(id);
+        }
+      this.emit("messageDeleteBulk" /* MessageDeleteBulk */, payload, removed);
+    });
+    this.#gateway.on("MESSAGE_REACTION_ADD", (data) => this.emit("messageReactionAdd" /* MessageReactionAdd */, data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE", (data) => this.emit("messageReactionRemove" /* MessageReactionRemove */, data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE_ALL", (data) => this.emit("messageReactionRemoveAll" /* MessageReactionRemoveAll */, data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE_EMOJI", (data) => this.emit("messageReactionRemoveEmoji" /* MessageReactionRemoveEmoji */, data));
+    this.#gateway.on("MESSAGE_POLL_VOTE_ADD", (data) => this.emit("messagePollVoteAdd" /* MessagePollVoteAdd */, data));
+    this.#gateway.on("MESSAGE_POLL_VOTE_REMOVE", (data) => this.emit("messagePollVoteRemove" /* MessagePollVoteRemove */, data));
+  }
+  #wireGuilds() {
+    this.#gateway.on("GUILD_CREATE", (data) => {
+      const payload = data;
+      if (payload.unavailable) {
+        this.emit("guildUnavailable" /* GuildUnavailable */, payload);
+        return;
+      }
+      const wasCached = this.guilds.has(payload.id);
+      this.guilds.patch(payload);
+      for (const role of payload.roles ?? [])
+        this.#upsertRole(payload.id, role);
+      if (this.#cache.emojis) {
+        const emojis = this.guilds.emojis(payload.id);
+        for (const emoji of payload.emojis ?? [])
+          emojis.upsert(emoji);
+      }
+      for (const member of payload.members ?? [])
+        this.#upsertMember(payload.id, member);
+      for (const state of payload.voice_states ?? [])
+        this.#storeVoiceState(payload.id, state);
+      for (const channelData of [
+        ...payload.channels ?? [],
+        ...payload.threads ?? []
+      ])
+        this.channels.upsert({ ...channelData, guild_id: payload.id });
+      this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
+    });
+    this.#gateway.on("GUILD_UPDATE", (data) => {
+      const payload = data;
+      const cached = this.listenerCount("guildUpdate" /* GuildUpdate */) ? this.guilds.get(payload.id) : undefined;
+      const previous = cached ? this.#snapshot(cached) : null;
+      this.guilds.patch(payload);
+      this.emit("guildUpdate" /* GuildUpdate */, payload, previous);
+    });
+    this.#gateway.on("GUILD_DELETE", (data) => {
+      const payload = data;
+      if (payload.unavailable) {
+        this.emit("guildUnavailable" /* GuildUnavailable */, payload);
+        return;
+      }
+      this.guilds.delete(payload.id);
+      this.channels.deleteGuildChannels(payload.id);
+      this.voice.handleGuildRemove(payload.id);
+      this.emit("guildDelete" /* GuildDelete */, payload);
+    });
+    this.#gateway.on("GUILD_MEMBER_ADD", (data) => {
+      const member = data;
+      this.#upsertMember(member.guild_id, member);
+      this.emit("guildMemberAdd" /* GuildMemberAdd */, member);
+    });
+    this.#gateway.on("GUILD_MEMBER_UPDATE", (data) => {
+      const member = data;
+      const cached = this.#cache.members && !this.#guildGone(member.guild_id) ? this.guilds.members(member.guild_id).get(member.user.id) : undefined;
+      const previous = cached && this.listenerCount("guildMemberUpdate" /* GuildMemberUpdate */) ? this.#snapshot(cached, new GuildMember2({ user: member.user, guild_id: member.guild_id }, this.#resourceContext)) : null;
+      this.#upsertMember(member.guild_id, member);
+      this.emit("guildMemberUpdate" /* GuildMemberUpdate */, member, previous);
+    });
+    this.#gateway.on("GUILD_MEMBER_REMOVE", (data) => {
+      const member = data;
+      if (!this.#guildGone(member.guild_id))
+        this.guilds.members(member.guild_id).delete(member.user.id);
+      this.emit("guildMemberRemove" /* GuildMemberRemove */, member);
+    });
+    this.#gateway.on("GUILD_MEMBERS_CHUNK", (data) => {
+      const chunk = data;
+      for (const member of chunk.members)
+        this.#upsertMember(chunk.guild_id, member);
+      this.emit("guildMembersChunk" /* GuildMembersChunk */, chunk);
+    });
+    this.#gateway.on("GUILD_BAN_ADD", (data) => {
+      const ban = data;
+      if (!this.#guildGone(ban.guild_id)) {
+        const bans = this.guilds.bans(ban.guild_id);
+        bans.set(ban.user.id, {
+          reason: bans.get(ban.user.id)?.reason ?? null,
+          user: ban.user
+        });
+        this.guilds.members(ban.guild_id).delete(ban.user.id);
+      }
+      this.emit("guildBanAdd" /* GuildBanAdd */, ban);
+    });
+    this.#gateway.on("GUILD_BAN_REMOVE", (data) => {
+      const ban = data;
+      if (!this.#guildGone(ban.guild_id))
+        this.guilds.bans(ban.guild_id).delete(ban.user.id);
+      this.emit("guildBanRemove" /* GuildBanRemove */, ban);
+    });
+    this.#gateway.on("GUILD_ROLE_CREATE", (data) => {
+      const event = data;
+      this.#upsertRole(event.guild_id, event.role);
+      this.emit("guildRoleCreate" /* GuildRoleCreate */, event);
+    });
+    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => {
+      const event = data;
+      const cached = this.#cache.roles ? this.guilds.roles(event.guild_id).get(event.role.id) : undefined;
+      const previous = cached && this.listenerCount("guildRoleUpdate" /* GuildRoleUpdate */) ? this.#snapshot(cached) : null;
+      this.#upsertRole(event.guild_id, event.role);
+      this.emit("guildRoleUpdate" /* GuildRoleUpdate */, event, previous);
+    });
+    this.#gateway.on("GUILD_ROLE_DELETE", (data) => {
+      const event = data;
+      const roles = this.guilds.roles(event.guild_id);
+      const removed = roles.get(event.role_id) ?? null;
+      roles.delete(event.role_id);
+      this.emit("guildRoleDelete" /* GuildRoleDelete */, event, removed);
+    });
+  }
+  #wireGuildFeatures() {
+    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => {
+      const event = data;
+      let previous = null;
+      if (this.#cache.emojis) {
+        const emojis = this.guilds.emojis(event.guild_id);
+        if (this.listenerCount("guildEmojisUpdate" /* GuildEmojisUpdate */))
+          previous = [...emojis.cache.values()].map((emoji) => this.#snapshot(emoji));
+        const current = new Set(event.emojis.map((emoji) => emoji.id));
+        for (const id of [...emojis.cache.keys()])
+          if (!current.has(id))
+            emojis.delete(id);
+        for (const emoji of event.emojis)
+          emojis.upsert(emoji);
+      }
+      this.emit("guildEmojisUpdate" /* GuildEmojisUpdate */, event, previous);
+    });
+    this.#gateway.on("GUILD_STICKERS_UPDATE", (data) => {
+      const event = data;
+      const stickers = this.guilds.stickers(event.guild_id);
+      const previous = [...stickers.cache.values()];
+      stickers.sync(event.stickers);
+      this.emit("guildStickersUpdate" /* GuildStickersUpdate */, event, previous);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_CREATE", (data) => {
+      const sound = data;
+      if (sound.guild_id)
+        this.guilds.soundboard(sound.guild_id).set(sound.sound_id, sound);
+      this.emit("soundboardSoundCreate" /* SoundboardSoundCreate */, sound);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_UPDATE", (data) => {
+      const sound = data;
+      if (sound.guild_id)
+        this.guilds.soundboard(sound.guild_id).set(sound.sound_id, sound);
+      this.emit("soundboardSoundUpdate" /* SoundboardSoundUpdate */, sound);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_DELETE", (data) => {
+      const event = data;
+      this.guilds.soundboard(event.guild_id).delete(event.sound_id);
+      this.emit("soundboardSoundDelete" /* SoundboardSoundDelete */, event);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUNDS_UPDATE", (data) => {
+      const event = data;
+      const sounds = this.guilds.soundboard(event.guild_id);
+      sounds.clear();
+      for (const sound of event.soundboard_sounds)
+        sounds.set(sound.sound_id, sound);
+      this.emit("soundboardSoundsUpdate" /* SoundboardSoundsUpdate */, event);
+    });
+    this.#gateway.on("ENTITLEMENT_CREATE", (data) => {
+      const entitlement = data;
+      this.monetization?.set(entitlement.id, entitlement);
+      this.emit("entitlementCreate" /* EntitlementCreate */, entitlement);
+    });
+    this.#gateway.on("ENTITLEMENT_UPDATE", (data) => {
+      const entitlement = data;
+      this.monetization?.set(entitlement.id, entitlement);
+      this.emit("entitlementUpdate" /* EntitlementUpdate */, entitlement);
+    });
+    this.#gateway.on("ENTITLEMENT_DELETE", (data) => {
+      const entitlement = data;
+      this.monetization?.delete(entitlement.id);
+      this.emit("entitlementDelete" /* EntitlementDelete */, entitlement);
+    });
+    this.#gateway.on("GUILD_INTEGRATIONS_UPDATE", (data) => this.emit("guildIntegrationsUpdate" /* GuildIntegrationsUpdate */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_CREATE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).set(event.id, event);
+      this.emit("guildScheduledEventCreate" /* GuildScheduledEventCreate */, event);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_UPDATE", (data) => {
+      const event = data;
+      const events = this.guilds.scheduledEvents(event.guild_id);
+      const previous = events.get(event.id) ?? null;
+      events.set(event.id, event);
+      this.emit("guildScheduledEventUpdate" /* GuildScheduledEventUpdate */, event, previous);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_DELETE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).delete(event.id);
+      this.emit("guildScheduledEventDelete" /* GuildScheduledEventDelete */, event);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_USER_ADD", (data) => this.emit("guildScheduledEventUserAdd" /* GuildScheduledEventUserAdd */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_USER_REMOVE", (data) => this.emit("guildScheduledEventUserRemove" /* GuildScheduledEventUserRemove */, data));
+    this.#gateway.on("AUTO_MODERATION_RULE_CREATE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).set(rule.id, rule);
+      this.emit("autoModerationRuleCreate" /* AutoModerationRuleCreate */, rule);
+    });
+    this.#gateway.on("AUTO_MODERATION_RULE_UPDATE", (data) => {
+      const rule = data;
+      const rules = this.guilds.autoModerationRules(rule.guild_id);
+      const previous = rules.get(rule.id) ?? null;
+      rules.set(rule.id, rule);
+      this.emit("autoModerationRuleUpdate" /* AutoModerationRuleUpdate */, rule, previous);
+    });
+    this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).delete(rule.id);
+      this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, rule);
+    });
+    this.#gateway.on("AUTO_MODERATION_ACTION_EXECUTION", (data) => this.emit("autoModerationActionExecution" /* AutoModerationActionExecution */, data));
+  }
+  #wireChannels() {
+    this.#gateway.on("CHANNEL_CREATE", (data) => {
+      const channel = this.channels.upsert(data);
+      this.emit("channelCreate" /* ChannelCreate */, channel);
+    });
+    this.#gateway.on("CHANNEL_UPDATE", (data) => {
+      const previous = this.listenerCount("channelUpdate" /* ChannelUpdate */) ? this.#previousChannel(data) : null;
+      const channel = this.channels.upsert(data);
+      this.emit("channelUpdate" /* ChannelUpdate */, channel, previous);
+    });
+    this.#gateway.on("CHANNEL_DELETE", (data) => {
+      const payload = data;
+      const removed = this.channels.get(payload.id) ?? null;
+      this.channels.delete(payload.id);
+      this.emit("channelDelete" /* ChannelDelete */, payload, removed);
+    });
+    this.#gateway.on("CHANNEL_PINS_UPDATE", (data) => this.emit("channelPinsUpdate" /* ChannelPinsUpdate */, data));
+    this.#gateway.on("THREAD_CREATE", (data) => {
+      const channel = this.channels.upsert(data);
+      this.emit("threadCreate" /* ThreadCreate */, channel);
+    });
+    this.#gateway.on("THREAD_UPDATE", (data) => {
+      const previous = this.listenerCount("threadUpdate" /* ThreadUpdate */) ? this.#previousChannel(data) : null;
+      const channel = this.channels.upsert(data);
+      this.emit("threadUpdate" /* ThreadUpdate */, channel, previous);
+    });
+    this.#gateway.on("THREAD_DELETE", (data) => {
+      const payload = data;
+      const removed = this.channels.get(payload.id) ?? null;
+      this.channels.delete(payload.id);
+      this.emit("threadDelete" /* ThreadDelete */, payload, removed);
+    });
+    this.#gateway.on("THREAD_LIST_SYNC", (data) => {
+      const sync = data;
+      for (const thread of sync.threads)
+        this.channels.upsert({ ...thread, guild_id: sync.guild_id });
+      this.emit("threadListSync" /* ThreadListSync */, sync);
+    });
+    this.#gateway.on("THREAD_MEMBERS_UPDATE", (data) => this.emit("threadMembersUpdate" /* ThreadMembersUpdate */, data));
+    this.#gateway.on("THREAD_MEMBER_UPDATE", (data) => this.emit("threadMemberUpdate" /* ThreadMemberUpdate */, data));
+    this.#gateway.on("STAGE_INSTANCE_CREATE", (data) => {
+      const stage = data;
+      this.stageInstances.set(stage.channel_id, stage);
+      this.emit("stageInstanceCreate" /* StageInstanceCreate */, stage);
+    });
+    this.#gateway.on("STAGE_INSTANCE_UPDATE", (data) => {
+      const stage = data;
+      const previous = this.stageInstances.get(stage.channel_id) ?? null;
+      this.stageInstances.set(stage.channel_id, stage);
+      this.emit("stageInstanceUpdate" /* StageInstanceUpdate */, stage, previous);
+    });
+    this.#gateway.on("STAGE_INSTANCE_DELETE", (data) => {
+      const stage = data;
+      this.stageInstances.delete(stage.channel_id);
+      this.emit("stageInstanceDelete" /* StageInstanceDelete */, stage);
+    });
+    this.#gateway.on("INVITE_CREATE", (data) => {
+      const invite = data;
+      if (invite.guild_id)
+        this.guilds.invites(invite.guild_id).set(invite.code, invite);
+      this.emit("inviteCreate" /* InviteCreate */, invite);
+    });
+    this.#gateway.on("INVITE_DELETE", (data) => {
+      const invite = data;
+      if (invite.guild_id)
+        this.guilds.invites(invite.guild_id).delete(invite.code);
+      this.emit("inviteDelete" /* InviteDelete */, invite);
+    });
+    this.#gateway.on("WEBHOOKS_UPDATE", (data) => this.emit("webhooksUpdate" /* WebhooksUpdate */, data));
+  }
+  #wireMisc() {
+    this.#gateway.on("VOICE_STATE_UPDATE", (data) => {
+      const state = data;
+      const previous = state.guild_id ? this.guilds.voiceStates(state.guild_id).get(state.user_id) ?? null : null;
+      if (state.guild_id)
+        this.#storeVoiceState(state.guild_id, state);
+      this.voice.handleVoiceState({
+        ...state,
+        channel_id: state.channel_id ?? null
+      });
+      this.emit("voiceStateUpdate" /* VoiceStateUpdate */, state, previous);
+    });
+    this.#gateway.on("VOICE_SERVER_UPDATE", (data) => {
+      const server = data;
+      this.voice.handleVoiceServer({
+        ...server,
+        endpoint: server.endpoint ?? null
+      });
+      this.emit("voiceServerUpdate" /* VoiceServerUpdate */, server);
+    });
+    this.#gateway.on("PRESENCE_UPDATE", (data) => {
+      const presence = data;
+      let previous = null;
+      if (this.#cache.presences && presence.guild_id) {
+        const presences = this.guilds.presences(presence.guild_id);
+        previous = presences.get(presence.user.id) ?? null;
+        presences.set(presence.user.id, presence);
+      }
+      this.emit("presenceUpdate" /* PresenceUpdate */, presence, previous);
+    });
+    this.#gateway.on("TYPING_START", (data) => this.emit("typingStart" /* TypingStart */, data));
+    this.#gateway.on("INTERACTION_CREATE", (data) => this.emit("interactionCreate" /* InteractionCreate */, createInteraction2(this, data)));
+    this.#gateway.on("RAW", (data) => this.emit("raw" /* Raw */, data));
+    this.#gateway.on("error", (error) => this.emit("error" /* Error */, error));
+  }
+  #observeMessage(message) {
+    if (!this.channels.has(message.channelId))
+      this.channels.set(message.channelId, message.channel);
+    if (this.#cache.users)
+      this.#merge(this.users, message.author.id, message.author);
+  }
+  #upsertMember(guildId, data) {
+    const member = new GuildMember2({ ...data, guild_id: guildId }, this.#resourceContext);
+    if (this.#cache.users)
+      this.#merge(this.users, member.user.id, member.user);
+    if (!this.#cache.members || this.#guildGone(guildId))
+      return member;
+    const members = this.guilds.members(guildId);
+    const known = members.get(member.user.id);
+    const timedOutUntil = known?.timedOutUntil;
+    const merged = this.#merge(members, member.user.id, member);
+    if (known && timedOutUntil !== undefined && data.communication_disabled_until === undefined)
+      merged.timedOutUntil = timedOutUntil;
+    return merged;
+  }
+  #guildGone(guildId) {
+    return this.#guildsIntent && !this.guilds.has(guildId);
+  }
+  #storeVoiceState(guildId, state) {
+    const states = this.guilds.voiceStates(guildId);
+    if (state.channel_id)
+      states.set(state.user_id, state);
+    else
+      states.delete(state.user_id);
+  }
+  #upsertRole(guildId, data) {
+    if (!this.#cache.roles)
+      return new Role2(data);
+    return this.#merge(this.guilds.roles(guildId), data.id, new Role2(data));
+  }
+  #snapshot(cached, blank = Object.create(Object.getPrototypeOf(cached))) {
+    const from = cached;
+    const into = blank;
+    for (const key of Object.keys(from))
+      into[key] = from[key];
+    return blank;
+  }
+  #previousChannel(data) {
+    const cached = this.channels.get(data.id);
+    if (!cached)
+      return null;
+    return this.#snapshot(cached, createChannel2({ id: cached.id, type: cached.type, guild_id: cached.guildId }, this.#resourceContext));
+  }
+  #merge(manager, id, next) {
+    const existing = manager.get(id);
+    if (!existing) {
+      manager.set(id, next);
+      return next;
+    }
+    const from = next;
+    const into = existing;
+    for (const key of Object.keys(from)) {
+      const value = from[key];
+      if (value !== undefined)
+        into[key] = value;
+    }
+    manager.set(id, existing);
+    return existing;
+  }
+  createCollector(event, options = {}) {
+    const collector = new Collector2(options);
+    let order = 0;
+    const listener = (...args) => {
+      const item = args[0];
+      const id = item?.id;
+      const key = options.key?.(item) ?? (typeof id === "string" ? id : String(order++));
+      collector.handle(key, item).catch((error) => this.emit("error" /* Error */, error instanceof Error ? error : new Error(String(error))));
+    };
+    this.on(event, listener);
+    this.#collectors.add(collector);
+    collector.onDispose(() => {
+      this.off(event, listener);
+      this.#collectors.delete(collector);
+    });
+    return collector;
+  }
+  guild(id) {
+    return new GuildHandle2(this, id);
+  }
+  channel(id) {
+    return new ChannelHandle2(this, id);
+  }
+  person(id) {
+    return new UserHandle2(this, id);
+  }
+  member(guildId, userId) {
+    return new MemberHandle2(this, guildId, userId);
+  }
+  role(guildId, roleId) {
+    return new RoleHandle2(this, guildId, roleId);
+  }
+  message(channelId, messageId) {
+    return new MessageHandle2(this, channelId, messageId);
+  }
+  get resourceContext() {
+    return this.#resourceContext;
+  }
+  #memberPermissions(guildId, memberId, roleIds, channelId, timedOutUntil) {
+    const guild = this.guilds.get(guildId);
+    if (!guild)
+      return null;
+    let channel = channelId ? this.channels.get(channelId) : undefined;
+    if (channelId) {
+      if (channel?.isThread())
+        channel = channel.parentId ? this.channels.get(channel.parentId) : undefined;
+      if (!channel || channel.partial || channel.guildId !== guildId)
+        return null;
+    }
+    return computePermissions2({
+      guildId,
+      ownerId: guild.ownerId,
+      memberId,
+      memberRoleIds: [...roleIds],
+      roles: this.guilds.roles(guildId).values(),
+      overwrites: channel?.permissionOverwrites,
+      timedOutUntil
+    });
+  }
+  permissionsFor(memberId, guildOrChannelId) {
+    let channel = this.channels.get(guildOrChannelId);
+    if (channel?.partial)
+      return null;
+    if (channel?.isThread()) {
+      channel = channel.parentId ? this.channels.get(channel.parentId) : undefined;
+      if (!channel || channel.partial)
+        return null;
+    }
+    const guildId = channel?.guildId ?? guildOrChannelId;
+    const guild = this.guilds.get(guildId);
+    const member = this.guilds.members(guildId).get(memberId);
+    if (!guild || !member)
+      return null;
+    return computePermissions2({
+      guildId,
+      ownerId: guild.ownerId,
+      memberId,
+      memberRoleIds: member.roleIds,
+      roles: this.guilds.roles(guildId).values(),
+      overwrites: channel?.permissionOverwrites,
+      timedOutUntil: member.timedOutUntil
+    });
+  }
+  fetchDefaultSoundboardSounds() {
+    return this.rest.get(Routes2.soundboardDefaultSounds());
+  }
+  async login(token) {
+    if (this.state === "destroyed")
+      throw new Error("Cannot login a destroyed client.");
+    if (token?.trim()) {
+      this.rest.setToken(token);
+      this.options.token = token;
+    }
+    const usedToken = this.options.token;
+    if (!usedToken?.trim())
+      throw new TypeError("A bot token is required to log in.");
+    const shardId = this.#assertClusterShard();
+    this.state = "connecting";
+    if (this.#identifyGate && shardId !== undefined)
+      await connectInQueue2(this.#gateway, shardId, this.#identifyGate, {
+        waitForReady: this.#cluster?.startup === "sequential",
+        readyTimeout: this.#cluster?.readyTimeout
+      });
+    else
+      await this.#gateway.connect();
+    return usedToken;
+  }
+  #assertClusterShard() {
+    const cluster = this.#cluster;
+    if (!cluster)
+      return;
+    const { shardId, shardCount } = this.options.gateway ?? {};
+    const fix = `new Client({ \u2026, gateway: { shardId, shardCount: ${cluster.shardCount} } }) with shardId one of ${cluster.shardIds.join(", ")}, or a ShardManager to run them all`;
+    if (shardId === undefined)
+      throw new Error(`This process is cluster ${cluster.clusterId}'s worker: use ${fix}.`);
+    if (!cluster.shardIds.includes(shardId))
+      throw new Error(`Shard ${shardId} belongs to another cluster; cluster ${cluster.clusterId} runs ${cluster.shardIds.join(", ")}. Use ${fix}.`);
+    if (shardCount !== cluster.shardCount)
+      throw new Error(`gateway.shardCount must be the deployment's ${cluster.shardCount} shards (got ${String(shardCount)}).`);
+    return shardId;
+  }
+  destroy() {
+    this.state = "destroyed";
+    this.voice.destroy();
+    this.#gateway.close();
+    for (const collector of [...this.#collectors])
+      collector.stop("destroyed");
+    this.users.clear();
+    this.guilds.clear();
+    this.channels.clear();
+  }
+  postInteractionResponse(id, token, response) {
+    const json = response.toJSON();
+    const callback = response.withResponse ? `${Routes2.interactionCallback(id, token)}?with_response=true` : Routes2.interactionCallback(id, token);
+    const carriesMessage = json.type === 4 || json.type === 7;
+    const upload = json.data ? toRequest2(json.data, carriesMessage ? this.options.allowedMentions : undefined) : undefined;
+    return this.rest.post(callback, upload === undefined ? json : { ...json, data: upload.body }, { files: upload?.files });
+  }
+  editInteractionReply(token, data, applicationId) {
+    const appId = applicationId ?? this.user?.id;
+    if (!appId)
+      return Promise.reject(new Error("Client is unauthenticated."));
+    const { body, files } = toRequest2(data, this.options.allowedMentions);
+    return this.rest.patch(Routes2.interactionOriginalResponse(appId, token), body, { files });
+  }
+  deleteInteractionReply(token, applicationId) {
+    const appId = applicationId ?? this.user?.id;
+    if (!appId)
+      return Promise.reject(new Error("Client is unauthenticated."));
+    return this.rest.delete(Routes2.interactionOriginalResponse(appId, token));
+  }
+  async followUpInteraction(token, data, applicationId) {
+    const appId = applicationId ?? this.user?.id;
+    if (!appId)
+      return Promise.reject(new Error("Client is unauthenticated."));
+    const { body, files } = toRequest2(data, this.options.allowedMentions);
+    return this.rest.post(Routes2.webhook(appId, token), body, { files });
+  }
+  interactionWebhookMessage(method, applicationId, token, messageId, data) {
+    const path = messageId === "@original" ? Routes2.interactionOriginalResponse(applicationId, token) : Routes2.webhookMessage(applicationId, token, messageId);
+    if (method === "GET")
+      return this.rest.get(path);
+    if (method === "PATCH") {
+      const request = data ? toRequest2(data, this.options.allowedMentions) : undefined;
+      return this.rest.patch(path, request?.body, {
+        files: request?.files
+      });
+    }
+    return this.rest.delete(path);
+  }
+  async fetchWebhook(id, token) {
+    return this.rest.get(Routes2.webhook(id, token));
+  }
+  async fetchGuildPreview(guildId) {
+    return this.rest.get(Routes2.guildPreview(guildId));
+  }
+  fetchVoiceRegions() {
+    return this.rest.get("/voice/regions");
+  }
+  fetchInvite(code, options) {
+    const query = new URLSearchParams;
+    if (options?.withCounts)
+      query.set("with_counts", "true");
+    if (options?.guildScheduledEventId)
+      query.set("guild_scheduled_event_id", options.guildScheduledEventId);
+    const qs = query.toString();
+    return this.rest.get(`/invites/${encodeURIComponent(code)}${qs ? `?${qs}` : ""}`);
+  }
+  async fetchSticker(id) {
+    return this.rest.get(Routes2.sticker(id));
+  }
+  fetchPremiumStickerPacks() {
+    return this.rest.get(Routes2.stickerPacks());
+  }
+  fetchGuildTemplate(code) {
+    return this.rest.get(`/guilds/templates/${encodeURIComponent(code)}`);
+  }
+  generateInvite(options) {
+    if (!this.user)
+      throw new Error("Client must be ready to generate invite.");
+    const params = new URLSearchParams({
+      client_id: this.user.id,
+      scope: (options?.scopes ?? ["bot"]).join(" ")
+    });
+    if (options?.permissions) {
+      params.set("permissions", String(options.permissions));
+    }
+    return `https://discord.com/api/oauth2/authorize?${params.toString()}`;
+  }
+}
+
+export { ClientEvent2, Collector2, RedisCache2, createApi2, option2, command2, CommandRegistry2, channelCreatePayload2, parseDuration2, UserHandle2, GuildHandle2, MemberHandle2, RoleHandle2, ChannelHandle2, MessageHandle2, Client2 };
+
+//# debugId=BA934EB30EED6CAE64756E2164756E21