lunibee 0.2.3 → 0.3.0

package/dist/core/index.js

@@ -5,7 +5,6 @@ var PermissionOverwriteEnum;
   PermissionOverwriteEnum[PermissionOverwriteEnum["Role"] = 0] = "Role";
   PermissionOverwriteEnum[PermissionOverwriteEnum["Member"] = 1] = "Member";
 })(PermissionOverwriteEnum ||= {});
-var PermissionOverwriteType = PermissionOverwriteEnum;
 var Permission = {
   createInstantInvite: 1n << 0n,
   kickMembers: 1n << 1n,
@@ -114,60 +113,7 @@ var Permissions = {
   PinMessages: 1n << 51n,
   BypassSlowmode: 1n << 52n
 };
-var PermissionFlagsBits = {
-  CreateInstantInvite: 1n << 0n,
-  KickMembers: 1n << 1n,
-  BanMembers: 1n << 2n,
-  Administrator: 1n << 3n,
-  ManageChannels: 1n << 4n,
-  ManageGuild: 1n << 5n,
-  AddReactions: 1n << 6n,
-  ViewAuditLog: 1n << 7n,
-  PrioritySpeaker: 1n << 8n,
-  Stream: 1n << 9n,
-  ViewChannel: 1n << 10n,
-  SendMessages: 1n << 11n,
-  SendTTSMessages: 1n << 12n,
-  ManageMessages: 1n << 13n,
-  EmbedLinks: 1n << 14n,
-  AttachFiles: 1n << 15n,
-  ReadMessageHistory: 1n << 16n,
-  MentionEveryone: 1n << 17n,
-  UseExternalEmojis: 1n << 18n,
-  ViewGuildInsights: 1n << 19n,
-  Connect: 1n << 20n,
-  Speak: 1n << 21n,
-  MuteMembers: 1n << 22n,
-  DeafenMembers: 1n << 23n,
-  MoveMembers: 1n << 24n,
-  UseVAD: 1n << 25n,
-  ChangeNickname: 1n << 26n,
-  ManageNicknames: 1n << 27n,
-  ManageRoles: 1n << 28n,
-  ManageWebhooks: 1n << 29n,
-  ManageGuildExpressions: 1n << 30n,
-  UseApplicationCommands: 1n << 31n,
-  RequestToSpeak: 1n << 32n,
-  ManageEvents: 1n << 33n,
-  ManageThreads: 1n << 34n,
-  CreatePublicThreads: 1n << 35n,
-  CreatePrivateThreads: 1n << 36n,
-  UseExternalStickers: 1n << 37n,
-  SendMessagesInThreads: 1n << 38n,
-  UseEmbeddedActivities: 1n << 39n,
-  ModerateMembers: 1n << 40n,
-  ViewCreatorMonetizationAnalytics: 1n << 41n,
-  UseSoundboard: 1n << 42n,
-  CreateGuildExpressions: 1n << 43n,
-  CreateEvents: 1n << 44n,
-  UseExternalSounds: 1n << 45n,
-  SendVoiceMessages: 1n << 46n,
-  SetVoiceChannelStatus: 1n << 48n,
-  SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n,
-  PinMessages: 1n << 51n,
-  BypassSlowmode: 1n << 52n
-};
+var PermissionFlagsBits = Permissions;
 
 class PermissionSet {
   bitfield;
@@ -468,6 +414,9 @@ function computePermissions(context) {
   const member = overwrites.find((o) => o.type === 1 /* Member */ && o.id === context.memberId);
   if (member)
     base = base & ~bits(member.deny) | bits(member.allow);
+  const until = context.timedOutUntil instanceof Date ? context.timedOutUntil.getTime() : context.timedOutUntil ?? 0;
+  if (until > Date.now())
+    base &= Permission.viewChannel | Permission.readMessageHistory;
   return new PermissionSet(base);
 }
 // packages/core/src/events.ts
@@ -688,6 +637,152 @@ class Collector extends EventEmitter {
     });
   }
 }
+// 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 createApi(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/types/src/channel-kind.ts
+var ChannelKinds = {
+  text: [0],
+  dm: [1],
+  voice: [2],
+  "group-dm": [3],
+  category: [4],
+  announcement: [5],
+  thread: [10, 11, 12],
+  stage: [13],
+  directory: [14],
+  forum: [15],
+  media: [16]
+};
+var KIND_OF_TYPE = new Map(Object.keys(ChannelKinds).flatMap((kind) => ChannelKinds[kind].map((type) => [type, kind])));
+function channelKindOf(type) {
+  return KIND_OF_TYPE.get(type) ?? "unknown";
+}
 // packages/types/src/gateway.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
@@ -742,220 +837,1427 @@ var IntentBits = {
 };
 var Intents = IntentBits;
 function resolveGatewayIntents(intents) {
-  if (typeof intents === "number")
-    return intents;
-  if (intents && typeof intents === "object" && !Array.isArray(intents))
-    return intents.bitfield;
-  if (Array.isArray(intents)) {
-    return intents.reduce((acc, intent) => {
-      return acc | resolveGatewayIntents(intent);
-    }, 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;
+  if (!Array.isArray(intents))
+    throw new TypeError("Gateway intents must be an array, e.g. [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages].");
+  return intents.reduce((acc, intent) => acc | resolveIntent(intent), 0);
+}
+function resolveIntent(intent) {
+  if (typeof intent === "number")
+    return intent;
+  const bits = {
+    ...IntentBits,
+    ...GatewayIntentBits
+  };
+  const lower = intent.charAt(0).toLowerCase() + intent.slice(1);
+  if (Object.hasOwn(bits, intent))
+    return bits[intent];
+  if (Object.hasOwn(bits, lower))
+    return bits[lower];
+  const num = Number(intent);
+  return Number.isNaN(num) ? 0 : num;
+}
+function resolveInput(bits) {
+  return resolveGatewayIntents(Array.isArray(bits) ? bits : [bits]);
 }
 
 class IntentsBitField {
   static Flags = GatewayIntentBits;
   bitfield;
-  constructor(bits = 0) {
-    this.bitfield = resolveGatewayIntents(bits);
+  constructor(bits = []) {
+    this.bitfield = resolveInput(bits);
   }
   has(bits) {
-    const resolved = resolveGatewayIntents(bits);
+    const resolved = resolveInput(bits);
     return (this.bitfield & resolved) === resolved;
   }
   any(bits) {
-    return (this.bitfield & resolveGatewayIntents(bits)) !== 0;
+    return (this.bitfield & resolveInput(bits)) !== 0;
   }
   add(...bits) {
     for (const bit of bits)
-      this.bitfield |= resolveGatewayIntents(bit);
+      this.bitfield |= resolveInput(bit);
     return this;
   }
   remove(...bits) {
     for (const bit of bits)
-      this.bitfield &= ~resolveGatewayIntents(bit);
+      this.bitfield &= ~resolveInput(bit);
+    return this;
+  }
+  toArray() {
+    return Object.keys(GatewayIntentBits).filter((name) => this.has(GatewayIntentBits[name]));
+  }
+  equals(bits) {
+    return this.bitfield === resolveInput(bits);
+  }
+  valueOf() {
+    return this.bitfield;
+  }
+  toJSON() {
+    return this.bitfield;
+  }
+}
+// packages/types/src/index.ts
+var InteractionResponseEnum = {
+  Pong: 1,
+  ChannelMessage: 4,
+  DeferredChannelMessage: 5,
+  DeferredMessageUpdate: 6,
+  MessageUpdate: 7,
+  Autocomplete: 8,
+  Modal: 9
+};
+var ActivityEnum = {
+  Playing: 0,
+  Streaming: 1,
+  Listening: 2,
+  Watching: 3,
+  Custom: 4,
+  Competing: 5
+};
+
+// packages/builders/src/components.ts
+var IS_COMPONENTS_V2 = 1 << 15;
+// packages/builders/src/commands.ts
+var ApplicationCommandOptionEnum = {
+  Subcommand: 1,
+  SubcommandGroup: 2,
+  String: 3,
+  Integer: 4,
+  Boolean: 5,
+  User: 6,
+  Channel: 7,
+  Role: 8,
+  Mentionable: 9,
+  Number: 10,
+  Attachment: 11
+};
+function validateContexts(contexts) {
+  if (contexts.some((context) => context !== 0 && context !== 1 && context !== 2))
+    throw new RangeError("Command contexts must be 0, 1 or 2.");
+}
+
+class CreateSlashCommand {
+  #data = { type: 1 };
+  setName(name) {
+    validateName(name, "Command name");
+    this.#data.name = name;
+    return this;
+  }
+  setDescription(description) {
+    validateText(description, "Command description", 100);
+    this.#data.description = description;
+    return this;
+  }
+  setContexts(...contexts) {
+    validateContexts(contexts);
+    this.#data.contexts = [...contexts];
+    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 CreateStringOption));
+  }
+  addIntegerOption(configure) {
+    return this.addOption(configure(new CreateIntegerOption));
+  }
+  addNumberOption(configure) {
+    return this.addOption(configure(new CreateNumberOption));
+  }
+  addBooleanOption(configure) {
+    return this.addOption(configure(new CreateBooleanOption));
+  }
+  addUserOption(configure) {
+    return this.addOption(configure(new CreateUserOption));
+  }
+  addChannelOption(configure) {
+    return this.addOption(configure(new CreateChannelOption));
+  }
+  addRoleOption(configure) {
+    return this.addOption(configure(new CreateRoleOption));
+  }
+  addMentionableOption(configure) {
+    return this.addOption(configure(new CreateMentionableOption));
+  }
+  addAttachmentOption(configure) {
+    return this.addOption(configure(new CreateAttachmentOption));
+  }
+  addSubcommand(configure) {
+    return this.addOption(configure(new CreateSubcommand));
+  }
+  addSubcommandGroup(configure) {
+    return this.addOption(configure(new CreateSubcommandGroup));
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+  addOption(option) {
+    this.#data.options = appendOption(this.#data.options, option.toJSON(), "application command");
+    return this;
+  }
+}
+
+class CreateCommandOption {
+  data;
+  constructor(type) {
+    this.data = { type };
+  }
+  setName(name) {
+    validateName(name, "Option name");
+    this.data.name = name;
+    return this;
+  }
+  setDescription(description) {
+    validateText(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 CreateStringOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.String);
+  }
+  addChoices(...choices) {
+    for (const choice of choices)
+      validateText(choice.value, "Choice value", 100);
+    appendChoices(this.data, choices);
+    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 CreateNumericOption extends CreateCommandOption {
+  #integer;
+  constructor(type, integer) {
+    super(type);
+    this.#integer = integer;
+  }
+  setMinValue(value) {
+    validateNumberRange(value, -MAX_SAFE, MAX_SAFE, "min_value", this.#integer);
+    this.data.min_value = value;
+    return this;
+  }
+  setMaxValue(value) {
+    validateNumberRange(value, -MAX_SAFE, MAX_SAFE, "max_value", this.#integer);
+    const min = this.data.min_value;
+    if (min !== undefined && min > 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) {
+    appendChoices(this.data, choices);
+    return this;
+  }
+}
+
+class CreateIntegerOption extends CreateNumericOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Integer, true);
+  }
+}
+
+class CreateNumberOption extends CreateNumericOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Number, false);
+  }
+}
+
+class CreateBooleanOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Boolean);
+  }
+}
+
+class CreateUserOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.User);
+  }
+}
+
+class CreateRoleOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Role);
+  }
+}
+
+class CreateMentionableOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Mentionable);
+  }
+}
+
+class CreateAttachmentOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Attachment);
+  }
+}
+
+class CreateChannelOption extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.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 CreateSubcommand extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.Subcommand);
+  }
+  addStringOption(configure) {
+    return this.addChildOption(configure(new CreateStringOption));
+  }
+  addIntegerOption(configure) {
+    return this.addChildOption(configure(new CreateIntegerOption));
+  }
+  addNumberOption(configure) {
+    return this.addChildOption(configure(new CreateNumberOption));
+  }
+  addBooleanOption(configure) {
+    return this.addChildOption(configure(new CreateBooleanOption));
+  }
+  addUserOption(configure) {
+    return this.addChildOption(configure(new CreateUserOption));
+  }
+  addChannelOption(configure) {
+    return this.addChildOption(configure(new CreateChannelOption));
+  }
+  addRoleOption(configure) {
+    return this.addChildOption(configure(new CreateRoleOption));
+  }
+  addMentionableOption(configure) {
+    return this.addChildOption(configure(new CreateMentionableOption));
+  }
+  addAttachmentOption(configure) {
+    return this.addChildOption(configure(new CreateAttachmentOption));
+  }
+  addChildOption(option) {
+    const options = this.data.options ?? [];
+    if (options.some((existing) => existing.type === ApplicationCommandOptionEnum.Subcommand))
+      throw new RangeError("Subcommands cannot contain nested subcommands.");
+    this.data.options = appendOption(options, option.toJSON(), "subcommand");
+    return this;
+  }
+}
+
+class CreateSubcommandGroup extends CreateCommandOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum.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 CreateSubcommand).toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate subcommand name: ${String(payload.name)}.`);
+    if (payload.type !== ApplicationCommandOptionEnum.Subcommand)
+      throw new TypeError("Subcommand group children must be subcommands.");
+    options.push(payload);
+    this.data.options = options;
     return this;
   }
-  toArray() {
-    return Object.keys(GatewayIntentBits).filter((name) => this.has(GatewayIntentBits[name]));
+}
+var MAX_SAFE = Number.MAX_SAFE_INTEGER;
+function appendOption(options, payload, parent) {
+  const list = options ?? [];
+  if (list.length >= 25)
+    throw new RangeError(`${parent === "subcommand" ? "A subcommand" : "An application command"} cannot contain more than 25 options.`);
+  if (list.some((existing) => existing.name === payload.name))
+    throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
+  if (payload.required === true && list.some((existing) => existing.required !== true))
+    throw new RangeError(`Required ${parent} options must be placed before optional options.`);
+  return [...list, payload];
+}
+function appendChoices(data, choices) {
+  const current = data.choices ?? [];
+  if (!choices.length)
+    throw new TypeError("At least one choice is required.");
+  if (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)
+    validateText(choice.name, "Choice name", 100);
+  data.choices = [...current, ...choices.map((choice) => ({ ...choice }))];
+}
+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 validateText(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/utils/src/args.ts
+var SNOWFLAKE = /^\d{16,22}$/;
+var TRUE_WORDS = new Set([
+  "true",
+  "yes",
+  "y",
+  "on",
+  "1",
+  "enable",
+  "enabled"
+]);
+var FALSE_WORDS = new Set([
+  "false",
+  "no",
+  "n",
+  "off",
+  "0",
+  "disable",
+  "disabled"
+]);
+function tokenizeArgs(input) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let started = false;
+  for (let index = 0;index < input.length; index++) {
+    const character = input[index];
+    if (character === "\\" && index + 1 < input.length) {
+      current += input[++index];
+      started = true;
+    } else if (quote) {
+      if (character === quote)
+        quote = null;
+      else
+        current += character;
+    } else if (character === '"' || character === "'") {
+      if (started)
+        current += character;
+      else {
+        quote = character;
+        started = true;
+      }
+    } else if (/\s/.test(character)) {
+      if (started)
+        args.push(current);
+      current = "";
+      started = false;
+    } else {
+      current += character;
+      started = true;
+    }
+  }
+  if (started)
+    args.push(current);
+  return args;
+}
+function parseUserMention(value) {
+  const id = /^<@!?(\d{16,22})>$/.exec(value)?.[1] ?? value;
+  return SNOWFLAKE.test(id) ? id : null;
+}
+function parseRoleMention(value) {
+  const id = /^<@&(\d{16,22})>$/.exec(value)?.[1] ?? value;
+  return SNOWFLAKE.test(id) ? id : null;
+}
+function parseChannelMention(value) {
+  const id = /^<#(\d{16,22})>$/.exec(value)?.[1] ?? value;
+  return SNOWFLAKE.test(id) ? id : null;
+}
+function parseMentionable(value) {
+  const role = /^<@&(\d{16,22})>$/.exec(value)?.[1];
+  if (role)
+    return { id: role, type: "role" };
+  const user = parseUserMention(value);
+  return user ? { id: user, type: "user" } : null;
+}
+function readOne(spec, raw) {
+  switch (spec.type) {
+    case "string":
+    case "rest":
+      if (spec.maxLength !== undefined && raw.length > spec.maxLength)
+        return {
+          error: `must be at most ${spec.maxLength} characters`
+        };
+      if (spec.choices && !spec.choices.some((choice) => String(choice).toLowerCase() === raw.toLowerCase()))
+        return { error: `must be one of: ${spec.choices.join(", ")}` };
+      return { value: raw };
+    case "integer":
+    case "number": {
+      const value = Number(raw);
+      if (!Number.isFinite(value) || raw.trim() === "")
+        return { error: "must be a number" };
+      if (spec.type === "integer" && !Number.isSafeInteger(value))
+        return { error: "must be a whole number" };
+      if (spec.min !== undefined && value < spec.min)
+        return { error: `must be at least ${spec.min}` };
+      if (spec.max !== undefined && value > spec.max)
+        return { error: `must be at most ${spec.max}` };
+      if (spec.choices && !spec.choices.includes(value))
+        return { error: `must be one of: ${spec.choices.join(", ")}` };
+      return { value };
+    }
+    case "boolean": {
+      const word = raw.toLowerCase();
+      if (TRUE_WORDS.has(word))
+        return { value: true };
+      if (FALSE_WORDS.has(word))
+        return { value: false };
+      return { error: "must be yes or no" };
+    }
+    case "user": {
+      const id = parseUserMention(raw);
+      return id ? { value: id } : { error: "must be a user mention or ID" };
+    }
+    case "role": {
+      const id = parseRoleMention(raw);
+      return id ? { value: id } : { error: "must be a role mention or ID" };
+    }
+    case "channel": {
+      const id = parseChannelMention(raw);
+      return id ? { value: id } : { error: "must be a channel mention or ID" };
+    }
+    case "mentionable": {
+      const value = parseMentionable(raw);
+      return value ? { value } : { error: "must be a user or role mention" };
+    }
+  }
+}
+function parsePrefixArgs(input, specs) {
+  const args = typeof input === "string" ? tokenizeArgs(input) : [...input];
+  const values = {};
+  let position = 0;
+  for (const [index, spec] of specs.entries()) {
+    if (spec.type === "rest" && index !== specs.length - 1)
+      throw new TypeError(`The rest argument "${spec.name}" must be the last one.`);
+    const raw = spec.type === "rest" ? args.slice(position).join(" ") : args[position];
+    if (raw === undefined || raw === "") {
+      if (spec.required)
+        return { ok: false, arg: spec.name, error: "is required" };
+      values[spec.name] = undefined;
+      continue;
+    }
+    const read = readOne(spec, raw);
+    if ("error" in read)
+      return { ok: false, arg: spec.name, error: read.error };
+    values[spec.name] = read.value;
+    position += spec.type === "rest" ? args.length : 1;
+  }
+  return { ok: true, values };
+}
+// packages/core/src/commands.ts
+function settings(def) {
+  return def.config;
+}
+function define(kind, config, words) {
+  return { kind, config: config ?? {}, words };
+}
+var option = {
+  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) => ChannelKinds[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 CreateStringOption, 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 CreateIntegerOption : new CreateNumberOption, 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 CreateBooleanOption, name, def));
+      break;
+    case "user":
+      slash.addUserOption(() => named(new CreateUserOption, name, def));
+      break;
+    case "role":
+      slash.addRoleOption(() => named(new CreateRoleOption, name, def));
+      break;
+    case "mentionable":
+      slash.addMentionableOption(() => named(new CreateMentionableOption, name, def));
+      break;
+    case "attachment":
+      slash.addAttachmentOption(() => named(new CreateAttachmentOption, name, def));
+      break;
+    case "channel": {
+      const config = def.config;
+      const channel = named(new CreateChannelOption, 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 command(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 CreateSlashCommand().setName(definition.name).setDescription(definition.description);
+    for (const [name, def] of Object.entries(options))
+      addOptionTo(builder, name, def);
+    if (permissions.length)
+      builder.setDefaultMemberPermissions(new PermissionSet([...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 CommandRegistry {
+  #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 = resolveGatewayIntents(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#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 = parsePrefixArgs(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;
+    }
+    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 channelCreatePayload(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: ChannelKinds[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 parseDuration(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 UserHandle {
+  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 ChannelHandle(this.bot, data.id);
+  }
+  async send(message) {
+    return (await this.dm()).send(message);
+  }
+}
+
+class GuildHandle {
+  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 MemberHandle(this.bot, this.id, userId);
+  }
+  role(roleId) {
+    return new RoleHandle(this.bot, this.id, roleId);
+  }
+  channel(channelId) {
+    return new ChannelHandle(this.bot, channelId);
+  }
+  async createChannel(options) {
+    const channel = await this.bot.channels.create(this.id, channelCreatePayload(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 MemberHandle {
+  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 GuildHandle(this.bot, this.guildId);
+  }
+  user() {
+    return new UserHandle(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 : parseDuration(duration), reason);
+  }
+}
+
+class RoleHandle {
+  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 ChannelHandle {
+  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 MessageHandle(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 MessageHandle {
+  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);
   }
-  equals(bits) {
-    return this.bitfield === resolveGatewayIntents(bits);
+  async get() {
+    return this.peek() ?? this.fetch();
   }
-  valueOf() {
-    return this.bitfield;
+  fetch() {
+    return this.bot.channels.fetchMessage(this.channelId, this.messageId);
   }
-  toJSON() {
-    return this.bitfield;
+  channel() {
+    return new ChannelHandle(this.bot, this.channelId);
   }
-}
-// packages/types/src/index.ts
-var InteractionResponseEnum = {
-  Pong: 1,
-  ChannelMessage: 4,
-  DeferredChannelMessage: 5,
-  DeferredMessageUpdate: 6,
-  MessageUpdate: 7,
-  Autocomplete: 8,
-  Modal: 9
-};
-// packages/collection/src/index.ts
-class RecencyList {
-  #nodes = new Map;
-  #oldest;
-  #newest;
-  get size() {
-    return this.#nodes.size;
-  }
-  oldest() {
-    return this.#oldest?.key;
-  }
-  touch(key) {
-    const node = this.#nodes.get(key);
-    if (node)
-      return this.#moveNewest(node);
-    const created = { key, older: this.#newest };
-    if (this.#newest)
-      this.#newest.newer = created;
-    else
-      this.#oldest = created;
-    this.#newest = created;
-    this.#nodes.set(key, created);
+  edit(message) {
+    return this.bot.channels.editMessage(this.channelId, this.messageId, typeof message === "string" ? { content: message } : message);
   }
-  promote(key) {
-    const node = this.#nodes.get(key);
-    if (node)
-      this.#moveNewest(node);
+  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
+      }
+    });
   }
-  delete(key) {
-    const node = this.#nodes.get(key);
-    if (!node)
-      return false;
-    this.#unlink(node);
-    this.#nodes.delete(key);
-    return true;
+  react(emoji) {
+    return this.bot.channels.addReaction(this.channelId, this.messageId, emoji);
   }
-  clear() {
-    this.#nodes.clear();
-    this.#oldest = this.#newest = undefined;
+  pin(reason) {
+    return this.bot.channels.pinMessage(this.channelId, this.messageId, reason);
   }
-  #unlink(node) {
-    if (node.older)
-      node.older.newer = node.newer;
-    else
-      this.#oldest = node.newer;
-    if (node.newer)
-      node.newer.older = node.older;
-    else
-      this.#newest = node.older;
-    node.older = node.newer = undefined;
+  unpin(reason) {
+    return this.bot.channels.unpinMessage(this.channelId, this.messageId, reason);
   }
-  #moveNewest(node) {
-    if (node === this.#newest)
-      return;
-    this.#unlink(node);
-    node.older = this.#newest;
-    if (this.#newest)
-      this.#newest.newer = node;
-    else
-      this.#oldest = node;
-    this.#newest = node;
+  crosspost() {
+    return this.bot.channels.crosspostMessage(this.channelId, this.messageId);
   }
 }
+// packages/collection/src/index.ts
+function newPolicy(options = {}) {
+  return {
+    ttl: options.ttl,
+    jitter: options.jitter ?? 0,
+    maxSize: options.maxSize,
+    slide: options.slide ?? true,
+    onEvict: options.onEvict,
+    expired: 0,
+    evicted: 0,
+    entries: new Map,
+    oldest: undefined,
+    newest: undefined,
+    lruSize: 0,
+    heap: [],
+    armedFor: Infinity
+  };
+}
+function peekOf(collection, key) {
+  return collection instanceof Map ? Map.prototype.get.call(collection, key) : collection.get(key);
+}
+var mapGet = Map.prototype.get;
+var mapHas = Map.prototype.has;
+function sample(items, amount) {
+  if (!Number.isInteger(amount) || amount < 0)
+    throw new RangeError("amount must be a non-negative integer.");
+  const count = Math.min(amount, items.length);
+  for (let i = 0;i < count; i++) {
+    const j = i + Math.floor(Math.random() * (items.length - i));
+    [items[i], items[j]] = [items[j], items[i]];
+  }
+  items.length = count;
+  return items;
+}
 function assertTTL(ttl) {
   if (ttl !== undefined && (!Number.isFinite(ttl) || ttl <= 0))
     throw new RangeError("TTL must be a positive number, or omitted.");
 }
 
 class Collection extends Map {
-  #ttl;
-  #maxSize;
-  #onEvict;
-  #expiry = new Map;
-  #lru = new RecencyList;
-  #stats = {
-    hits: 0,
-    misses: 0,
-    expired: 0,
-    evicted: 0
-  };
-  #heap = [];
-  #timer;
-  #armedFor = Infinity;
+  #policy;
+  #hits = 0;
+  #misses = 0;
   constructor(entries, options = {}) {
     super();
     assertTTL(options.ttl);
+    if (options.jitter !== undefined && !(options.jitter >= 0 && options.jitter <= 1))
+      throw new RangeError("jitter must be between 0 and 1.");
     if (options.maxSize !== undefined && (!Number.isInteger(options.maxSize) || options.maxSize <= 0))
       throw new RangeError("maxSize must be a positive integer.");
-    this.#ttl = options.ttl;
-    this.#maxSize = options.maxSize;
-    this.#onEvict = options.onEvict;
+    if (options.ttl !== undefined || options.jitter !== undefined || options.maxSize !== undefined || options.slide !== undefined || options.onEvict !== undefined)
+      this.#policy = newPolicy(options);
     if (entries)
       for (const [key, value] of entries)
         this.set(key, value);
   }
   set(key, value, ttl) {
+    if (ttl === undefined && this.#policy === undefined)
+      return super.set(key, value);
     assertTTL(ttl);
-    const window = ttl ?? this.#ttl;
-    if (this.#maxSize !== undefined) {
-      this.#lru.touch(key);
-    }
-    super.set(key, value);
+    let window = ttl ?? this.#policy?.ttl;
+    const jitter = this.#policy?.jitter ?? 0;
+    if (window !== undefined && jitter > 0)
+      window = Math.max(1, window * (1 - jitter * Math.random()));
     if (window !== undefined)
-      this.#schedule(key, window);
-    else if (this.#expiry.size > 0)
-      this.#expiry.delete(key);
+      this.#policy ??= newPolicy();
+    if (!this.#policy)
+      return super.set(key, value);
+    const before = super.size;
+    super.set(key, value);
+    this.#track(key, value, window, super.size !== before);
     this.#enforceCap();
     return this;
   }
   setWithoutTTL(key, value) {
-    if (this.#expiry.size > 0)
-      this.#expiry.delete(key);
-    if (this.#lru.size > 0)
-      this.#lru.delete(key);
+    if (this.#policy)
+      this.#forget(key);
     super.set(key, value);
     return this;
   }
   get(key) {
-    if (this.#expireIfDue(key)) {
-      this.#stats.misses++;
+    const policy = this.#policy;
+    const entry = policy?.entries.get(key);
+    if (entry === undefined) {
+      const value = mapGet.call(this, key);
+      if (value !== undefined || mapHas.call(this, key)) {
+        this.#hits++;
+        return value;
+      }
+      this.#misses++;
       return;
     }
-    const value = super.get(key);
-    if (value === undefined && !super.has(key)) {
-      this.#stats.misses++;
+    const timed = entry.window !== 0;
+    const now = timed ? Date.now() : 0;
+    if (timed && entry.deadline <= now) {
+      this.#expire(entry);
+      this.#misses++;
       return;
     }
-    this.#stats.hits++;
-    const expiry = this.#expiry.get(key);
-    if (expiry)
-      expiry.deadline = Date.now() + expiry.window;
-    this.#lru.promote(key);
-    return value;
+    this.#hits++;
+    if (timed && policy.slide)
+      entry.deadline = now + entry.window;
+    if (entry.inLru)
+      this.#promote(policy, entry);
+    return entry.value;
+  }
+  ensure(key, factory, ttl) {
+    const existing = this.get(key);
+    if (existing !== undefined || super.has(key))
+      return existing;
+    const created = factory(key, this);
+    this.set(key, created, ttl);
+    return created;
   }
   peek(key) {
     if (!this.#expireIfDue(key) && super.has(key)) {
-      this.#stats.hits++;
+      this.#hits++;
       return super.get(key);
     }
-    this.#stats.misses++;
+    this.#misses++;
     return;
   }
   get stats() {
-    return { ...this.#stats };
+    return {
+      hits: this.#hits,
+      misses: this.#misses,
+      expired: this.#policy?.expired ?? 0,
+      evicted: this.#policy?.evicted ?? 0
+    };
   }
   has(key) {
     return !this.#expireIfDue(key) && super.has(key);
@@ -963,19 +2265,23 @@ class Collection extends Map {
   delete(key) {
     if (this.#expireIfDue(key))
       return false;
-    this.#expiry.delete(key);
-    this.#lru.delete(key);
+    if (this.#policy)
+      this.#forget(key);
     return super.delete(key);
   }
   clear() {
     super.clear();
-    this.#expiry.clear();
-    this.#lru.clear();
-    this.#heap.length = 0;
-    if (this.#timer)
-      clearTimeout(this.#timer);
-    this.#timer = undefined;
-    this.#armedFor = Infinity;
+    const policy = this.#policy;
+    if (!policy)
+      return;
+    policy.entries.clear();
+    policy.oldest = policy.newest = undefined;
+    policy.lruSize = 0;
+    policy.heap.length = 0;
+    if (policy.timer)
+      clearTimeout(policy.timer);
+    policy.timer = undefined;
+    policy.armedFor = Infinity;
   }
   get size() {
     this.purge();
@@ -1003,11 +2309,11 @@ class Collection extends Map {
   ttlRemaining(key) {
     if (this.#expireIfDue(key))
       return;
-    const expiry = this.#expiry.get(key);
-    return expiry && Math.max(0, expiry.deadline - Date.now());
+    const entry = this.#policy?.entries.get(key);
+    return entry && entry.window !== 0 ? Math.max(0, entry.deadline - Date.now()) : undefined;
   }
   purge() {
-    if (this.#expiry.size === 0)
+    if (!this.#policy || this.#policy.heap.length === 0)
       return 0;
     const now = Date.now();
     let removed = 0;
@@ -1018,133 +2324,255 @@ class Collection extends Map {
       this.#remove(due.key);
       removed++;
     }
-    this.#stats.expired += removed;
+    this.#policy.expired += removed;
     this.#rearm();
     for (const [key, value] of dropped)
       this.#notify(key, value, "expired");
     return removed;
   }
   #expireIfDue(key) {
-    const expiry = this.#expiry.get(key);
-    if (!expiry || expiry.deadline > Date.now())
+    const entry = this.#policy?.entries.get(key);
+    if (!entry || entry.window === 0 || entry.deadline > Date.now())
       return false;
-    const value = super.get(key);
-    this.#remove(key);
-    this.#stats.expired++;
-    this.#notify(key, value, "expired");
+    this.#expire(entry);
     return true;
   }
+  #expire(entry) {
+    const value = super.get(entry.key);
+    this.#remove(entry.key);
+    this.#policy.expired++;
+    this.#notify(entry.key, value, "expired");
+  }
   #remove(key) {
-    this.#expiry.delete(key);
-    this.#lru.delete(key);
+    this.#forget(key);
     super.delete(key);
   }
+  #forget(key) {
+    const policy = this.#policy;
+    const entry = policy.entries.get(key);
+    if (!entry)
+      return;
+    if (entry.inLru)
+      this.#unlink(policy, entry);
+    policy.entries.delete(key);
+  }
+  #track(key, value, window, isNew) {
+    const policy = this.#policy;
+    const lru = policy.maxSize !== undefined;
+    let entry = isNew ? undefined : policy.entries.get(key);
+    if (entry)
+      entry.value = value;
+    if (window === undefined) {
+      if (entry && entry.window !== 0) {
+        if (lru)
+          entry = this.#replace(policy, entry, 0, 0);
+        else {
+          this.#forget(key);
+          return;
+        }
+      }
+      if (!entry && lru) {
+        entry = this.#create(key, value, 0, 0);
+        policy.entries.set(key, entry);
+      }
+      if (entry)
+        this.#promote(policy, entry);
+      return;
+    }
+    const deadline = Date.now() + window;
+    if (entry && entry.window !== 0) {
+      entry.deadline = deadline;
+      entry.window = window;
+      if (deadline < entry.filed)
+        entry = this.#replace(policy, entry, window, deadline);
+      else {
+        if (entry.inLru)
+          this.#promote(policy, entry);
+        return;
+      }
+    } else if (entry) {
+      entry.window = window;
+      entry.deadline = entry.filed = deadline;
+    } else {
+      entry = this.#create(key, value, window, deadline);
+      policy.entries.set(key, entry);
+    }
+    if (lru)
+      this.#promote(policy, entry);
+    this.#heapPush(entry);
+    if (policy.heap.length > 2 * policy.entries.size + 8)
+      this.#compact();
+    if (policy.timer === undefined || deadline < policy.armedFor)
+      this.#rearm();
+  }
+  #create(key, value, window, deadline) {
+    return {
+      key,
+      value,
+      older: undefined,
+      newer: undefined,
+      inLru: false,
+      window,
+      deadline,
+      filed: deadline
+    };
+  }
+  #replace(policy, old, window, deadline) {
+    const entry = {
+      ...old,
+      window,
+      deadline,
+      filed: deadline
+    };
+    if (old.inLru) {
+      if (old.older)
+        old.older.newer = entry;
+      else
+        policy.oldest = entry;
+      if (old.newer)
+        old.newer.older = entry;
+      else
+        policy.newest = entry;
+    }
+    policy.entries.set(old.key, entry);
+    return entry;
+  }
+  #promote(policy, entry) {
+    if (entry === policy.newest)
+      return;
+    if (entry.inLru)
+      this.#unlink(policy, entry, true);
+    else {
+      entry.inLru = true;
+      policy.lruSize++;
+    }
+    entry.older = policy.newest;
+    entry.newer = undefined;
+    if (policy.newest)
+      policy.newest.newer = entry;
+    else
+      policy.oldest = entry;
+    policy.newest = entry;
+  }
+  #unlink(policy, entry, keepCount = false) {
+    if (entry.older)
+      entry.older.newer = entry.newer;
+    else
+      policy.oldest = entry.newer;
+    if (entry.newer)
+      entry.newer.older = entry.older;
+    else
+      policy.newest = entry.older;
+    entry.older = entry.newer = undefined;
+    if (!keepCount) {
+      entry.inLru = false;
+      policy.lruSize--;
+    }
+  }
+  #derived() {
+    const Species = this.constructor[Symbol.species] ?? Collection;
+    return new Species;
+  }
   #notify(key, value, reason) {
-    if (!this.#onEvict)
+    const onEvict = this.#policy?.onEvict;
+    if (!onEvict)
       return;
     try {
-      this.#onEvict(key, value, reason);
+      onEvict(key, value, reason);
     } catch {}
   }
   #enforceCap() {
-    if (this.#maxSize === undefined)
+    const policy = this.#policy;
+    const max = policy.maxSize;
+    if (max === undefined)
       return;
-    while (this.#lru.size > this.#maxSize) {
-      const oldest = this.#lru.oldest();
-      const value = super.get(oldest);
-      this.#remove(oldest);
-      this.#stats.evicted++;
-      this.#notify(oldest, value, "evicted");
+    if (policy.lruSize > max && policy.heap.length > 0 && policy.heap[0].filed <= Date.now())
+      this.purge();
+    while (policy.lruSize > max) {
+      const oldest = policy.oldest;
+      const value = policy.onEvict ? super.get(oldest.key) : undefined;
+      this.#unlink(policy, oldest);
+      policy.entries.delete(oldest.key);
+      super.delete(oldest.key);
+      policy.evicted++;
+      this.#notify(oldest.key, value, "evicted");
     }
   }
-  #schedule(key, window) {
-    const deadline = Date.now() + window;
-    const expiry = this.#expiry.get(key);
-    if (expiry) {
-      expiry.deadline = deadline;
-      expiry.window = window;
-      if (deadline >= expiry.filed)
-        return;
-      expiry.filed = deadline;
-    } else
-      this.#expiry.set(key, { deadline, window, filed: deadline });
-    this.#heapPush({ key, deadline });
-    if (this.#heap.length > 2 * this.#expiry.size + 8)
-      this.#compact();
-    this.#rearm();
-  }
   #nextDeadline() {
+    const policy = this.#policy;
     for (;; ) {
-      const top = this.#heap[0];
+      const top = policy.heap[0];
       if (top === undefined)
         return Infinity;
-      const expiry = this.#expiry.get(top.key);
-      if (!expiry || expiry.filed !== top.deadline) {
+      if (policy.entries.get(top.key) !== top) {
         this.#heapPop();
         continue;
       }
-      if (expiry.deadline === top.deadline)
-        return top.deadline;
+      if (top.deadline === top.filed)
+        return top.filed;
       this.#heapPop();
-      expiry.filed = expiry.deadline;
-      this.#heapPush({ key: top.key, deadline: expiry.deadline });
+      top.filed = top.deadline;
+      this.#heapPush(top);
     }
   }
   #compact() {
-    const live = this.#heap.filter((record) => this.#expiry.get(record.key)?.filed === record.deadline);
-    this.#heap.length = 0;
-    for (const record of live)
-      this.#heapPush(record);
+    const policy = this.#policy;
+    const live = policy.heap.filter((entry) => policy.entries.get(entry.key) === entry);
+    policy.heap.length = 0;
+    for (const entry of live)
+      this.#heapPush(entry);
   }
   #rearm() {
+    const p = this.#policy;
     const deadline = this.#nextDeadline();
-    if (this.#timer !== undefined && deadline >= this.#armedFor)
+    if (p.timer !== undefined && deadline >= p.armedFor)
       return;
-    if (this.#timer)
-      clearTimeout(this.#timer);
-    this.#timer = undefined;
-    this.#armedFor = deadline;
+    if (p.timer)
+      clearTimeout(p.timer);
+    p.timer = undefined;
+    p.armedFor = deadline;
     if (deadline === Infinity)
       return;
-    this.#timer = setTimeout(() => {
-      this.#timer = undefined;
-      this.#armedFor = Infinity;
+    p.timer = setTimeout(() => {
+      p.timer = undefined;
+      p.armedFor = Infinity;
       this.purge();
     }, Math.max(0, deadline - Date.now()));
-    this.#timer.unref?.();
+    p.timer.unref?.();
   }
-  #heapPush(record) {
-    const heap = this.#heap;
-    heap.push(record);
-    let i = heap.length - 1;
+  #heapPush(entry) {
+    const heap = this.#policy.heap;
+    let i = heap.length;
+    heap.push(entry);
     while (i > 0) {
       const parent = i - 1 >> 1;
-      if (heap[parent].deadline <= heap[i].deadline)
+      const above = heap[parent];
+      if (above.filed <= entry.filed)
         break;
-      [heap[parent], heap[i]] = [heap[i], heap[parent]];
+      heap[i] = above;
       i = parent;
     }
+    heap[i] = entry;
   }
   #heapPop() {
-    const heap = this.#heap;
+    const heap = this.#policy.heap;
     const top = heap[0];
     const last = heap.pop();
     if (top === undefined || heap.length === 0)
       return top;
-    heap[0] = last;
-    for (let i = 0;; ) {
-      const left = 2 * i + 1;
-      const right = left + 1;
-      let smallest = i;
-      if (left < heap.length && heap[left].deadline < heap[smallest].deadline)
-        smallest = left;
-      if (right < heap.length && heap[right].deadline < heap[smallest].deadline)
-        smallest = right;
-      if (smallest === i)
+    let i = 0;
+    for (;; ) {
+      let child = 2 * i + 1;
+      if (child >= heap.length)
+        break;
+      if (child + 1 < heap.length && heap[child + 1].filed < heap[child].filed)
+        child++;
+      if (heap[child].filed >= last.filed)
         break;
-      [heap[smallest], heap[i]] = [heap[i], heap[smallest]];
-      i = smallest;
+      heap[i] = heap[child];
+      i = child;
     }
+    heap[i] = last;
     return top;
   }
   first() {
@@ -1176,19 +2604,35 @@ class Collection extends Map {
     }
     return;
   }
+  findLast(predicate) {
+    const keys = this.keyArray();
+    const values = this.array();
+    for (let i = values.length - 1;i >= 0; i--)
+      if (predicate(values[i], keys[i], this))
+        return values[i];
+    return;
+  }
+  findLastKey(predicate) {
+    const keys = this.keyArray();
+    const values = this.array();
+    for (let i = values.length - 1;i >= 0; i--)
+      if (predicate(values[i], keys[i], this))
+        return keys[i];
+    return;
+  }
   filter(predicate) {
-    const result = new Collection;
-    for (const [key, value] of this) {
+    const result = this.#derived();
+    this.forEach((value, key) => {
       if (predicate(value, key, this))
         result.set(key, value);
-    }
+    });
     return result;
   }
   map(transform) {
     const result = [];
-    for (const [key, value] of this) {
+    this.forEach((value, key) => {
       result.push(transform(value, key, this));
-    }
+    });
     return result;
   }
   some(predicate) {
@@ -1206,9 +2650,9 @@ class Collection extends Map {
     return true;
   }
   each(callback) {
-    for (const [key, value] of this) {
+    this.forEach((value, key) => {
       callback(value, key, this);
-    }
+    });
     return this;
   }
   array() {
@@ -1221,9 +2665,10 @@ class Collection extends Map {
     return [...this.entries()];
   }
   clone() {
-    const copy = new Collection;
-    for (const [key, value] of this)
+    const copy = this.#derived();
+    this.forEach((value, key) => {
       copy.set(key, value);
+    });
     return copy;
   }
   hasAll(...keys) {
@@ -1276,7 +2721,7 @@ class Collection extends Map {
     return result;
   }
   intersection(other) {
-    const result = new Collection;
+    const result = this.#derived();
     for (const [key, value] of this) {
       if (other.has(key))
         result.set(key, value);
@@ -1284,7 +2729,7 @@ class Collection extends Map {
     return result;
   }
   difference(other) {
-    const result = new Collection;
+    const result = this.#derived();
     for (const [key, value] of this) {
       if (!other.has(key))
         result.set(key, value);
@@ -1292,8 +2737,8 @@ class Collection extends Map {
     return result;
   }
   partition(predicate) {
-    const pass = new Collection;
-    const fail = new Collection;
+    const pass = this.#derived();
+    const fail = this.#derived();
     for (const [key, value] of this) {
       if (predicate(value, key, this))
         pass.set(key, value);
@@ -1302,6 +2747,81 @@ class Collection extends Map {
     }
     return [pass, fail];
   }
+  symmetricDifference(other) {
+    const result = this.#derived();
+    for (const [key, value] of this)
+      if (!other.has(key))
+        result.set(key, value);
+    for (const [key, value] of other)
+      if (!this.has(key))
+        result.set(key, value);
+    return result;
+  }
+  concat(...collections) {
+    const result = this.clone();
+    for (const collection of collections)
+      for (const [key, value] of collection)
+        result.set(key, value);
+    return result;
+  }
+  merge(other, whenInSelf, whenInOther, whenInBoth) {
+    const result = this.#derived();
+    const decide = (key, kept) => {
+      if (kept.keep)
+        result.set(key, kept.value);
+    };
+    for (const [key, value] of this) {
+      decide(key, other.has(key) ? whenInBoth(value, peekOf(other, key), key) : whenInSelf(value, key));
+    }
+    for (const [key, value] of other)
+      if (!this.has(key))
+        decide(key, whenInOther(value, key));
+    return result;
+  }
+  equals(other) {
+    if (!other)
+      return false;
+    if (other === this)
+      return true;
+    if (this.size !== other.size)
+      return false;
+    for (const [key, value] of this) {
+      if (!other.has(key))
+        return false;
+      if (value !== peekOf(other, key))
+        return false;
+    }
+    return true;
+  }
+  mapValues(transform) {
+    const result = this.#derived();
+    for (const [key, value] of this)
+      result.set(key, transform(value, key, this));
+    return result;
+  }
+  toReversed() {
+    const result = this.#derived();
+    const entries = [...this];
+    for (let i = entries.length - 1;i >= 0; i--)
+      result.set(entries[i][0], entries[i][1]);
+    return result;
+  }
+  toSorted(comparator) {
+    return this.sorted(comparator);
+  }
+  static groupBy(items, keySelector) {
+    const groups = new Collection;
+    let index = 0;
+    for (const item of items)
+      groups.ensure(keySelector(item, index++), () => []).push(item);
+    return groups;
+  }
+  static combineEntries(entries, combine) {
+    const result = new Collection;
+    for (const [key, value] of entries)
+      result.set(key, result.has(key) ? combine(result.get(key), value, key) : value);
+    return result;
+  }
   tap(fn) {
     fn(this);
     return this;
@@ -1320,6 +2840,13 @@ class Collection extends Map {
       acc = fn(acc, value, key, this);
     return acc;
   }
+  reduceRight(fn, initialValue) {
+    const entries = [...this];
+    let acc = initialValue;
+    for (let i = entries.length - 1;i >= 0; i--)
+      acc = fn(acc, entries[i][1], entries[i][0], this);
+    return acc;
+  }
   sorted(comparator) {
     const decorated = [...this.entries()].map((entry, index) => ({
       entry,
@@ -1330,32 +2857,52 @@ class Collection extends Map {
         const comparison = comparator(x.entry[1], y.entry[1], x.entry[0], y.entry[0]);
         return comparison !== 0 ? comparison : x.index - y.index;
       });
-    const result = new Collection;
+    const result = this.#derived();
     for (const { entry } of decorated)
       result.set(entry[0], entry[1]);
     return result;
   }
-  random() {
-    const arr = [...this.values()];
-    if (!arr.length)
+  random(amount) {
+    if (amount !== undefined)
+      return sample([...this.values()], amount);
+    const size = this.size;
+    if (size === 0)
       return;
-    return arr[Math.floor(Math.random() * arr.length)];
+    let index = Math.floor(Math.random() * size);
+    for (const value of this.values())
+      if (index-- === 0)
+        return value;
+    return;
   }
-  randomKey() {
-    const arr = [...this.keys()];
-    if (!arr.length)
+  randomKey(amount) {
+    if (amount !== undefined)
+      return sample([...this.keys()], amount);
+    const size = this.size;
+    if (size === 0)
       return;
-    return arr[Math.floor(Math.random() * arr.length)];
+    let index = Math.floor(Math.random() * size);
+    for (const key of this.keys())
+      if (index-- === 0)
+        return key;
+    return;
   }
   at(index) {
-    const arr = [...this.values()];
-    const i = index < 0 ? arr.length + index : index;
-    return arr[i];
+    let remaining = index < 0 ? this.size + index : index;
+    if (remaining < 0)
+      return;
+    for (const value of this.values())
+      if (remaining-- === 0)
+        return value;
+    return;
   }
   keyAt(index) {
-    const arr = [...this.keys()];
-    const i = index < 0 ? arr.length + index : index;
-    return arr[i];
+    let remaining = index < 0 ? this.size + index : index;
+    if (remaining < 0)
+      return;
+    for (const key of this.keys())
+      if (remaining-- === 0)
+        return key;
+    return;
   }
   toJSON() {
     return [...this.entries()];
@@ -1469,7 +3016,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.2.3",
+  version: "0.3.0",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -1550,7 +3097,7 @@ function kindFromStatus(status) {
   return "client";
 }
 function redactPath(path) {
-  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/, "$1:token");
+  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/i, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/i, "$1:token");
 }
 var HINTS = {
   50001: "The bot cannot see this resource: check that it is in the guild and has View Channel there.",
@@ -1609,19 +3156,23 @@ async function abortable(promise, signal, path) {
 }
 
 // packages/rest/src/route.ts
+import { createHash } from "crypto";
 function normalizeRoutePath(path) {
   const queryIndex = path.indexOf("?");
   const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
-  return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
+  return redactPath(routePath).replace(/\/\d+(?=\/|$)/g, "/:id");
 }
 function majorParameter(path) {
-  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/i.exec(path);
   if (!match)
     return "@none";
-  if (match[1] === "webhooks" && match[3] !== undefined)
-    return `${match[2]}:${match[3]}`;
+  if (match[1].toLowerCase() === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${tokenDigest(match[3])}`;
   return match[2];
 }
+function tokenDigest(token) {
+  return createHash("sha256").update(token).digest("hex").slice(0, 16);
+}
 function scopeBucket(hashOrRoute, major) {
   return `${hashOrRoute}|${major}`;
 }
@@ -1863,6 +3414,9 @@ var Routes = {
   user: () => "/users/@me",
   userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
   guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  currentUserGuild: (guildId) => `/users/@me/guilds/${snowflake(guildId, "Guild ID")}`,
+  sticker: (stickerId) => `/stickers/${snowflake(stickerId, "Sticker ID")}`,
+  messageReactionUser: (channelId, messageId, emoji, userId) => `${Routes.messageReactions(channelId, messageId, emoji)}/${snowflake(userId, "User ID")}`,
   guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
   guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
   guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
@@ -1879,11 +3433,10 @@ var Routes = {
   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)}`,
+  messageReactionMe: (channelId, messageId, emoji) => `${Routes.messageReactions(channelId, messageId, emoji)}/@me`,
   messageReactionsAll: (channelId, messageId) => `${Routes.message(channelId, messageId)}/reactions`,
   channelMessagesPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/pins`,
   channelMessagesPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/pins/${snowflake(messageId, "Message ID")}`,
-  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`,
@@ -1898,6 +3451,10 @@ var Routes = {
   interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
   channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
   channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
+  channelJoinedPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/users/@me/threads/archived/private`,
+  threadMember: (threadId, userId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members/${userOrMe(userId)}`,
+  channelTyping: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/typing`,
+  channelThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads`,
   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")}`,
@@ -1910,6 +3467,13 @@ var Routes = {
   gatewayBot: () => "/gateway/bot",
   guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
   guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
+  guildMembersSearch: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/search`,
+  guildMemberMe: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/@me`,
+  guildBulkBan: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/bulk-ban`,
+  guildVoiceState: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/voice-states/${userOrMe(userId)}`,
+  guildIntegration: (guildId, integrationId) => `/guilds/${snowflake(guildId, "Guild ID")}/integrations/${snowflake(integrationId, "Integration ID")}`,
+  userGuilds: () => "/users/@me/guilds",
+  stickerPacks: (packId) => packId ? `/sticker-packs/${snowflake(packId, "Sticker pack ID")}` : "/sticker-packs",
   guildWelcomeScreen: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/welcome-screen`,
   guildOnboarding: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/onboarding`,
   guildPrune: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/prune`,
@@ -1930,6 +3494,9 @@ var Routes = {
   consumeEntitlement: (applicationId, entitlementId) => `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}/consume`,
   skuSubscription: (skuId, subscriptionId) => subscriptionId ? `/skus/${snowflake(skuId, "SKU ID")}/subscriptions/${snowflake(subscriptionId, "Subscription ID")}` : `/skus/${snowflake(skuId, "SKU ID")}/subscriptions`
 };
+function userOrMe(value) {
+  return value === "@me" ? value : snowflake(value, "User ID");
+}
 function integer(value, field) {
   if (!Number.isInteger(value) || value < 0)
     throw new TypeError(`${field} must be a non-negative integer.`);
@@ -1945,6 +3512,22 @@ function snowflake(value, field) {
 var LIBRARY_VERSION = package_default.version;
 var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
 var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${LIBRARY_VERSION})`;
+function assertSafePath(path) {
+  const end = path.search(/[?#]/);
+  const pathname = end === -1 ? path : path.slice(0, end);
+  if (pathname.includes("\\"))
+    throw new TypeError("REST paths must not contain backslashes.");
+  for (const segment of pathname.split("/")) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new TypeError("REST path has malformed percent-encoding.");
+    }
+    if (decoded === "." || decoded === "..")
+      throw new TypeError("REST paths must not contain '.' or '..' segments.");
+  }
+}
 var REQUEST_DATA_KEYS = new Set([
   "body",
   "files",
@@ -2005,7 +3588,7 @@ class REST {
       timeout: options.timeout
     });
     const store = options.store ?? new MemoryRateLimitStore;
-    this.#concurrentBuckets = (options.concurrentBuckets ?? false) && typeof store.reserve === "function";
+    this.#concurrentBuckets = (options.concurrentBuckets ?? true) && typeof store.reserve === "function";
     this.#limiter = new RateLimiter(store, {
       concurrent: this.#concurrentBuckets
     });
@@ -2029,6 +3612,7 @@ class REST {
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    assertSafePath(path);
     const route = createRouteKey(method, path);
     const files = options.files;
     if (files && files.length > 0 && !(body instanceof FormData))
@@ -2116,13 +3700,19 @@ class REST {
   #headers(body, options) {
     const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
     const headers = { ...options.headers };
+    const set = (name, value) => {
+      for (const key of Object.keys(headers))
+        if (key.toLowerCase() === name.toLowerCase())
+          delete headers[key];
+      headers[name] = value;
+    };
     if (options.auth !== false && this.#token)
-      headers["Authorization"] = `Bot ${this.#token}`;
-    headers["User-Agent"] = USER_AGENT;
+      set("Authorization", `Bot ${this.#token}`);
+    set("User-Agent", USER_AGENT);
     if (options.reason !== undefined)
-      headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+      set("X-Audit-Log-Reason", encodeURIComponent(options.reason));
     if (!isFormData)
-      headers["Content-Type"] = "application/json";
+      set("Content-Type", "application/json");
     return headers;
   }
   #encodeBody(body) {
@@ -2189,8 +3779,11 @@ class BaseStructure {
   toString() {
     return this.id;
   }
+  get createdTimestamp() {
+    return Number((BigInt(this.id) >> 22n) + 1420070400000n);
+  }
   get createdAt() {
-    return new Date(Number((BigInt(this.id) >> 22n) + 1420070400000n));
+    return new Date(this.createdTimestamp);
   }
 }
 var CDN_BASE = "https://cdn.discordapp.com";
@@ -2198,7 +3791,7 @@ function cdnURL(path, hash, options = {}) {
   const isAnimated = hash.startsWith("a_") && !options.forceStatic;
   const ext = options.extension ?? (isAnimated ? "gif" : "png");
   const size = options.size ? `?size=${options.size}` : "";
-  return `${CDN_BASE}${path}/${hash}.${ext}${size}`;
+  return `${CDN_BASE}${path}/${encodeURIComponent(hash)}.${ext}${size}`;
 }
 
 class User extends BaseStructure {
@@ -2272,9 +3865,6 @@ class Channel extends BaseStructure {
       throw new Error("This channel is not attached to a client.");
     return this.#context.sendMessage(this.id, options);
   }
-  sendMessage(options) {
-    return this.send(options);
-  }
   edit(options) {
     if (!this.#context?.editChannel)
       throw new Error("This channel is not attached to a client.");
@@ -2304,6 +3894,17 @@ class Channel extends BaseStructure {
   update(options) {
     return this.edit(options);
   }
+  get kind() {
+    return channelKindOf(this.type);
+  }
+  is(...kinds) {
+    return kinds.includes(this.kind);
+  }
+  as(...kinds) {
+    if (!this.is(...kinds))
+      throw new TypeError(`Channel ${this.id} is a ${this.kind} channel, not ${kinds.join(" or ")}.`);
+    return this;
+  }
   isThread() {
     return this.type === 10 || this.type === 11 || this.type === 12;
   }
@@ -2355,6 +3956,7 @@ class Guild extends BaseStructure {
   safetyAlertsChannelId;
   maxPresences;
   maxVideoChannelUsers;
+  premiumProgressBarEnabled;
   constructor(data) {
     super(data.id);
     if (!data.name)
@@ -2392,6 +3994,7 @@ class Guild extends BaseStructure {
     this.safetyAlertsChannelId = data.safety_alerts_channel_id ?? null;
     this.maxPresences = data.max_presences ?? null;
     this.maxVideoChannelUsers = data.max_video_channel_users;
+    this.premiumProgressBarEnabled = data.premium_progress_bar_enabled ?? false;
   }
   iconURL(options = {}) {
     if (!this.icon)
@@ -2488,10 +4091,10 @@ class GuildMember {
   get permissions() {
     if (this.#suppliedPermissions)
       return this.#suppliedPermissions;
-    return new PermissionsBitField(this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds) ?? 0n);
+    return new PermissionsBitField(this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds, undefined, this.timedOutUntil) ?? 0n);
   }
   permissionsIn(channelId) {
-    const computed = this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds, channelId);
+    const computed = this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds, channelId, this.timedOutUntil);
     return computed ? new PermissionsBitField(computed) : null;
   }
   #action(name) {
@@ -2554,6 +4157,7 @@ class Role extends BaseStructure {
   position;
   unicodeEmoji;
   iconHash;
+  colors;
   tags;
   constructor(data) {
     super(data.id);
@@ -2567,6 +4171,11 @@ class Role extends BaseStructure {
     this.mentionable = data.mentionable ?? false;
     this.position = data.position ?? 0;
     this.unicodeEmoji = data.unicode_emoji ?? null;
+    this.colors = data.colors ? {
+      primary: data.colors.primary_color,
+      secondary: data.colors.secondary_color,
+      tertiary: data.colors.tertiary_color
+    } : null;
     this.iconHash = data.icon ?? null;
     this.tags = data.tags ?? null;
   }
@@ -3030,6 +4639,14 @@ class Interaction {
     this.type = data.type;
     this.data = data;
   }
+  get entitlements() {
+    const entitlements = this.data.entitlements;
+    return Array.isArray(entitlements) ? entitlements : [];
+  }
+  hasEntitlement(skuId) {
+    const now = Date.now();
+    return this.entitlements.some((entitlement) => entitlement.sku_id === skuId && !entitlement.deleted && (!entitlement.ends_at || Date.parse(entitlement.ends_at) > now));
+  }
   #commandType() {
     if (this.type !== InteractionEnum.ApplicationCommand)
       return 0;
@@ -3324,22 +4941,133 @@ function findFocused(options) {
         return found;
     }
   }
-  return;
-}
-function createInteraction(client, data) {
-  switch (data.type) {
-    case InteractionEnum.ApplicationCommand: {
-      const commandType = data.data?.type;
-      return commandType === COMMAND_USER || commandType === COMMAND_MESSAGE ? new ContextMenuCommandInteraction(client, data) : new CommandInteraction(client, data);
-    }
-    case InteractionEnum.ApplicationCommandAutocomplete:
-      return new AutocompleteInteraction(client, data);
-    case InteractionEnum.MessageComponent:
-      return new ComponentInteraction(client, data);
-    case InteractionEnum.ModalSubmit:
-      return new ModalSubmitInteraction(client, data);
-    default:
-      return new Interaction(client, data);
+  return;
+}
+function createInteraction(client, data) {
+  switch (data.type) {
+    case InteractionEnum.ApplicationCommand: {
+      const commandType = data.data?.type;
+      return commandType === COMMAND_USER || commandType === COMMAND_MESSAGE ? new ContextMenuCommandInteraction(client, data) : new CommandInteraction(client, data);
+    }
+    case InteractionEnum.ApplicationCommandAutocomplete:
+      return new AutocompleteInteraction(client, data);
+    case InteractionEnum.MessageComponent:
+      return new ComponentInteraction(client, data);
+    case InteractionEnum.ModalSubmit:
+      return new ModalSubmitInteraction(client, data);
+    default:
+      return new Interaction(client, data);
+  }
+}
+// packages/structures/src/audit-log.ts
+function int(value) {
+  return Number(value ?? 0);
+}
+function parseInfo(type, options) {
+  if (!options)
+    return;
+  switch (type) {
+    case 13:
+    case 14:
+    case 15:
+      return {
+        id: options.id ?? "",
+        type: int(options.type),
+        roleName: options.role_name
+      };
+    case 21:
+      return {
+        deleteMemberDays: int(options.delete_member_days),
+        membersRemoved: int(options.members_removed)
+      };
+    case 26:
+    case 72:
+      return {
+        channelId: options.channel_id ?? "",
+        count: int(options.count)
+      };
+    case 27:
+    case 73:
+      return { count: int(options.count) };
+    case 74:
+    case 75:
+      return {
+        channelId: options.channel_id ?? "",
+        messageId: options.message_id ?? ""
+      };
+    case 83:
+    case 84:
+    case 85:
+      return { channelId: options.channel_id ?? "" };
+    case 121:
+      return { applicationId: options.app_id ?? "" };
+    case 143:
+    case 144:
+    case 145:
+      return {
+        ruleName: options.auto_moderation_rule_name ?? "",
+        ruleTriggerType: int(options.auto_moderation_rule_trigger_type),
+        channelId: options.channel_id
+      };
+    default:
+      return;
+  }
+}
+
+class AuditLogEntry extends BaseStructure {
+  targetId;
+  userId;
+  actionType;
+  changes;
+  options;
+  info;
+  reason;
+  constructor(data) {
+    super(data.id);
+    this.targetId = data.target_id;
+    this.userId = data.user_id;
+    this.actionType = data.action_type;
+    this.info = parseInfo(data.action_type, data.options);
+    this.changes = data.changes ?? [];
+    this.options = data.options ?? null;
+    this.reason = data.reason ?? null;
+  }
+  is(type) {
+    return this.actionType === type;
+  }
+  change(key) {
+    const found = this.changes.find((change) => change.key === key);
+    return found && { old: found.old_value, new: found.new_value };
+  }
+}
+
+class AuditLog {
+  entries;
+  constructor(data) {
+    this.entries = new Map;
+    for (const entryData of data.audit_log_entries) {
+      this.entries.set(entryData.id, new AuditLogEntry(entryData));
+    }
+  }
+  filter(query) {
+    const types = query.type === undefined ? undefined : Array.isArray(query.type) ? query.type : [query.type];
+    const since = query.since === undefined ? undefined : new Date(query.since).getTime();
+    const matches = [];
+    for (const entry of this.entries.values()) {
+      if (types && !types.includes(entry.actionType))
+        continue;
+      if (query.targetId !== undefined && entry.targetId !== query.targetId)
+        continue;
+      if (query.userId !== undefined && entry.userId !== query.userId)
+        continue;
+      if (since !== undefined && entry.createdAt.getTime() < since)
+        continue;
+      matches.push(entry);
+    }
+    return matches;
+  }
+  find(query) {
+    return this.filter(query)[0];
   }
 }
 
@@ -3530,6 +5258,13 @@ class Message extends BaseStructure {
 }
 
 // packages/managers/src/message.ts
+function toAttachments(files) {
+  return files.map((file) => ({
+    name: file.name,
+    data: typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data,
+    contentType: file.contentType
+  }));
+}
 function toRequest(options, allowedMentions) {
   const { files, ...body } = options;
   if (allowedMentions !== undefined && body.allowed_mentions === undefined)
@@ -3538,11 +5273,7 @@ function toRequest(options, allowedMentions) {
     return body;
   return {
     body,
-    files: files.map((file) => ({
-      name: file.name,
-      data: typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data,
-      contentType: file.contentType
-    }))
+    files: toAttachments(files)
   };
 }
 
@@ -3616,6 +5347,70 @@ class ThreadManager {
     });
     return createChannel(data, this.#context);
   }
+  async create(options) {
+    const data = await this.#rest.post(Routes.channelThreads(this.#channelId), {
+      name: options.name,
+      type: options.type ?? 12,
+      auto_archive_duration: options.autoArchiveDuration,
+      rate_limit_per_user: options.rateLimitPerUser,
+      invitable: options.invitable
+    }, { reason: options.reason });
+    return createChannel(data, this.#context);
+  }
+  async createForumPost(options) {
+    const { message, appliedTags, reason, ...thread } = options;
+    const { files, ...content } = message;
+    const data = await this.#rest.post(Routes.channelThreads(this.#channelId), {
+      name: thread.name,
+      auto_archive_duration: thread.autoArchiveDuration,
+      rate_limit_per_user: thread.rateLimitPerUser,
+      applied_tags: appliedTags,
+      message: content
+    }, { files: files?.length ? toAttachments(files) : undefined, reason });
+    return createChannel(data, this.#context);
+  }
+  async fetchArchived(scope, options = {}) {
+    const route = scope === "public" ? Routes.channelPublicArchivedThreads(this.#channelId) : scope === "private" ? Routes.channelPrivateArchivedThreads(this.#channelId) : Routes.channelJoinedPrivateArchivedThreads(this.#channelId);
+    const params = new URLSearchParams;
+    if (options.before)
+      params.set("before", options.before);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    const query = params.toString();
+    const page = await this.#rest.get(`${route}${query ? `?${query}` : ""}`);
+    return {
+      threads: page.threads.map((thread) => createChannel(thread, this.#context)),
+      members: page.members,
+      hasMore: page.has_more
+    };
+  }
+  async join(threadId) {
+    await this.#rest.put(Routes.threadMember(threadId, "@me"));
+  }
+  async leave(threadId) {
+    await this.#rest.delete(Routes.threadMember(threadId, "@me"));
+  }
+  async addMember(threadId, userId) {
+    await this.#rest.put(Routes.threadMember(threadId, userId));
+  }
+  async removeMember(threadId, userId) {
+    await this.#rest.delete(Routes.threadMember(threadId, userId));
+  }
+  async fetchMember(threadId, userId, query = {}) {
+    const suffix = query.withMember ? "?with_member=true" : "";
+    return this.#rest.get(`${Routes.threadMember(threadId, userId)}${suffix}`);
+  }
+  async fetchMembers(threadId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.withMember)
+      params.set("with_member", "true");
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    const query = params.toString();
+    return this.#rest.get(`${Routes.threadMembers(threadId)}${query ? `?${query}` : ""}`);
+  }
 }
 
 // packages/managers/src/user.ts
@@ -3633,8 +5428,21 @@ class UserManager extends ResourceManager {
     const data = await this.#rest.patch("/users/@me", options);
     return this.upsert(new User(data));
   }
+  async fetchGuilds(options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(200, Math.max(1, options.limit))));
+    if (options.before)
+      params.set("before", options.before);
+    if (options.after)
+      params.set("after", options.after);
+    if (options.withCounts)
+      params.set("with_counts", "true");
+    const query = params.toString();
+    return this.#rest.get(`${Routes.userGuilds()}${query ? `?${query}` : ""}`);
+  }
   async leaveGuild(guildId) {
-    await this.#rest.delete(`/users/@me/guilds/${guildId}`);
+    await this.#rest.delete(Routes.currentUserGuild(guildId));
   }
   async createDM(userId) {
     return this.#rest.post("/users/@me/channels", {
@@ -3672,9 +5480,6 @@ class EmojiManager extends Manager {
     });
     this.delete(emojiId);
   }
-  deleteEmoji(emojiId) {
-    return this.remove(emojiId);
-  }
   upsert(data) {
     const key = data.id != null ? data.id : `unicode:${data.name ?? ""}`;
     return this.#merge(key, new Emoji(data));
@@ -3855,6 +5660,39 @@ class MonetizationManager extends Manager {
   }
 }
 
+class ApplicationEmojiManager extends Manager {
+  #rest;
+  applicationId;
+  constructor(rest, applicationId) {
+    super();
+    this.#rest = rest;
+    this.applicationId = applicationId;
+  }
+  #store(emoji) {
+    if (emoji.id)
+      this.set(emoji.id, emoji);
+    return emoji;
+  }
+  async fetchAll() {
+    const { items } = await this.#rest.get(Routes.applicationEmoji(this.applicationId));
+    this.clear();
+    return items.map((emoji) => this.#store(emoji));
+  }
+  async fetch(emojiId) {
+    return this.#store(await this.#rest.get(Routes.applicationEmoji(this.applicationId, emojiId)));
+  }
+  async create(options) {
+    return this.#store(await this.#rest.post(Routes.applicationEmoji(this.applicationId), options));
+  }
+  async edit(emojiId, options) {
+    return this.#store(await this.#rest.patch(Routes.applicationEmoji(this.applicationId, emojiId), options));
+  }
+  async remove(emojiId) {
+    await this.#rest.delete(Routes.applicationEmoji(this.applicationId, emojiId));
+    this.delete(emojiId);
+  }
+}
+
 // packages/managers/src/member.ts
 class GuildMemberManager extends ResourceManager {
   #rest;
@@ -3868,6 +5706,27 @@ class GuildMemberManager extends ResourceManager {
     this.#rest = rest;
     this.#context = context;
   }
+  async search(query, limit = 1) {
+    if (!query.trim())
+      throw new TypeError("A search query is required.");
+    const params = new URLSearchParams({
+      query,
+      limit: String(Math.min(1000, Math.max(1, limit)))
+    });
+    const found = await this.#rest.get(`${Routes.guildMembersSearch(this.guildId)}?${params}`);
+    return found.map((data) => {
+      const member = new GuildMember({ ...data, guild_id: this.guildId }, this.#context());
+      this.set(member.user.id, member);
+      return member;
+    });
+  }
+  async editMe(options) {
+    const [payload, reason] = splitReason(options);
+    const data = await this.#rest.patch(Routes.guildMemberMe(this.guildId), payload, { reason });
+    const member = new GuildMember({ ...data, guild_id: this.guildId }, this.#context());
+    this.set(member.user.id, member);
+    return member;
+  }
   async kick(userId, reason) {
     await this.#rest.delete(Routes.guildMember(this.guildId, userId), {
       reason
@@ -3883,10 +5742,10 @@ class GuildMemberManager extends ResourceManager {
       reason
     });
   }
-  async edit(userId, options, reason) {
+  async edit(userId, options) {
     const [payload, optionsReason] = splitReason(options);
     const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), payload, {
-      reason: optionsReason ?? reason
+      reason: optionsReason
     });
     const member = new GuildMember({ ...data, guild_id: this.guildId }, this.#context());
     this.set(member.user.id, member);
@@ -3900,7 +5759,10 @@ class GuildMemberManager extends ResourceManager {
   }
   async timeout(userId, milliseconds, reason) {
     const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
-    return this.edit(userId, { communication_disabled_until: timeoutDate }, reason);
+    return this.edit(userId, {
+      communication_disabled_until: timeoutDate,
+      reason
+    });
   }
 }
 
@@ -3923,20 +5785,15 @@ class RoleManager extends ResourceManager {
   }
   async create(options) {
     const { reason, ...payload } = options;
-    const data = await this.#rest.post(Routes.guildRoles(this.guildId), {
-      ...payload,
-      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
-    }, { reason });
-    const role = new Role(data);
-    this.set(role.id, role);
-    return role;
+    const data = await this.#rest.post(Routes.guildRoles(this.guildId), rolePayload(payload), { reason });
+    return this.#store(data);
   }
   async edit(roleId, options) {
     const { reason, ...payload } = options;
-    const data = await this.#rest.patch(Routes.guildRole(this.guildId, roleId), {
-      ...payload,
-      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
-    }, { reason });
+    const data = await this.#rest.patch(Routes.guildRole(this.guildId, roleId), rolePayload(payload), { reason });
+    return this.#store(data);
+  }
+  #store(data) {
     const role = new Role(data);
     this.set(role.id, role);
     return role;
@@ -3955,9 +5812,19 @@ class RoleManager extends ResourceManager {
       return role;
     });
   }
-  deleteRole(roleId) {
-    return this.remove(roleId);
-  }
+}
+function rolePayload(options) {
+  const { permissions, colors, unicodeEmoji, ...rest } = options;
+  return {
+    ...rest,
+    permissions: permissions !== undefined ? String(permissions) : undefined,
+    colors: colors && {
+      primary_color: colors.primary,
+      secondary_color: colors.secondary ?? null,
+      tertiary_color: colors.tertiary ?? null
+    },
+    unicode_emoji: unicodeEmoji
+  };
 }
 
 // packages/managers/src/guild-resources.ts
@@ -3997,6 +5864,18 @@ class GuildBanManager extends Manager {
   async create(userId, options = {}) {
     await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
   }
+  async bulk(userIds, options = {}) {
+    if (userIds.length < 1 || userIds.length > 200)
+      throw new RangeError("Bulk ban takes 1 to 200 user IDs.");
+    const result = await this.#rest.post(Routes.guildBulkBan(this.guildId), {
+      user_ids: userIds,
+      delete_message_seconds: options.deleteMessageSeconds
+    }, { reason: options.reason });
+    return {
+      banned: result.banned_users ?? [],
+      failed: result.failed_users ?? []
+    };
+  }
   async remove(userId, reason) {
     await this.#rest.delete(Routes.guildBan(this.guildId, userId), {
       reason
@@ -4028,13 +5907,13 @@ class GuildScheduledEventManager extends Manager {
     }));
     return events.map((event) => this.#store(event));
   }
-  async create(options, reason) {
+  async create(options) {
     const [payload, optionsReason] = splitReason(options);
-    return this.#store(await this.#rest.post(Routes.guildScheduledEvents(this.guildId), payload, { reason: optionsReason ?? reason }));
+    return this.#store(await this.#rest.post(Routes.guildScheduledEvents(this.guildId), payload, { reason: optionsReason }));
   }
-  async edit(eventId, options, reason) {
+  async edit(eventId, options) {
     const [payload, optionsReason] = splitReason(options);
-    return this.#store(await this.#rest.patch(Routes.guildScheduledEvent(this.guildId, eventId), payload, { reason: optionsReason ?? reason }));
+    return this.#store(await this.#rest.patch(Routes.guildScheduledEvent(this.guildId, eventId), payload, { reason: optionsReason }));
   }
   async remove(eventId, reason) {
     await this.#rest.delete(Routes.guildScheduledEvent(this.guildId, eventId), { reason });
@@ -4061,20 +5940,20 @@ class StageInstanceManager extends Manager {
     this.set(stage.channel_id, stage);
     return stage;
   }
-  async create(channelId, options, reason) {
+  async create(channelId, options) {
     return this.#store(await this.#rest.post(Routes.stageInstances(), {
       channel_id: channelId,
       topic: options.topic,
       privacy_level: options.privacyLevel,
       send_start_notification: options.sendStartNotification,
       guild_scheduled_event_id: options.guildScheduledEventId
-    }, { reason: options.reason ?? reason }));
+    }, { reason: options.reason }));
   }
   async fetch(channelId) {
     return this.#store(await this.#rest.get(Routes.stageInstanceByChannel(channelId)));
   }
-  async edit(channelId, options, reason) {
-    return this.#store(await this.#rest.patch(Routes.stageInstanceByChannel(channelId), { topic: options.topic, privacy_level: options.privacyLevel }, { reason: options.reason ?? reason }));
+  async edit(channelId, options) {
+    return this.#store(await this.#rest.patch(Routes.stageInstanceByChannel(channelId), { topic: options.topic, privacy_level: options.privacyLevel }, { reason: options.reason }));
   }
   async remove(channelId, reason) {
     await this.#rest.delete(Routes.stageInstanceByChannel(channelId), {
@@ -4104,14 +5983,19 @@ class PermissionOverwriteManager {
     const touched = (changes.allow ?? 0n) | (changes.deny ?? 0n) | (changes.inherit ?? 0n);
     const allow = BigInt(existing?.allow ?? 0) & ~touched | (changes.allow ?? 0n);
     const deny = BigInt(existing?.deny ?? 0) & ~touched | (changes.deny ?? 0n);
-    await this.edit(overwriteId, { type, allow, deny }, options.reason);
+    await this.edit(overwriteId, {
+      type,
+      allow,
+      deny,
+      reason: options.reason
+    });
   }
-  async edit(overwriteId, options, reason) {
+  async edit(overwriteId, options) {
     await this.#rest.put(Routes.channelPermission(this.channelId, overwriteId), {
       type: options.type,
       allow: BigInt(options.allow ?? 0).toString(),
       deny: BigInt(options.deny ?? 0).toString()
-    }, { reason: options.reason ?? reason });
+    }, { reason: options.reason });
   }
   async remove(overwriteId, reason) {
     await this.#rest.delete(Routes.channelPermission(this.channelId, overwriteId), { reason });
@@ -4135,6 +6019,7 @@ class GuildManager extends ResourceManager {
   #soundboard = new Map;
   #voiceStates = new Map;
   #autoModerationRules = new Map;
+  #presences = new Map;
   #invites = new Map;
   #context;
   attachContext(context) {
@@ -4195,6 +6080,9 @@ class GuildManager extends ResourceManager {
   voiceStates(guildId) {
     return this.#perGuild(this.#voiceStates, guildId, () => new Manager);
   }
+  presences(guildId) {
+    return this.#perGuild(this.#presences, guildId, () => new Manager);
+  }
   autoModerationRules(guildId) {
     return this.#perGuild(this.#autoModerationRules, guildId, () => new Manager);
   }
@@ -4220,6 +6108,7 @@ class GuildManager extends ResourceManager {
     this.#stickers.delete(id);
     this.#soundboard.delete(id);
     this.#voiceStates.delete(id);
+    this.#presences.delete(id);
     this.#autoModerationRules.delete(id);
     this.#invites.delete(id);
     return super.delete(id);
@@ -4236,12 +6125,35 @@ class GuildManager extends ResourceManager {
   async remove(id) {
     await this.#rest.delete(Routes.guild(id));
   }
-  deleteGuild(id) {
-    return this.remove(id);
-  }
   async fetchPreview(id) {
     return this.#rest.get(Routes.guildPreview(id));
   }
+  async fetchWelcomeScreen(id) {
+    return this.#rest.get(Routes.guildWelcomeScreen(id));
+  }
+  async editWelcomeScreen(id, options) {
+    const { reason, welcomeChannels, ...rest } = options;
+    return this.#rest.patch(Routes.guildWelcomeScreen(id), { ...rest, welcome_channels: welcomeChannels }, { reason });
+  }
+  async fetchOnboarding(id) {
+    return this.#rest.get(Routes.guildOnboarding(id));
+  }
+  async editOnboarding(id, options) {
+    const { reason, defaultChannelIds, ...rest } = options;
+    return this.#rest.put(Routes.guildOnboarding(id), { ...rest, default_channel_ids: defaultChannelIds }, { reason });
+  }
+  async editVoiceState(id, userId, options) {
+    await this.#rest.patch(Routes.guildVoiceState(id, userId), {
+      channel_id: options.channelId,
+      suppress: options.suppress,
+      request_to_speak_timestamp: options.requestToSpeakTimestamp
+    });
+  }
+  async removeIntegration(id, integrationId, reason) {
+    await this.#rest.delete(Routes.guildIntegration(id, integrationId), {
+      reason
+    });
+  }
   async fetchActiveThreads(id) {
     return this.#rest.get(Routes.guildActiveThreads(id));
   }
@@ -4265,6 +6177,9 @@ class GuildManager extends ResourceManager {
       params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
     return this.#rest.get(withQuery3(Routes.guildAuditLog(guildId), params));
   }
+  async fetchAuditLogEntries(guildId, options = {}) {
+    return new AuditLog(await this.fetchAuditLog(guildId, options));
+  }
   async fetchMembers(guildId, options = {}) {
     const params = new URLSearchParams;
     if (options.limit !== undefined)
@@ -4445,9 +6360,6 @@ class ChannelManager extends Manager {
     await this.#rest.delete(Routes.channel(channelId), { reason });
     this.delete(channelId);
   }
-  deleteChannel(channelId) {
-    return this.remove(channelId);
-  }
   delete(channelId) {
     this.#messageManagers.delete(channelId);
     return super.delete(channelId);
@@ -4455,9 +6367,6 @@ class ChannelManager extends Manager {
   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);
   }
@@ -4526,7 +6435,7 @@ class ChannelManager extends Manager {
     }
   }
   async addReaction(channelId, messageId, emoji) {
-    await this.#rest.put(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
+    await this.#rest.put(Routes.messageReactionMe(channelId, messageId, emoji));
   }
   async fetchReactions(channelId, messageId, emoji, options = {}) {
     const params = new URLSearchParams;
@@ -4539,10 +6448,10 @@ class ChannelManager extends Manager {
     return data.map((user) => new User(user));
   }
   async removeOwnReaction(channelId, messageId, emoji) {
-    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
+    await this.#rest.delete(Routes.messageReactionMe(channelId, messageId, emoji));
   }
   async removeReaction(channelId, messageId, emoji, userId) {
-    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/${userId}`);
+    await this.#rest.delete(Routes.messageReactionUser(channelId, messageId, emoji, userId));
   }
   async removeAllReactions(channelId, messageId) {
     await this.#rest.delete(Routes.messageReactionsAll(channelId, messageId));
@@ -4551,6 +6460,46 @@ class ChannelManager extends Manager {
     const data = await this.#rest.get(Routes.channelMessagesPins(channelId));
     return data.items.map((item) => this.messages(channelId).upsert(item.message));
   }
+  async fetchPins(channelId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.before)
+      params.set("before", options.before);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(50, Math.max(1, options.limit))));
+    const query = params.toString();
+    const data = await this.#rest.get(`${Routes.channelMessagesPins(channelId)}${query ? `?${query}` : ""}`);
+    return {
+      messages: data.items.map((item) => this.messages(channelId).upsert(item.message)),
+      hasMore: data.has_more
+    };
+  }
+  async triggerTyping(channelId) {
+    await this.#rest.post(Routes.channelTyping(channelId));
+  }
+  async createForumTag(channelId, tag, reason) {
+    const tags = await this.#forumTags(channelId);
+    return this.#saveForumTags(channelId, [...tags, tag], reason);
+  }
+  async editForumTag(channelId, tagId, changes, reason) {
+    const tags = await this.#forumTags(channelId);
+    if (!tags.some((tag) => tag.id === tagId))
+      throw new Error(`Channel ${channelId} has no tag ${tagId}.`);
+    return this.#saveForumTags(channelId, tags.map((tag) => tag.id === tagId ? { ...tag, ...changes } : tag), reason);
+  }
+  async removeForumTag(channelId, tagId, reason) {
+    const tags = await this.#forumTags(channelId);
+    if (!tags.some((tag) => tag.id === tagId))
+      throw new Error(`Channel ${channelId} has no tag ${tagId}.`);
+    return this.#saveForumTags(channelId, tags.filter((tag) => tag.id !== tagId), reason);
+  }
+  async#forumTags(channelId) {
+    const channel = await this.#rest.get(Routes.channel(channelId));
+    return channel.available_tags ?? [];
+  }
+  async#saveForumTags(channelId, tags, reason) {
+    const updated = await this.#rest.patch(Routes.channel(channelId), { available_tags: tags }, { reason });
+    return updated.available_tags ?? [];
+  }
   async pinMessage(channelId, messageId, reason) {
     await this.#rest.put(Routes.channelMessagesPin(channelId, messageId), undefined, { reason });
   }
@@ -4579,9 +6528,6 @@ class ChannelManager extends Manager {
       hasMore: messages.length === limit
     };
   }
-  bulkDelete(channelId, messageIds) {
-    return this.bulkDeleteMessages(channelId, messageIds);
-  }
   clear() {
     this.#messageManagers.clear();
     super.clear();
@@ -4665,7 +6611,26 @@ class GatewaySession {
     return resume ? { type: "resume", ...resume } : { type: "identify" };
   }
   connectURL(fallback) {
-    return this.resumeInfo()?.resumeURL ?? fallback;
+    const resume = this.resumeInfo()?.resumeURL;
+    return resume !== undefined && isTrustedGatewayURL(resume, fallback) ? resume : fallback;
+  }
+}
+function isTrustedGatewayURL(url, fallback) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "wss:" || parsed.username || parsed.password)
+    return false;
+  const host = parsed.hostname.toLowerCase();
+  if (host === "discord.gg" || host.endsWith(".discord.gg"))
+    return true;
+  try {
+    return host === new URL(fallback).hostname.toLowerCase();
+  } catch {
+    return false;
   }
 }
 
@@ -4837,6 +6802,7 @@ class GatewayReconnect {
   #options;
   #random;
   #attempt = 0;
+  #recent = [];
   #timer;
   #promise;
   #resolve;
@@ -4877,14 +6843,29 @@ class GatewayReconnect {
     if (this.exhausted)
       return { scheduled: false, reason: "exhausted" };
     const attempt = this.#attempt;
-    const delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
+    const now = (this.#options.now ?? Date.now)();
+    const window = this.#options.stormWindow ?? 60000;
+    const limit = this.#options.stormLimit ?? 5;
+    while (this.#recent.length && now - this.#recent[0] >= window)
+      this.#recent.shift();
+    const over = this.#recent.length - limit;
+    this.#recent.push(now);
+    let delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
+    const unstable = over >= 0;
+    if (unstable)
+      delay = Math.min(this.#options.maxDelay, Math.max(delay, this.#options.baseDelay * 2 ** (over + 1)));
     const jitter = this.#random() * Math.max(1, delay * 0.25);
     const delayMs = delay + jitter;
     this.#timer = setTimeout(() => {
       this.#timer = undefined;
       run();
     }, delayMs);
-    return { scheduled: true, delayMs, attempt };
+    return {
+      scheduled: true,
+      delayMs,
+      attempt,
+      ...unstable ? { unstable: { reconnects: this.#recent.length } } : {}
+    };
   }
   cancel() {
     if (this.#timer)
@@ -4941,12 +6922,15 @@ class PlainTextDecoder {
 
 class ZlibStreamDecoder {
   #create;
+  #maxFrameBytes;
   #inflate;
   #chunks = [];
+  #size = 0;
   #failure;
   #pendingReject;
-  constructor(create = () => createInflate()) {
+  constructor(create = () => createInflate(), maxFrameBytes = 64 * 1024 * 1024) {
     this.#create = create;
+    this.#maxFrameBytes = maxFrameBytes;
   }
   push(data) {
     if (typeof data === "string")
@@ -4965,6 +6949,7 @@ class ZlibStreamDecoder {
     await this.#awaiting((settle) => inflate.flush(zlibConstants.Z_SYNC_FLUSH, () => settle()));
     const parts = this.#chunks;
     this.#chunks = [];
+    this.#size = 0;
     if (parts.length === 0)
       return [];
     const total = parts.reduce((size, part) => size + part.length, 0);
@@ -4980,6 +6965,7 @@ class ZlibStreamDecoder {
     const inflate = this.#inflate;
     this.#inflate = undefined;
     this.#chunks = [];
+    this.#size = 0;
     this.#failure = undefined;
     this.#pendingReject = undefined;
     if (!inflate)
@@ -5007,7 +6993,17 @@ class ZlibStreamDecoder {
   }
   #open() {
     const inflate = this.#create();
-    inflate.on("data", (chunk) => this.#chunks.push(chunk));
+    inflate.on("data", (chunk) => {
+      if (this.#failure)
+        return;
+      this.#size += chunk.length;
+      if (this.#size > this.#maxFrameBytes) {
+        this.#chunks = [];
+        inflate.emit("error", new Error(`Gateway frame inflated past ${this.#maxFrameBytes} bytes.`));
+        return;
+      }
+      this.#chunks.push(chunk);
+    });
     inflate.on("error", (error) => {
       this.#failure = error;
       const reject = this.#pendingReject;
@@ -5250,9 +7246,9 @@ function classifyPayload(payload) {
 }
 function identifyPayload(options) {
   const props = options.properties ?? {};
-  const os = props.os ?? "Android";
-  const browser = props.browser ?? "Discord Android";
-  const device = props.device ?? "Discord Android";
+  const os = props.os ?? process.platform;
+  const browser = props.browser ?? "Lunibee";
+  const device = props.device ?? "Lunibee";
   return {
     op: GatewayOpcodes.Identify,
     d: {
@@ -5294,17 +7290,40 @@ function resumePayload(token, resume) {
 function heartbeatPayload(sequence) {
   return { op: GatewayOpcodes.Heartbeat, d: sequence, s: null, t: null };
 }
-// packages/ws/src/state.ts
-class GatewayError extends Error {
-  code;
-  constructor(message, code, options) {
-    super(message, options);
-    this.name = "GatewayError";
-    this.code = code;
+// packages/ws/src/dispatcher.ts
+class GatewayDispatcher {
+  #listeners = new Map;
+  #onFailure;
+  constructor(onFailure) {
+    this.#onFailure = onFailure;
+  }
+  on(event, listener) {
+    let listeners = this.#listeners.get(event);
+    if (!listeners)
+      this.#listeners.set(event, listeners = new Set);
+    listeners.add(listener);
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+  }
+  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.#onFailure(error);
+          });
+      } catch (error) {
+        if (event !== "error")
+          this.#onFailure(error);
+      }
+    }
   }
 }
 // packages/ws/src/send-budget.ts
-class SendBudget {
+class GatewaySendLimiter {
   #timestamps = [];
   #limit;
   #windowMs;
@@ -5324,7 +7343,15 @@ class SendBudget {
     this.#timestamps.push(now);
   }
 }
-
+// packages/ws/src/state.ts
+class GatewayError extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = "GatewayError";
+    this.code = code;
+  }
+}
 // packages/ws/src/index.ts
 var RESUMABLE_CLOSE_CODE = 4900;
 var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
@@ -5338,8 +7365,9 @@ class Gateway {
   #heartbeat;
   #closed = false;
   #reconnect;
-  #listeners = new Map;
-  #sendBudget = new SendBudget;
+  #events = new GatewayDispatcher((error) => this.#emitError(error));
+  #sendBudget = new GatewaySendLimiter;
+  #reconnects = 0;
   ping = -1;
   constructor(options) {
     if (!options.token?.trim())
@@ -5357,9 +7385,9 @@ class Gateway {
       heartbeatAckTimeout: 1e4,
       zombieTimeout: 30000,
       properties: {
-        os: "Android",
-        browser: "Discord Android",
-        device: "Discord Android"
+        os: process.platform,
+        browser: "Lunibee",
+        device: "Lunibee"
       },
       presence: {
         status: "online",
@@ -5390,7 +7418,9 @@ class Gateway {
       enabled: this.#options.reconnect,
       maxAttempts: this.#options.maxReconnectAttempts,
       baseDelay: this.#options.reconnectBaseDelay,
-      maxDelay: this.#options.reconnectMaxDelay
+      maxDelay: this.#options.reconnectMaxDelay,
+      stormLimit: options.reconnectStormLimit,
+      stormWindow: options.reconnectStormWindow
     });
     this.#heartbeat = new GatewayHeartbeat({
       ackTimeout: this.#options.heartbeatAckTimeout,
@@ -5441,16 +7471,21 @@ class Gateway {
   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);
+    this.#events.on(event, listener);
     return this;
   }
   off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
+    this.#events.off(event, listener);
     return this;
   }
+  health() {
+    return {
+      state: this.state,
+      latency: this.#heartbeat.latency,
+      silentFor: this.#heartbeat.silentFor,
+      reconnects: this.#reconnects
+    };
+  }
   send(payload) {
     if (!payload || !Number.isInteger(payload.op))
       throw new TypeError("Gateway payload must contain an integer opcode.");
@@ -5492,6 +7527,22 @@ class Gateway {
       t: null
     });
   }
+  sendVoiceState(guildId, channelId, options = {}) {
+    if (!this.ownsGuild(guildId))
+      return false;
+    return this.setVoiceState({
+      guild_id: guildId,
+      channel_id: channelId,
+      self_mute: options.selfMute ?? false,
+      self_deaf: options.selfDeaf ?? false
+    });
+  }
+  ownsGuild(guildId) {
+    const count = this.#options.shardCount;
+    if (count <= 1)
+      return true;
+    return Number((BigInt(guildId) >> 22n) % BigInt(count)) === this.#options.shardId;
+  }
   requestGuildMembers(data) {
     return this.send({
       op: GatewayOpcodes.RequestGuildMembers,
@@ -5629,7 +7680,16 @@ class Gateway {
     if (this.#closed)
       return;
     const result = this.#reconnect.schedule(() => this.#open(this.#session.connectURL(DEFAULT_GATEWAY_URL)));
-    if (result.scheduled || result.reason !== "exhausted")
+    if (result.scheduled) {
+      this.#reconnects++;
+      if (result.unstable)
+        this.#emit("unstable", {
+          reconnects: result.unstable.reconnects,
+          delay: result.delayMs
+        });
+      return;
+    }
+    if (result.reason !== "exhausted")
       return;
     this.#reconnect.settle(new GatewayError("Gateway reconnect attempts exhausted."));
     this.#setState("CONNECT" /* Connect */);
@@ -5650,19 +7710,7 @@ class Gateway {
     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);
-      }
-    }
+    this.#events.emit(event, data);
   }
   #setState(next) {
     if (this.state === next)
@@ -5675,14 +7723,12 @@ class Gateway {
 
 // packages/core/src/index.ts
 class EventEmitter2 {
-  #listeners = new Map;
+  #listeners = {};
+  redactSecrets = (text) => text;
   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);
+    (this.#listeners[event] ??= new Set).add(listener);
     return this;
   }
   once(event, listener) {
@@ -5693,7 +7739,7 @@ class EventEmitter2 {
     return this.on(event, wrapped);
   }
   off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
+    this.#listeners[event]?.delete(listener);
     return this;
   }
   removeListener(event, listener) {
@@ -5701,13 +7747,13 @@ class EventEmitter2 {
   }
   removeAllListeners(event) {
     if (event === undefined)
-      this.#listeners.clear();
+      this.#listeners = {};
     else
-      this.#listeners.delete(event);
+      delete this.#listeners[event];
     return this;
   }
   emit(event, ...args) {
-    const listeners = this.#listeners.get(event);
+    const listeners = this.#listeners[event];
     if (!listeners?.size)
       return false;
     for (const listener of [...listeners]) {
@@ -5723,28 +7769,27 @@ class EventEmitter2 {
   }
   #handleError(event, error) {
     const normalized = error instanceof Error ? error : new Error(String(error), { cause: error });
-    const listeners = event === "error" /* Error */ ? [] : [
-      ...this.#listeners.get("error" /* Error */) ?? []
-    ];
+    const errorListeners = this.#listeners["error" /* Error */];
+    const listeners = event === "error" /* Error */ ? [] : [...errorListeners ?? []];
     if (listeners.length === 0)
-      return warnListenerError(event, normalized);
+      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));
+          Promise.resolve(result).catch((failure) => warnListenerError("error" /* Error */, failure, this.redactSecrets));
       } catch (failure) {
-        warnListenerError("error" /* Error */, failure);
+        warnListenerError("error" /* Error */, failure, this.redactSecrets);
       }
     }
   }
 }
-function warnListenerError(event, error) {
+function warnListenerError(event, error, redact = (text) => text) {
   const failure = error instanceof Error ? error : new Error(String(error));
-  process.emitWarning(`A "${String(event)}" listener threw and no error listener handled it: ${failure.message}`, {
+  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
+    detail: failure.stack === undefined ? undefined : redact(failure.stack)
   });
 }
 
@@ -5756,7 +7801,13 @@ class Client extends EventEmitter2 {
   channels;
   stageInstances;
   application;
+  #api;
+  get api() {
+    return this.#api ??= createApi(this.rest);
+  }
+  commands = new CommandRegistry(this);
   monetization;
+  applicationEmojis;
   get ws() {
     return this.#gateway;
   }
@@ -5766,6 +7817,10 @@ class Client extends EventEmitter2 {
   user;
   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;
   }
@@ -5781,9 +7836,26 @@ class Client extends EventEmitter2 {
   setPresence(data) {
     return this.#gateway.setPresence(data);
   }
+  setActivity(name, options = {}) {
+    const type = options.type ?? ActivityEnum.Playing;
+    return this.setPresence({
+      status: options.status ?? "online",
+      activities: name === null ? [] : [
+        {
+          name,
+          type,
+          url: options.url,
+          state: options.state ?? (type === ActivityEnum.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);
   }
@@ -5801,6 +7873,7 @@ class Client extends EventEmitter2 {
       members: true,
       roles: true,
       emojis: true,
+      presences: false,
       ...options.cache
     };
     this.users = new UserManager(this.rest);
@@ -5812,7 +7885,23 @@ class Client extends EventEmitter2 {
     this.stageInstances = new StageInstanceManager(this.rest);
     const placeholderAppCommands = new ApplicationCommandManager(this.rest, "0");
     this.application = { commands: placeholderAppCommands };
-    this.#resourceContext = {
+    this.#resourceContext = this.#createResourceContext();
+    this.guilds.attachContext(this.#resourceContext);
+    this.#gateway = new Gateway({
+      token: options.token,
+      intents: options.intents,
+      ...options.compress === undefined ? {} : { compress: options.compress },
+      ...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),
@@ -5826,10 +7915,13 @@ class Client extends EventEmitter2 {
       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),
-      memberPermissions: (guildId, memberId, roleIds, channelId) => this.#memberPermissions(guildId, memberId, roleIds, channelId),
+      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),
+      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) => {
@@ -5849,12 +7941,8 @@ class Client extends EventEmitter2 {
         return this.channels.permissionOverwrites(channelId).update(targetId, bits, options);
       }
     };
-    this.guilds.attachContext(this.#resourceContext);
-    this.#gateway = new Gateway({
-      token: options.token,
-      intents: options.intents,
-      ...options.gateway
-    });
+  }
+  #wireLifecycle() {
     this.#gateway.on("READY", (data) => {
       const ready = data;
       this.user = ready.user;
@@ -5865,6 +7953,8 @@ class Client extends EventEmitter2 {
       this.application.commands = new ApplicationCommandManager(this.rest, appId);
       if (this.monetization?.applicationId !== appId)
         this.monetization = new MonetizationManager(this.rest, appId);
+      if (this.applicationEmojis?.applicationId !== appId)
+        this.applicationEmojis = new ApplicationEmojiManager(this.rest, appId);
       this.emit("ready" /* Ready */, this.user);
     });
     this.#gateway.on("RESUMED", () => {
@@ -5880,6 +7970,8 @@ class Client extends EventEmitter2 {
         this.state = "idle";
       this.emit("close" /* Close */, data);
     });
+  }
+  #wireMessages() {
     this.#gateway.on("MESSAGE_CREATE", (data) => {
       const payload = data;
       const message = new Message(payload, this.#resourceContext);
@@ -5899,7 +7991,7 @@ class Client extends EventEmitter2 {
       const previous = messages?.cache.peek(message.id);
       if (previous)
         messages.cache.set(message.id, message);
-      this.emit("messageUpdate" /* MessageUpdate */, message, previous);
+      this.emit("messageUpdate" /* MessageUpdate */, message, previous ?? null);
     });
     this.#gateway.on("MESSAGE_DELETE", (data) => {
       const payload = data;
@@ -5927,6 +8019,8 @@ class Client extends EventEmitter2 {
     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) {
@@ -6027,6 +8121,8 @@ class Client extends EventEmitter2 {
       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;
@@ -6097,8 +8193,10 @@ class Client extends EventEmitter2 {
     });
     this.#gateway.on("GUILD_SCHEDULED_EVENT_UPDATE", (data) => {
       const event = data;
-      this.guilds.scheduledEvents(event.guild_id).set(event.id, event);
-      this.emit("guildScheduledEventUpdate" /* GuildScheduledEventUpdate */, event);
+      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;
@@ -6114,8 +8212,10 @@ class Client extends EventEmitter2 {
     });
     this.#gateway.on("AUTO_MODERATION_RULE_UPDATE", (data) => {
       const rule = data;
-      this.guilds.autoModerationRules(rule.guild_id).set(rule.id, rule);
-      this.emit("autoModerationRuleUpdate" /* AutoModerationRuleUpdate */, rule);
+      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;
@@ -6123,6 +8223,8 @@ class Client extends EventEmitter2 {
       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);
@@ -6169,8 +8271,9 @@ class Client extends EventEmitter2 {
     });
     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);
+      this.emit("stageInstanceUpdate" /* StageInstanceUpdate */, stage, previous);
     });
     this.#gateway.on("STAGE_INSTANCE_DELETE", (data) => {
       const stage = data;
@@ -6190,14 +8293,26 @@ class Client extends EventEmitter2 {
       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.emit("voiceStateUpdate" /* VoiceStateUpdate */, state);
+      this.emit("voiceStateUpdate" /* VoiceStateUpdate */, state, previous);
     });
     this.#gateway.on("VOICE_SERVER_UPDATE", (data) => this.emit("voiceServerUpdate" /* VoiceServerUpdate */, data));
-    this.#gateway.on("PRESENCE_UPDATE", (data) => this.emit("presenceUpdate" /* PresenceUpdate */, data));
+    this.#gateway.on("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 */, createInteraction(this, data)));
     this.#gateway.on("RAW", (data) => this.emit("raw" /* Raw */, data));
@@ -6262,10 +8377,28 @@ class Client extends EventEmitter2 {
     collector.onDispose(() => this.off(event, listener));
     return collector;
   }
+  guild(id) {
+    return new GuildHandle(this, id);
+  }
+  channel(id) {
+    return new ChannelHandle(this, id);
+  }
+  person(id) {
+    return new UserHandle(this, id);
+  }
+  member(guildId, userId) {
+    return new MemberHandle(this, guildId, userId);
+  }
+  role(guildId, roleId) {
+    return new RoleHandle(this, guildId, roleId);
+  }
+  message(channelId, messageId) {
+    return new MessageHandle(this, channelId, messageId);
+  }
   get resourceContext() {
     return this.#resourceContext;
   }
-  #memberPermissions(guildId, memberId, roleIds, channelId) {
+  #memberPermissions(guildId, memberId, roleIds, channelId, timedOutUntil) {
     const guild = this.guilds.get(guildId);
     if (!guild)
       return null;
@@ -6282,7 +8415,8 @@ class Client extends EventEmitter2 {
       memberId,
       memberRoleIds: [...roleIds],
       roles: this.guilds.roles(guildId).values(),
-      overwrites: channel?.permissionOverwrites
+      overwrites: channel?.permissionOverwrites,
+      timedOutUntil
     });
   }
   permissionsFor(memberId, guildOrChannelId) {
@@ -6303,7 +8437,8 @@ class Client extends EventEmitter2 {
       memberId,
       memberRoleIds: member.roleIds,
       roles: this.guilds.roles(guildId).values(),
-      overwrites: channel?.permissionOverwrites
+      overwrites: channel?.permissionOverwrites,
+      timedOutUntil: member.timedOutUntil
     });
   }
   fetchDefaultSoundboardSounds() {
@@ -6351,10 +8486,10 @@ class Client extends EventEmitter2 {
       return Promise.reject(new Error("Client is unauthenticated."));
     return this.rest.delete(Routes.interactionOriginalResponse(this.user.id, token));
   }
-  followUpInteraction(token, data) {
+  async followUpInteraction(token, data) {
     if (!this.user)
       return Promise.reject(new Error("Client is unauthenticated."));
-    return this.rest.post(`/webhooks/${this.user.id}/${token}`, toRequest(data, this.options.allowedMentions));
+    return this.rest.post(Routes.webhook(this.user.id, token), toRequest(data, this.options.allowedMentions));
   }
   interactionWebhookMessage(method, applicationId, token, messageId, data) {
     const path = messageId === "@original" ? Routes.interactionOriginalResponse(applicationId, token) : Routes.webhookMessage(applicationId, token, messageId);
@@ -6364,11 +8499,11 @@ class Client extends EventEmitter2 {
       return this.rest.patch(path, data ? toRequest(data, this.options.allowedMentions) : data);
     return this.rest.delete(path);
   }
-  fetchWebhook(id, token) {
-    return this.rest.get(token ? `/webhooks/${id}/${token}` : `/webhooks/${id}`);
+  async fetchWebhook(id, token) {
+    return this.rest.get(Routes.webhook(id, token));
   }
-  fetchGuildPreview(guildId) {
-    return this.rest.get(`/guilds/${guildId}/preview`);
+  async fetchGuildPreview(guildId) {
+    return this.rest.get(Routes.guildPreview(guildId));
   }
   fetchVoiceRegions() {
     return this.rest.get("/voice/regions");
@@ -6382,11 +8517,11 @@ class Client extends EventEmitter2 {
     const qs = query.toString();
     return this.rest.get(`/invites/${encodeURIComponent(code)}${qs ? `?${qs}` : ""}`);
   }
-  fetchSticker(id) {
-    return this.rest.get(`/stickers/${id}`);
+  async fetchSticker(id) {
+    return this.rest.get(Routes.sticker(id));
   }
   fetchPremiumStickerPacks() {
-    return this.rest.get(`/sticker-packs`);
+    return this.rest.get(Routes.stickerPacks());
   }
   fetchGuildTemplate(code) {
     return this.rest.get(`/guilds/templates/${encodeURIComponent(code)}`);
@@ -6405,23 +8540,34 @@ class Client extends EventEmitter2 {
   }
 }
 export {
+  ChannelHandle,
   Client,
   ClientEvent,
   Collector,
+  CommandRegistry,
   ClientEvent as Events,
   GatewayIntentBits,
+  GuildHandle,
   IntentBits,
   Intents,
   IntentsBitField,
+  MemberHandle,
+  MessageHandle,
   Permission,
   PermissionFlagsBits,
   PermissionOverwriteEnum,
-  PermissionOverwriteType,
   PermissionSet,
   Permissions,
   PermissionsBitField,
+  RoleHandle,
+  UserHandle,
+  channelCreatePayload,
+  command,
   computePermissions,
+  createApi,
+  option,
+  parseDuration,
   resolveGatewayIntents
 };
 
-//# debugId=A8C0111D9C7EBB3664756E2164756E21
+//# debugId=EEC9EA7D2E19B5EE64756E2164756E21