lunibee 0.1.7 → 0.1.8

package/dist/index.js

@@ -1,9 +1,9 @@
 // @bun
 // packages/core/src/permissions.ts
 var PermissionOverwriteType;
-((PermissionOverwriteType2) => {
-  PermissionOverwriteType2[PermissionOverwriteType2["Role"] = 0] = "Role";
-  PermissionOverwriteType2[PermissionOverwriteType2["Member"] = 1] = "Member";
+((PermissionOverwriteType) => {
+  PermissionOverwriteType[PermissionOverwriteType["Role"] = 0] = "Role";
+  PermissionOverwriteType[PermissionOverwriteType["Member"] = 1] = "Member";
 })(PermissionOverwriteType ||= {});
 var Permission = {
   createInstantInvite: 1n << 0n,
@@ -421,71 +421,71 @@ class PermissionsBitField extends PermissionSet {
 }
 // packages/core/src/events.ts
 var ClientEvent;
-((ClientEvent2) => {
-  ClientEvent2["Ready"] = "ready";
-  ClientEvent2["Resumed"] = "resumed";
-  ClientEvent2["InvalidSession"] = "invalidSession";
-  ClientEvent2["Raw"] = "raw";
-  ClientEvent2["Error"] = "error";
-  ClientEvent2["Open"] = "open";
-  ClientEvent2["Close"] = "close";
-  ClientEvent2["MessageCreate"] = "messageCreate";
-  ClientEvent2["MessageUpdate"] = "messageUpdate";
-  ClientEvent2["MessageDelete"] = "messageDelete";
-  ClientEvent2["MessageDeleteBulk"] = "messageDeleteBulk";
-  ClientEvent2["MessageReactionAdd"] = "messageReactionAdd";
-  ClientEvent2["MessageReactionRemove"] = "messageReactionRemove";
-  ClientEvent2["MessageReactionRemoveAll"] = "messageReactionRemoveAll";
-  ClientEvent2["MessageReactionRemoveEmoji"] = "messageReactionRemoveEmoji";
-  ClientEvent2["MessagePollVoteAdd"] = "messagePollVoteAdd";
-  ClientEvent2["MessagePollVoteRemove"] = "messagePollVoteRemove";
-  ClientEvent2["GuildCreate"] = "guildCreate";
-  ClientEvent2["GuildUpdate"] = "guildUpdate";
-  ClientEvent2["GuildDelete"] = "guildDelete";
-  ClientEvent2["GuildAvailable"] = "guildAvailable";
-  ClientEvent2["GuildUnavailable"] = "guildUnavailable";
-  ClientEvent2["GuildMemberAdd"] = "guildMemberAdd";
-  ClientEvent2["GuildMemberUpdate"] = "guildMemberUpdate";
-  ClientEvent2["GuildMemberRemove"] = "guildMemberRemove";
-  ClientEvent2["GuildMembersChunk"] = "guildMembersChunk";
-  ClientEvent2["GuildBanAdd"] = "guildBanAdd";
-  ClientEvent2["GuildBanRemove"] = "guildBanRemove";
-  ClientEvent2["GuildRoleCreate"] = "guildRoleCreate";
-  ClientEvent2["GuildRoleUpdate"] = "guildRoleUpdate";
-  ClientEvent2["GuildRoleDelete"] = "guildRoleDelete";
-  ClientEvent2["GuildEmojisUpdate"] = "guildEmojisUpdate";
-  ClientEvent2["GuildStickersUpdate"] = "guildStickersUpdate";
-  ClientEvent2["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
-  ClientEvent2["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
-  ClientEvent2["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
-  ClientEvent2["GuildScheduledEventDelete"] = "guildScheduledEventDelete";
-  ClientEvent2["GuildScheduledEventUserAdd"] = "guildScheduledEventUserAdd";
-  ClientEvent2["GuildScheduledEventUserRemove"] = "guildScheduledEventUserRemove";
-  ClientEvent2["AutoModerationRuleCreate"] = "autoModerationRuleCreate";
-  ClientEvent2["AutoModerationRuleUpdate"] = "autoModerationRuleUpdate";
-  ClientEvent2["AutoModerationRuleDelete"] = "autoModerationRuleDelete";
-  ClientEvent2["AutoModerationActionExecution"] = "autoModerationActionExecution";
-  ClientEvent2["ChannelCreate"] = "channelCreate";
-  ClientEvent2["ChannelUpdate"] = "channelUpdate";
-  ClientEvent2["ChannelDelete"] = "channelDelete";
-  ClientEvent2["ChannelPinsUpdate"] = "channelPinsUpdate";
-  ClientEvent2["ThreadCreate"] = "threadCreate";
-  ClientEvent2["ThreadUpdate"] = "threadUpdate";
-  ClientEvent2["ThreadDelete"] = "threadDelete";
-  ClientEvent2["ThreadListSync"] = "threadListSync";
-  ClientEvent2["ThreadMembersUpdate"] = "threadMembersUpdate";
-  ClientEvent2["ThreadMemberUpdate"] = "threadMemberUpdate";
-  ClientEvent2["StageInstanceCreate"] = "stageInstanceCreate";
-  ClientEvent2["StageInstanceUpdate"] = "stageInstanceUpdate";
-  ClientEvent2["StageInstanceDelete"] = "stageInstanceDelete";
-  ClientEvent2["InviteCreate"] = "inviteCreate";
-  ClientEvent2["InviteDelete"] = "inviteDelete";
-  ClientEvent2["WebhooksUpdate"] = "webhooksUpdate";
-  ClientEvent2["VoiceStateUpdate"] = "voiceStateUpdate";
-  ClientEvent2["VoiceServerUpdate"] = "voiceServerUpdate";
-  ClientEvent2["PresenceUpdate"] = "presenceUpdate";
-  ClientEvent2["TypingStart"] = "typingStart";
-  ClientEvent2["InteractionCreate"] = "interactionCreate";
+((ClientEvent) => {
+  ClientEvent["Ready"] = "ready";
+  ClientEvent["Resumed"] = "resumed";
+  ClientEvent["InvalidSession"] = "invalidSession";
+  ClientEvent["Raw"] = "raw";
+  ClientEvent["Error"] = "error";
+  ClientEvent["Open"] = "open";
+  ClientEvent["Close"] = "close";
+  ClientEvent["MessageCreate"] = "messageCreate";
+  ClientEvent["MessageUpdate"] = "messageUpdate";
+  ClientEvent["MessageDelete"] = "messageDelete";
+  ClientEvent["MessageDeleteBulk"] = "messageDeleteBulk";
+  ClientEvent["MessageReactionAdd"] = "messageReactionAdd";
+  ClientEvent["MessageReactionRemove"] = "messageReactionRemove";
+  ClientEvent["MessageReactionRemoveAll"] = "messageReactionRemoveAll";
+  ClientEvent["MessageReactionRemoveEmoji"] = "messageReactionRemoveEmoji";
+  ClientEvent["MessagePollVoteAdd"] = "messagePollVoteAdd";
+  ClientEvent["MessagePollVoteRemove"] = "messagePollVoteRemove";
+  ClientEvent["GuildCreate"] = "guildCreate";
+  ClientEvent["GuildUpdate"] = "guildUpdate";
+  ClientEvent["GuildDelete"] = "guildDelete";
+  ClientEvent["GuildAvailable"] = "guildAvailable";
+  ClientEvent["GuildUnavailable"] = "guildUnavailable";
+  ClientEvent["GuildMemberAdd"] = "guildMemberAdd";
+  ClientEvent["GuildMemberUpdate"] = "guildMemberUpdate";
+  ClientEvent["GuildMemberRemove"] = "guildMemberRemove";
+  ClientEvent["GuildMembersChunk"] = "guildMembersChunk";
+  ClientEvent["GuildBanAdd"] = "guildBanAdd";
+  ClientEvent["GuildBanRemove"] = "guildBanRemove";
+  ClientEvent["GuildRoleCreate"] = "guildRoleCreate";
+  ClientEvent["GuildRoleUpdate"] = "guildRoleUpdate";
+  ClientEvent["GuildRoleDelete"] = "guildRoleDelete";
+  ClientEvent["GuildEmojisUpdate"] = "guildEmojisUpdate";
+  ClientEvent["GuildStickersUpdate"] = "guildStickersUpdate";
+  ClientEvent["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
+  ClientEvent["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
+  ClientEvent["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
+  ClientEvent["GuildScheduledEventDelete"] = "guildScheduledEventDelete";
+  ClientEvent["GuildScheduledEventUserAdd"] = "guildScheduledEventUserAdd";
+  ClientEvent["GuildScheduledEventUserRemove"] = "guildScheduledEventUserRemove";
+  ClientEvent["AutoModerationRuleCreate"] = "autoModerationRuleCreate";
+  ClientEvent["AutoModerationRuleUpdate"] = "autoModerationRuleUpdate";
+  ClientEvent["AutoModerationRuleDelete"] = "autoModerationRuleDelete";
+  ClientEvent["AutoModerationActionExecution"] = "autoModerationActionExecution";
+  ClientEvent["ChannelCreate"] = "channelCreate";
+  ClientEvent["ChannelUpdate"] = "channelUpdate";
+  ClientEvent["ChannelDelete"] = "channelDelete";
+  ClientEvent["ChannelPinsUpdate"] = "channelPinsUpdate";
+  ClientEvent["ThreadCreate"] = "threadCreate";
+  ClientEvent["ThreadUpdate"] = "threadUpdate";
+  ClientEvent["ThreadDelete"] = "threadDelete";
+  ClientEvent["ThreadListSync"] = "threadListSync";
+  ClientEvent["ThreadMembersUpdate"] = "threadMembersUpdate";
+  ClientEvent["ThreadMemberUpdate"] = "threadMemberUpdate";
+  ClientEvent["StageInstanceCreate"] = "stageInstanceCreate";
+  ClientEvent["StageInstanceUpdate"] = "stageInstanceUpdate";
+  ClientEvent["StageInstanceDelete"] = "stageInstanceDelete";
+  ClientEvent["InviteCreate"] = "inviteCreate";
+  ClientEvent["InviteDelete"] = "inviteDelete";
+  ClientEvent["WebhooksUpdate"] = "webhooksUpdate";
+  ClientEvent["VoiceStateUpdate"] = "voiceStateUpdate";
+  ClientEvent["VoiceServerUpdate"] = "voiceServerUpdate";
+  ClientEvent["PresenceUpdate"] = "presenceUpdate";
+  ClientEvent["TypingStart"] = "typingStart";
+  ClientEvent["InteractionCreate"] = "interactionCreate";
 })(ClientEvent ||= {});
 // packages/core/src/collector.ts
 import { EventEmitter } from "events";
@@ -548,16 +548,20 @@ class Collector extends EventEmitter {
       if (this.ended) {
         return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
       }
-      this.once("collect", (item) => {
+      const onCollect = (item) => {
+        this.off("end", onEnd);
         resolve(item);
-      });
-      this.once("end", (_collected, reason) => {
+      };
+      const onEnd = (_collected, reason) => {
+        this.off("collect", onCollect);
         reject(new Error(`Collector ended before item was collected: ${reason}`));
-      });
+      };
+      this.once("collect", onCollect);
+      this.once("end", onEnd);
     });
   }
 }
-// packages/types/src/index.ts
+// packages/types/src/gateway.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
   GuildMembers: 1 << 1,
@@ -613,6 +617,8 @@ var Intents = IntentBits;
 function resolveGatewayIntents(intents) {
   if (typeof intents === "number")
     return intents;
+  if (intents && typeof intents === "object" && !Array.isArray(intents))
+    return intents.bitfield;
   if (Array.isArray(intents)) {
     return intents.reduce((acc, intent) => {
       return acc | resolveGatewayIntents(intent);
@@ -632,6 +638,45 @@ function resolveGatewayIntents(intents) {
   }
   return 0;
 }
+
+class IntentsBitField {
+  static Flags = GatewayIntentBits;
+  bitfield;
+  constructor(bits = 0) {
+    this.bitfield = resolveGatewayIntents(bits);
+  }
+  has(bits) {
+    const resolved = resolveGatewayIntents(bits);
+    return (this.bitfield & resolved) === resolved;
+  }
+  any(bits) {
+    return (this.bitfield & resolveGatewayIntents(bits)) !== 0;
+  }
+  add(...bits) {
+    for (const bit of bits)
+      this.bitfield |= resolveGatewayIntents(bit);
+    return this;
+  }
+  remove(...bits) {
+    for (const bit of bits)
+      this.bitfield &= ~resolveGatewayIntents(bit);
+    return this;
+  }
+  toArray() {
+    return Object.keys(GatewayIntentBits).filter((name) => this.has(GatewayIntentBits[name]));
+  }
+  equals(bits) {
+    return this.bitfield === resolveGatewayIntents(bits);
+  }
+  valueOf() {
+    return this.bitfield;
+  }
+  toJSON() {
+    return this.bitfield;
+  }
+}
+
+// packages/types/src/index.ts
 var MessageFlags = {
   Crossposted: 1,
   IsCrosspost: 2,
@@ -734,6 +779,7 @@ class Cache {
       if (!Number.isFinite(interval) || interval < 1)
         throw new RangeError("Cache sweepInterval must be positive.");
       this.#timer = setInterval(() => this.sweep(), interval);
+      this.#timer.unref?.();
     }
   }
   get size() {
@@ -1097,7 +1143,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.7",
+  version: "0.1.8",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -1122,6 +1168,17 @@ class MemoryRateLimitStore {
   getBucket(key) {
     return this.#buckets.get(key);
   }
+  reserve(key) {
+    const state = this.#buckets.get(key);
+    const now = Date.now();
+    if (!state || state.resetAt <= now)
+      return { granted: true };
+    if (state.remaining > 0) {
+      state.remaining -= 1;
+      return { granted: true };
+    }
+    return { granted: false, retryAfterMs: state.resetAt - now };
+  }
   updateBucket(key, state) {
     this.#buckets.set(key, state);
     const now = Date.now();
@@ -1145,6 +1202,301 @@ class MemoryRateLimitStore {
   }
 }
 
+// packages/rest/src/errors.ts
+class RESTError extends Error {
+  status;
+  code;
+  errors;
+  method;
+  path;
+  constructor(message, status, code, errors, options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "RESTError";
+    this.status = status;
+    this.code = code;
+    this.errors = errors;
+    this.method = options.method;
+    this.path = options.path;
+  }
+}
+function abortError(path, reason) {
+  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+}
+async function sleep(delay, signal, path) {
+  if (delay <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delay);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(abortError(path, signal?.reason));
+    };
+    if (signal?.aborted)
+      return abort();
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function abortable(promise, signal, path) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    throw abortError(path, signal.reason);
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => signal.addEventListener("abort", () => reject(abortError(path, signal.reason)), { once: true }))
+  ]);
+}
+
+// packages/rest/src/route.ts
+function normalizeRoutePath(path) {
+  const queryIndex = path.indexOf("?");
+  const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
+  return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
+}
+function majorParameter(path) {
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  if (!match)
+    return "@none";
+  if (match[1] === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${match[3]}`;
+  return match[2];
+}
+function scopeBucket(hashOrRoute, major) {
+  return `${hashOrRoute}|${major}`;
+}
+function createRouteKey(method, path) {
+  const normalizedMethod = method.toUpperCase();
+  return {
+    method: normalizedMethod,
+    path,
+    route: `${normalizedMethod}:${normalizeRoutePath(path)}`,
+    major: majorParameter(path)
+  };
+}
+function serializeQuery(query) {
+  if (query === undefined)
+    return "";
+  if (typeof query === "string")
+    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
+  const serialized = params.toString();
+  return serialized.length === 0 ? "" : `?${serialized}`;
+}
+
+// packages/rest/src/scheduler.ts
+class RequestScheduler {
+  static MAX_REMAPS = 2;
+  #queues = new Map;
+  get size() {
+    return this.#queues.size;
+  }
+  async runResolved(resolveKey, signal, path, task) {
+    let key = await resolveKey();
+    for (let hop = 0;hop < RequestScheduler.MAX_REMAPS; hop++) {
+      const outcome = await this.run(key, signal, path, async (release) => {
+        const current = await resolveKey();
+        if (current !== key)
+          return { done: false, key: current };
+        return { done: true, value: await task(key, release) };
+      });
+      if (outcome.done)
+        return outcome.value;
+      key = outcome.key;
+    }
+    return this.run(key, signal, path, (release) => task(key, release));
+  }
+  async run(key, signal, path, task) {
+    const previous = this.#queues.get(key) ?? Promise.resolve();
+    let open;
+    const gate = new Promise((resolve) => {
+      open = resolve;
+    });
+    this.#queues.set(key, gate);
+    let released = false;
+    const release = () => {
+      if (released)
+        return;
+      released = true;
+      open();
+      if (this.#queues.get(key) === gate)
+        this.#queues.delete(key);
+    };
+    try {
+      await abortable(previous, signal, path);
+      return await task(release);
+    } finally {
+      release();
+    }
+  }
+}
+
+// packages/rest/src/limiter.ts
+class RateLimiter {
+  #store;
+  #concurrent;
+  constructor(store, options = {}) {
+    this.#store = store;
+    this.#concurrent = options.concurrent ?? false;
+  }
+  get store() {
+    return this.#store;
+  }
+  async resolveBucketKey(route, major) {
+    return scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
+  }
+  get reserves() {
+    return typeof this.#store.reserve === "function";
+  }
+  async acquire(bucketKey, signal, path) {
+    await this.#waitGlobal(signal, path);
+    if (!this.#store.reserve) {
+      const bucket = await this.#store.getBucket(bucketKey);
+      if (bucket) {
+        const delay = bucket.resetAt - Date.now();
+        if (bucket.remaining <= 0 && delay > 0)
+          await sleep(delay, signal, path);
+      }
+      return;
+    }
+    for (let attempt = 0;attempt < 8; attempt++) {
+      const reservation = await this.#store.reserve(bucketKey);
+      if (reservation.granted)
+        return;
+      await sleep(Math.max(1, reservation.retryAfterMs), signal, path);
+      await this.#waitGlobal(signal, path);
+    }
+  }
+  async#waitGlobal(signal, path) {
+    const globalDelay = await this.#store.getGlobalReset() - Date.now();
+    if (globalDelay > 0)
+      await sleep(globalDelay, signal, path);
+  }
+  async noteGlobalReset(resetAt) {
+    const current = await this.#store.getGlobalReset();
+    await this.#store.setGlobalReset(Math.max(current, resetAt));
+  }
+  async applyResponse(response, bucketKey, route, major) {
+    let currentKey = bucketKey;
+    const serverBucket = response.headers.get("X-RateLimit-Bucket");
+    if (serverBucket) {
+      await this.#store.setBucketHash(route, serverBucket);
+      currentKey = scopeBucket(serverBucket, major);
+    }
+    const stored = await this.#store.getBucket(currentKey);
+    const bucket = stored ? { ...stored } : { remaining: 1, resetAt: 0 };
+    const windowActive = this.#concurrent && !!stored && stored.resetAt > Date.now();
+    const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
+    const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
+    const reset = Number(response.headers.get("X-RateLimit-Reset"));
+    if (Number.isFinite(remaining))
+      bucket.remaining = Math.max(0, remaining);
+    if (Number.isFinite(resetAfter))
+      bucket.resetAt = Date.now() + Math.max(0, resetAfter) * 1000;
+    else if (Number.isFinite(reset))
+      bucket.resetAt = reset * 1000;
+    if (windowActive && stored) {
+      bucket.remaining = Math.min(bucket.remaining, stored.remaining);
+      bucket.resetAt = Math.max(bucket.resetAt, stored.resetAt);
+    }
+    if (response.status === 429) {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      if (Number.isFinite(retryAfter))
+        bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
+    }
+    await this.#store.updateBucket(currentKey, bucket);
+    if (response.headers.get("X-RateLimit-Global") === "true") {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      if (Number.isFinite(retryAfter))
+        await this.noteGlobalReset(Date.now() + retryAfter * 1000);
+    }
+    return currentKey;
+  }
+}
+
+// packages/rest/src/transport.ts
+class TransportError extends Error {
+  timedOut;
+  constructor(message, timedOut, cause) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "TransportError";
+    this.timedOut = timedOut;
+  }
+}
+
+class HttpTransport {
+  #baseURL;
+  #timeout;
+  #fetch;
+  constructor(options = {}) {
+    this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    this.#timeout = Math.max(1, options.timeout ?? 15000);
+    this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  get baseURL() {
+    return this.#baseURL;
+  }
+  get timeout() {
+    return this.#timeout;
+  }
+  async send(request) {
+    if (request.signal?.aborted)
+      throw abortError(request.path, request.signal.reason);
+    const controller = new AbortController;
+    const onAbort = () => controller.abort(request.signal?.reason);
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
+    try {
+      return await this.#fetch(`${this.#baseURL}${request.path}`, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof RESTError)
+        throw error;
+      const timedOut = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
+      throw new TransportError(timedOut ? `Discord REST request timed out after ${this.#timeout}ms` : "Discord REST request failed", timedOut, error);
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+}
+
+// packages/rest/src/decoder.ts
+class ResponseDecoder {
+  async read(response) {
+    if (response.status === 204)
+      return;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json"))
+      return response.json().catch(() => {
+        return;
+      });
+    return response.text().catch(() => {
+      return;
+    });
+  }
+  errorData(payload) {
+    if (!payload || typeof payload !== "object")
+      return {};
+    const data = payload;
+    return {
+      message: typeof data.message === "string" ? data.message : undefined,
+      code: typeof data.code === "number" ? data.code : undefined,
+      retry_after: typeof data.retry_after === "number" ? data.retry_after : undefined,
+      global: data.global === true
+    };
+  }
+  retryAfter(response, data) {
+    const raw = response.headers.get("Retry-After");
+    const header = raw === null ? Number.NaN : Number(raw);
+    const retryAfter = data.retry_after ?? (Number.isFinite(header) ? header : 1);
+    return Math.max(0, retryAfter);
+  }
+}
+
 // packages/rest/src/routes.ts
 var Routes = {
   user: () => "/users/@me",
@@ -1186,6 +1538,8 @@ var Routes = {
   threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
   guildScheduledEvents: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events`,
   guildScheduledEvent: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}`,
+  guildScheduledEventUsers: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}/users`,
+  channelPermission: (channelId, overwriteId) => `/channels/${snowflake(channelId, "Channel ID")}/permissions/${snowflake(overwriteId, "Overwrite ID")}`,
   guildAutoModerationRules: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules`,
   guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
   voiceRegions: () => "/voice/regions",
@@ -1209,15 +1563,36 @@ function snowflake(value, field) {
   return value;
 }
 // packages/rest/src/redis.ts
+var RESERVE_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return {1, 0} end
+local ok, state = pcall(cjson.decode, raw)
+if not ok or type(state) ~= 'table' or type(state.resetAt) ~= 'number' then
+  return {1, 0}
+end
+local now = tonumber(ARGV[1])
+local wait = state.resetAt - now
+if wait <= 0 then return {1, 0} end
+if type(state.remaining) == 'number' and state.remaining > 0 then
+  state.remaining = state.remaining - 1
+  redis.call('SET', KEYS[1], cjson.encode(state), 'PX', math.ceil(wait))
+  return {1, 0}
+end
+return {0, math.ceil(wait)}
+`;
+
 class RedisRateLimitStore {
   #client;
   #prefix;
   #onErrorCallback;
+  #local = new MemoryRateLimitStore;
   #lastError;
   constructor(options) {
     this.#client = options.client;
     this.#prefix = options.prefix ?? "lunibee:rest:";
     this.#onErrorCallback = options.onError;
+    if (typeof options.client.eval === "function")
+      this.reserve = (key) => this.#reserve(key);
   }
   get lastError() {
     return this.#lastError;
@@ -1242,10 +1617,11 @@ class RedisRateLimitStore {
       return hash ?? undefined;
     } catch (error) {
       this.#onError("getBucketHash", error);
-      return;
+      return this.#local.getBucketHash(route);
     }
   }
   async setBucketHash(route, hash) {
+    this.#local.setBucketHash(route, hash);
     try {
       await this.#client.set(`${this.#prefix}route:${route}`, hash, "EX", 604800);
       this.#markHealthy();
@@ -1262,10 +1638,11 @@ class RedisRateLimitStore {
       return JSON.parse(data);
     } catch (error) {
       this.#onError("getBucket", error);
-      return;
+      return this.#local.getBucket(key);
     }
   }
   async updateBucket(key, state) {
+    this.#local.updateBucket(key, state);
     const bucketKey = `${this.#prefix}bucket:${key}`;
     const ttl = Math.ceil((state.resetAt - Date.now()) / 1000);
     try {
@@ -1280,6 +1657,23 @@ class RedisRateLimitStore {
       this.#onError("updateBucket", error);
     }
   }
+  get supportsReservation() {
+    return typeof this.#client.eval === "function";
+  }
+  reserve;
+  async#reserve(key) {
+    try {
+      const result = await this.#client.eval(RESERVE_SCRIPT, 1, `${this.#prefix}bucket:${key}`, Date.now());
+      this.#markHealthy();
+      if (!Array.isArray(result))
+        return { granted: true };
+      const [granted, retryAfterMs] = result;
+      return Number(granted) === 1 ? { granted: true } : { granted: false, retryAfterMs: Number(retryAfterMs) || 0 };
+    } catch (error) {
+      this.#onError("reserve", error);
+      return this.#local.reserve(key);
+    }
+  }
   async getGlobalReset() {
     try {
       const resetAt = await this.#client.get(`${this.#prefix}global`);
@@ -1287,10 +1681,11 @@ class RedisRateLimitStore {
       return resetAt ? Number(resetAt) : 0;
     } catch (error) {
       this.#onError("getGlobalReset", error);
-      return 0;
+      return this.#local.getGlobalReset();
     }
   }
   async setGlobalReset(resetAt) {
+    this.#local.setGlobalReset(resetAt);
     const globalKey = `${this.#prefix}global`;
     const ttl = Math.ceil((resetAt - Date.now()) / 1000);
     try {
@@ -1346,22 +1741,6 @@ class WebhookClient {
 }
 
 // packages/rest/src/index.ts
-class RESTError extends Error {
-  status;
-  code;
-  errors;
-  method;
-  path;
-  constructor(message, status, code, errors, options = {}) {
-    super(message, options.cause === undefined ? undefined : { cause: options.cause });
-    this.name = "RESTError";
-    this.status = status;
-    this.code = code;
-    this.errors = errors;
-    this.method = options.method;
-    this.path = options.path;
-  }
-}
 var LIBRARY_VERSION = package_default.version;
 var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
 var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
@@ -1388,26 +1767,6 @@ function isRequestData(value) {
     return false;
   return keys.every((key) => REQUEST_DATA_KEYS.has(key));
 }
-function serializeQuery(query) {
-  if (query === undefined)
-    return "";
-  if (typeof query === "string")
-    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
-  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
-  const serialized = params.toString();
-  return serialized.length === 0 ? "" : `?${serialized}`;
-}
-function majorParameter(path) {
-  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
-  if (!match)
-    return "@none";
-  if (match[1] === "webhooks" && match[3] !== undefined)
-    return `${match[2]}:${match[3]}`;
-  return match[2];
-}
-function scopeBucket(hashOrRoute, major) {
-  return `${hashOrRoute}|${major}`;
-}
 function createRetryPolicy(maxRetries = 2) {
   if (!Number.isFinite(maxRetries) || maxRetries < 0)
     throw new TypeError("maxRetries must be a non-negative finite number.");
@@ -1415,7 +1774,10 @@ function createRetryPolicy(maxRetries = 2) {
     maxRetries: Math.floor(maxRetries),
     shouldRetry(method, status) {
       const normalized = method.toUpperCase();
-      return status === 429 || status >= 500 && status <= 599 && ["GET", "HEAD", "PUT", "DELETE"].includes(normalized);
+      const idempotent = ["GET", "HEAD", "PUT", "DELETE"].includes(normalized);
+      if (status === 0)
+        return idempotent;
+      return status === 429 || status >= 500 && status <= 599 && idempotent;
     },
     getDelay(attempt, retryAfter) {
       if (retryAfter !== undefined)
@@ -1426,22 +1788,32 @@ function createRetryPolicy(maxRetries = 2) {
 }
 
 class REST {
-  #baseURL;
-  #timeout;
   #retryPolicy;
   #token;
-  #store;
-  #localQueues = new Map;
+  #limiter;
+  #scheduler = new RequestScheduler;
+  #transport;
+  #decoder = new ResponseDecoder;
   #hooks = {};
+  #concurrentBuckets;
   constructor(options = {}) {
     this.#token = options.token;
-    this.#timeout = Math.max(1, options.timeout ?? 15000);
     this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
-    this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
-    this.#store = options.store ?? new MemoryRateLimitStore;
+    this.#transport = options.transport ?? new HttpTransport({
+      baseURL: options.baseURL,
+      timeout: options.timeout
+    });
+    const store = options.store ?? new MemoryRateLimitStore;
+    this.#concurrentBuckets = (options.concurrentBuckets ?? false) && typeof store.reserve === "function";
+    this.#limiter = new RateLimiter(store, {
+      concurrent: this.#concurrentBuckets
+    });
     if (options.hooks)
       this.#hooks = options.hooks;
   }
+  get store() {
+    return this.#limiter.store;
+  }
   setHooks(hooks) {
     this.#hooks = hooks;
     return this;
@@ -1452,121 +1824,109 @@ class REST {
     this.#token = token;
   }
   async request(method, path, body, options = {}) {
-    const normalizedMethod = method.toUpperCase();
-    if (!normalizedMethod)
+    if (!method.toUpperCase())
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    const route = createRouteKey(method, path);
     const files = options.files;
     if (files && files.length > 0 && !(body instanceof FormData))
       body = this.#fileForm(body, files);
     const query = serializeQuery(options.query);
-    const finalPath = query ? `${path}${query}` : path;
-    const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    const major = majorParameter(path);
-    let bucketKey = scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
-    const queueKey = bucketKey;
-    const previous = this.#localQueues.get(queueKey) ?? Promise.resolve();
-    let release;
-    const gate = new Promise((resolve) => {
-      release = resolve;
-    });
-    this.#localQueues.set(queueKey, gate);
-    await this.#abortable(previous, options.signal, path);
-    try {
-      for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucketKey, options.signal, path);
-        await this.#waitGlobal(options.signal, path);
-        const controller = new AbortController;
-        const onAbort = () => controller.abort(options.signal?.reason);
-        if (options.signal?.aborted)
-          throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, {
-          once: true
+    const requestPath = query ? `${path}${query}` : path;
+    return this.#scheduler.runResolved(() => this.#limiter.resolveBucketKey(route.route, route.major), options.signal, path, (bucketKey, release) => this.#attempts(route, requestPath, body, options, bucketKey, release));
+  }
+  async#attempts(route, requestPath, body, options, initialBucketKey, release) {
+    const { method, path } = route;
+    let bucketKey = initialBucketKey;
+    for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
+      await this.#limiter.acquire(bucketKey, options.signal, path);
+      if (this.#concurrentBuckets) {
+        const bucket = await this.#limiter.store.getBucket(bucketKey);
+        if (bucket && bucket.resetAt > Date.now())
+          release();
+      }
+      this.#emit(this.#hooks.onRequest, { method, path, attempt });
+      const requestStart = Date.now();
+      let response;
+      try {
+        response = await this.#transport.send({
+          method,
+          path: requestPath,
+          headers: this.#headers(body, options),
+          body: this.#encodeBody(body),
+          signal: options.signal
         });
-        const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
-        const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
-        const headers = { ...options.headers };
-        if (options.auth !== false && this.#token)
-          headers["Authorization"] = `Bot ${this.#token}`;
-        headers["User-Agent"] = USER_AGENT;
-        if (options.reason !== undefined)
-          headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
-        if (!isFormData)
-          headers["Content-Type"] = "application/json";
-        const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
-        try {
-          this.#emit(this.#hooks.onRequest, {
-            method: normalizedMethod,
-            path,
-            attempt
-          });
-          const requestStart = Date.now();
-          const response = await fetch(`${this.#baseURL}${finalPath}`, {
-            method: normalizedMethod,
-            headers,
-            body: fetchBody,
-            signal: controller.signal
-          });
-          this.#emit(this.#hooks.onResponse, {
-            method: normalizedMethod,
-            path,
-            status: response.status,
-            durationMs: Date.now() - requestStart
-          });
-          bucketKey = await this.#update(response, bucketKey, route, major);
-          const payload = await this.#readPayload(response);
-          if (response.ok)
-            return response.status === 204 ? undefined : payload;
-          const data = this.#errorData(payload);
-          const retryAfter = response.status === 429 ? this.#retryAfter(response, data) : undefined;
-          if (data.global && retryAfter !== undefined) {
-            const currentGlobal = await this.#store.getGlobalReset();
-            await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
-          }
-          if (response.status === 429)
-            this.#emit(this.#hooks.onRateLimit, {
-              method: normalizedMethod,
-              path,
-              retryAfterMs: (retryAfter ?? 1) * 1000,
-              global: data.global ?? false,
-              bucket: await this.#store.getBucketHash(route)
-            });
-          if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
-            this.#emit(this.#hooks.onRetry, {
-              method: normalizedMethod,
-              path,
-              attempt,
-              status: response.status,
-              delayMs: delay
-            });
-            await this.#sleep(delay, options.signal, path);
-            continue;
-          }
-          throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method: normalizedMethod, path });
-        } catch (error) {
-          if (error instanceof RESTError)
-            throw error;
-          if (options.signal?.aborted)
-            throw this.#abortError(path, options.signal.reason);
-          const isTimeout = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
-          if (!isTimeout && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, 0)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt), options.signal, path);
-            continue;
-          }
-          throw new RESTError(isTimeout ? `Discord REST request timed out after ${this.#timeout}ms` : "Discord REST request failed", 0, undefined, undefined, { method: normalizedMethod, path, cause: error });
-        } finally {
-          clearTimeout(timer);
-          options.signal?.removeEventListener("abort", onAbort);
+      } catch (error) {
+        if (error instanceof RESTError)
+          throw error;
+        if (options.signal?.aborted)
+          throw abortError(path, options.signal.reason);
+        const failure = error instanceof TransportError ? error : new TransportError("Discord REST request failed", false, error);
+        if (!failure.timedOut && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, 0)) {
+          await sleep(this.#retryPolicy.getDelay(attempt), options.signal, path);
+          continue;
         }
+        throw new RESTError(failure.message, 0, undefined, undefined, {
+          method,
+          path,
+          cause: failure.cause ?? failure
+        });
       }
-      throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method: normalizedMethod, path });
-    } finally {
-      release();
-      if (this.#localQueues.get(queueKey) === gate)
-        this.#localQueues.delete(queueKey);
-    }
+      this.#emit(this.#hooks.onResponse, {
+        method,
+        path,
+        status: response.status,
+        durationMs: Date.now() - requestStart
+      });
+      bucketKey = await this.#limiter.applyResponse(response, bucketKey, route.route, route.major);
+      const payload = await this.#decoder.read(response);
+      if (response.ok)
+        return response.status === 204 ? undefined : payload;
+      const data = this.#decoder.errorData(payload);
+      const retryAfter = response.status === 429 ? this.#decoder.retryAfter(response, data) : undefined;
+      if (data.global && retryAfter !== undefined)
+        await this.#limiter.noteGlobalReset(Date.now() + retryAfter * 1000);
+      if (response.status === 429)
+        this.#emit(this.#hooks.onRateLimit, {
+          method,
+          path,
+          retryAfterMs: (retryAfter ?? 1) * 1000,
+          global: data.global ?? false,
+          bucket: await this.#limiter.store.getBucketHash(route.route)
+        });
+      if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, response.status)) {
+        const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
+        this.#emit(this.#hooks.onRetry, {
+          method,
+          path,
+          attempt,
+          status: response.status,
+          delayMs: delay
+        });
+        await sleep(delay, options.signal, path);
+        continue;
+      }
+      throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method, path });
+    }
+    throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method, path });
+  }
+  #headers(body, options) {
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    const headers = { ...options.headers };
+    if (options.auth !== false && this.#token)
+      headers["Authorization"] = `Bot ${this.#token}`;
+    headers["User-Agent"] = USER_AGENT;
+    if (options.reason !== undefined)
+      headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+    if (!isFormData)
+      headers["Content-Type"] = "application/json";
+    return headers;
+  }
+  #encodeBody(body) {
+    if (typeof FormData !== "undefined" && body instanceof FormData)
+      return body;
+    return body === undefined ? undefined : JSON.stringify(body);
   }
   #dispatch(method, path, bodyOrOptions, options) {
     if (options === undefined && isRequestData(bodyOrOptions))
@@ -1611,115 +1971,6 @@ class REST {
       return;
     Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
-  async#wait(bucketKey, signal, path) {
-    const bucket = await this.#store.getBucket(bucketKey);
-    if (!bucket)
-      return;
-    const delay = bucket.resetAt - Date.now();
-    if (bucket.remaining <= 0 && delay > 0)
-      await this.#sleep(delay, signal, path);
-  }
-  async#waitGlobal(signal, path) {
-    const globalResetAt = await this.#store.getGlobalReset();
-    const delay = globalResetAt - Date.now();
-    if (delay > 0)
-      await this.#sleep(delay, signal, path);
-  }
-  async#sleep(delay, signal, path) {
-    if (delay <= 0)
-      return;
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(resolve, delay);
-      const abort = () => {
-        clearTimeout(timer);
-        reject(this.#abortError(path, signal?.reason));
-      };
-      if (signal?.aborted)
-        return abort();
-      signal?.addEventListener("abort", abort, { once: true });
-    });
-  }
-  async#abortable(promise, signal, path) {
-    if (!signal)
-      return promise;
-    if (signal.aborted)
-      throw this.#abortError(path, signal.reason);
-    return Promise.race([
-      promise,
-      new Promise((_, reject) => signal.addEventListener("abort", () => reject(this.#abortError(path, signal.reason)), { once: true }))
-    ]);
-  }
-  #abortError(path, reason) {
-    return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
-  }
-  async#readPayload(response) {
-    if (response.status === 204)
-      return;
-    const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("application/json"))
-      return response.json().catch(() => {
-        return;
-      });
-    return response.text().catch(() => {
-      return;
-    });
-  }
-  #errorData(payload) {
-    if (!payload || typeof payload !== "object")
-      return {};
-    const data = payload;
-    return {
-      message: typeof data.message === "string" ? data.message : undefined,
-      code: typeof data.code === "number" ? data.code : undefined,
-      retry_after: typeof data.retry_after === "number" ? data.retry_after : undefined,
-      global: data.global === true
-    };
-  }
-  #retryAfter(response, data) {
-    const header = Number(response.headers.get("Retry-After"));
-    const retryAfter = data.retry_after ?? (Number.isFinite(header) ? header : 1);
-    return Math.max(0, retryAfter);
-  }
-  #normalizeRoute(path) {
-    const queryIndex = path.indexOf("?");
-    const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
-    return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
-  }
-  async#update(response, bucketKey, route, major) {
-    let currentKey = bucketKey;
-    const serverBucket = response.headers.get("X-RateLimit-Bucket");
-    if (serverBucket) {
-      await this.#store.setBucketHash(route, serverBucket);
-      currentKey = scopeBucket(serverBucket, major);
-    }
-    let bucket = await this.#store.getBucket(currentKey) ?? {
-      remaining: 1,
-      resetAt: 0
-    };
-    const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
-    const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
-    const reset = Number(response.headers.get("X-RateLimit-Reset"));
-    if (Number.isFinite(remaining))
-      bucket.remaining = Math.max(0, remaining);
-    if (Number.isFinite(resetAfter))
-      bucket.resetAt = Date.now() + Math.max(0, resetAfter) * 1000;
-    else if (Number.isFinite(reset))
-      bucket.resetAt = reset * 1000;
-    if (response.status === 429) {
-      const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
-    }
-    await this.#store.updateBucket(currentKey, bucket);
-    if (response.headers.get("X-RateLimit-Global") === "true") {
-      const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter)) {
-        const currentGlobal = await this.#store.getGlobalReset();
-        await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
-      }
-    }
-    return currentKey;
-  }
 }
 
 // packages/structures/src/base.ts
@@ -1841,6 +2092,18 @@ class Channel extends BaseStructure {
   update(options) {
     return this.edit(options);
   }
+  isThread() {
+    return this.type === 10 || this.type === 11 || this.type === 12;
+  }
+  isTextBased() {
+    return [0, 1, 2, 3, 5, 10, 11, 12, 13].includes(this.type);
+  }
+  isVoiceBased() {
+    return this.type === 2 || this.type === 13;
+  }
+  isDMBased() {
+    return this.type === 1 || this.type === 3;
+  }
   toString() {
     return `<#${this.id}>`;
   }
@@ -2137,7 +2400,9 @@ class Emoji extends BaseStructure {
   animated;
   available;
   constructor(data) {
-    super(data.id ?? "unicode");
+    super(data.id ?? "0");
+    if (data.id === null)
+      this.id = "unicode";
     this.name = data.name;
     this.roleIds = data.roles ?? [];
     this.user = data.user ? new User(data.user) : null;
@@ -2270,14 +2535,107 @@ class GuildOnboarding extends BaseStructure {
     this.mode = data.mode;
   }
 }
-// packages/structures/src/interactions.ts
-var InteractionType = {
-  Ping: 1,
-  ApplicationCommand: 2,
-  MessageComponent: 3,
-  ApplicationCommandAutocomplete: 4,
-  ModalSubmit: 5
-};
+// packages/structures/src/channels.ts
+class NewsChannel extends TextChannel {
+}
+
+class DMChannel extends Channel {
+  recipients;
+  ownerId;
+  constructor(data, context) {
+    super(data, context);
+    this.recipients = (data.recipients ?? []).map((u) => new User(u));
+    this.ownerId = data.owner_id ?? null;
+  }
+}
+
+class VoiceChannel extends Channel {
+  bitrate;
+  userLimit;
+  rtcRegion;
+  videoQualityMode;
+  constructor(data, context) {
+    super(data, context);
+    this.bitrate = data.bitrate ?? 64000;
+    this.userLimit = data.user_limit ?? 0;
+    this.rtcRegion = data.rtc_region ?? null;
+    this.videoQualityMode = data.video_quality_mode ?? 1;
+  }
+}
+
+class StageChannel extends VoiceChannel {
+}
+
+class CategoryChannel extends Channel {
+}
+
+class ThreadChannel extends Channel {
+  ownerId;
+  messageCount;
+  memberCount;
+  metadata;
+  constructor(data, context) {
+    super(data, context);
+    this.ownerId = data.owner_id ?? null;
+    this.messageCount = data.message_count ?? 0;
+    this.memberCount = data.member_count ?? 0;
+    this.metadata = data.thread_metadata ?? null;
+  }
+  get archived() {
+    return this.metadata?.archived ?? false;
+  }
+  get locked() {
+    return this.metadata?.locked ?? false;
+  }
+  get autoArchiveDuration() {
+    return this.metadata?.auto_archive_duration ?? null;
+  }
+}
+
+class ForumChannel extends Channel {
+  availableTags;
+  defaultReactionEmoji;
+  defaultThreadRateLimitPerUser;
+  defaultAutoArchiveDuration;
+  constructor(data, context) {
+    super(data, context);
+    this.availableTags = data.available_tags ?? [];
+    this.defaultReactionEmoji = data.default_reaction_emoji ?? null;
+    this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user ?? 0;
+    this.defaultAutoArchiveDuration = data.default_auto_archive_duration ?? null;
+  }
+}
+
+class MediaChannel extends ForumChannel {
+}
+function createChannel(data, context) {
+  switch (data.type) {
+    case 0:
+      return new TextChannel(data, context);
+    case 1:
+    case 3:
+      return new DMChannel(data, context);
+    case 2:
+      return new VoiceChannel(data, context);
+    case 4:
+      return new CategoryChannel(data, context);
+    case 5:
+      return new NewsChannel(data, context);
+    case 10:
+    case 11:
+    case 12:
+      return new ThreadChannel(data, context);
+    case 13:
+      return new StageChannel(data, context);
+    case 15:
+      return new ForumChannel(data, context);
+    case 16:
+      return new MediaChannel(data, context);
+    default:
+      return new Channel(data, context);
+  }
+}
+// packages/structures/src/options.ts
 var OptionType = {
   SubCommand: 1,
   SubCommandGroup: 2,
@@ -2333,6 +2691,12 @@ class CommandOptions {
     }
     return this.#subcommandGroup;
   }
+  getFocused(full = false) {
+    const focused = this.#options.find((o) => o.focused);
+    if (!focused)
+      throw new TypeError("No focused option was provided.");
+    return full ? focused : focused.value ?? "";
+  }
   getString(name, required = false) {
     const opt = this.#get(name);
     if (!opt || opt.type !== OptionType.String) {
@@ -2438,6 +2802,14 @@ class CommandOptions {
     return this.#options;
   }
 }
+// packages/structures/src/interactions.ts
+var InteractionType = {
+  Ping: 1,
+  ApplicationCommand: 2,
+  MessageComponent: 3,
+  ApplicationCommandAutocomplete: 4,
+  ModalSubmit: 5
+};
 
 class InteractionResponse {
   type;
@@ -2501,6 +2873,30 @@ class Interaction {
   isAutocomplete() {
     return this.type === InteractionType.ApplicationCommandAutocomplete;
   }
+  #componentType() {
+    return this.isMessageComponent() ? this.data.data?.component_type ?? 0 : 0;
+  }
+  isButton() {
+    return this.#componentType() === 2;
+  }
+  isStringSelectMenu() {
+    return this.#componentType() === 3;
+  }
+  isUserSelectMenu() {
+    return this.#componentType() === 5;
+  }
+  isRoleSelectMenu() {
+    return this.#componentType() === 6;
+  }
+  isMentionableSelectMenu() {
+    return this.#componentType() === 7;
+  }
+  isChannelSelectMenu() {
+    return this.#componentType() === 8;
+  }
+  isAnySelectMenu() {
+    return [3, 5, 6, 7, 8].includes(this.#componentType());
+  }
   assertUnacknowledged() {
     if (this.replied || this.deferred)
       throw new Error("Interaction has already been acknowledged.");
@@ -2611,6 +3007,11 @@ class ModalSubmitInteraction extends Interaction {
 }
 
 class AutocompleteInteraction extends Interaction {
+  options;
+  constructor(client, data) {
+    super(client, data);
+    this.options = new CommandOptions(data.data?.options ?? []);
+  }
   get commandName() {
     return this.data?.data?.name ?? "";
   }
@@ -3034,7 +3435,7 @@ class ThreadManager {
       auto_archive_duration: options.autoArchiveDuration,
       rate_limit_per_user: options.rateLimitPerUser
     });
-    return new Channel(data, this.#context);
+    return createChannel(data, this.#context);
   }
 }
 
@@ -3062,18 +3463,173 @@ class UserManager extends ResourceManager {
     });
   }
 }
-// packages/managers/src/guild.ts
+// packages/managers/src/guild-resources.ts
 function withQuery(path, params) {
+  const query = new URLSearchParams;
+  for (const [key, value] of Object.entries(params))
+    if (value !== undefined)
+      query.set(key, String(value));
+  const suffix = query.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildBanManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  async fetch(userId) {
+    const ban = await this.#rest.get(Routes.guildBan(this.guildId, userId));
+    this.set(ban.user.id, ban);
+    return ban;
+  }
+  async fetchAll(options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
+    const bans = await this.#rest.get(withQuery(Routes.guildBans(this.guildId), {
+      limit,
+      before: options.before,
+      after: options.after
+    }));
+    for (const ban of bans)
+      this.set(ban.user.id, ban);
+    return bans;
+  }
+  async create(userId, options = {}) {
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+  }
+  async remove(userId, reason) {
+    await this.#rest.delete(Routes.guildBan(this.guildId, userId), {
+      reason
+    });
+    this.delete(userId);
+  }
+}
+
+class GuildScheduledEventManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(event) {
+    this.set(event.id, event);
+    return event;
+  }
+  async fetch(eventId, options = {}) {
+    return this.#store(await this.#rest.get(withQuery(Routes.guildScheduledEvent(this.guildId, eventId), {
+      with_user_count: options.withUserCount
+    })));
+  }
+  async fetchAll(options = {}) {
+    const events = await this.#rest.get(withQuery(Routes.guildScheduledEvents(this.guildId), {
+      with_user_count: options.withUserCount
+    }));
+    return events.map((event) => this.#store(event));
+  }
+  async create(options, reason) {
+    return this.#store(await this.#rest.post(Routes.guildScheduledEvents(this.guildId), options, { reason }));
+  }
+  async edit(eventId, options, reason) {
+    return this.#store(await this.#rest.patch(Routes.guildScheduledEvent(this.guildId, eventId), options, { reason }));
+  }
+  async remove(eventId) {
+    await this.#rest.delete(Routes.guildScheduledEvent(this.guildId, eventId));
+    this.delete(eventId);
+  }
+  async fetchSubscribers(eventId, options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(100, Math.max(1, options.limit));
+    return this.#rest.get(withQuery(Routes.guildScheduledEventUsers(this.guildId, eventId), {
+      limit,
+      with_member: options.withMember,
+      before: options.before,
+      after: options.after
+    }));
+  }
+}
+
+class StageInstanceManager extends Manager {
+  #rest;
+  constructor(rest) {
+    super();
+    this.#rest = rest;
+  }
+  #store(stage) {
+    this.set(stage.channel_id, stage);
+    return stage;
+  }
+  async create(channelId, options, reason) {
+    return this.#store(await this.#rest.post(Routes.stageInstances(), {
+      channel_id: channelId,
+      topic: options.topic,
+      privacy_level: options.privacyLevel,
+      send_start_notification: options.sendStartNotification,
+      guild_scheduled_event_id: options.guildScheduledEventId
+    }, { reason }));
+  }
+  async fetch(channelId) {
+    return this.#store(await this.#rest.get(Routes.stageInstanceByChannel(channelId)));
+  }
+  async edit(channelId, options, reason) {
+    return this.#store(await this.#rest.patch(Routes.stageInstanceByChannel(channelId), { topic: options.topic, privacy_level: options.privacyLevel }, { reason }));
+  }
+  async remove(channelId, reason) {
+    await this.#rest.delete(Routes.stageInstanceByChannel(channelId), {
+      reason
+    });
+    this.delete(channelId);
+  }
+}
+
+class PermissionOverwriteManager {
+  #rest;
+  channelId;
+  constructor(rest, channelId) {
+    this.#rest = rest;
+    this.channelId = channelId;
+  }
+  async edit(overwriteId, options, reason) {
+    await this.#rest.put(Routes.channelPermission(this.channelId, overwriteId), {
+      type: options.type,
+      allow: BigInt(options.allow ?? 0).toString(),
+      deny: BigInt(options.deny ?? 0).toString()
+    }, { reason });
+  }
+  async remove(overwriteId, reason) {
+    await this.#rest.delete(Routes.channelPermission(this.channelId, overwriteId), { reason });
+  }
+}
+
+// packages/managers/src/guild.ts
+function withQuery2(path, params) {
   const suffix = params.toString();
   return suffix ? `${path}?${suffix}` : path;
 }
 
 class GuildManager extends ResourceManager {
   #rest;
+  #bans = new Map;
+  #scheduledEvents = new Map;
   constructor(rest) {
     super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
     this.#rest = rest;
   }
+  bans(guildId) {
+    let manager = this.#bans.get(guildId);
+    if (!manager)
+      this.#bans.set(guildId, manager = new GuildBanManager(this.#rest, guildId));
+    return manager;
+  }
+  scheduledEvents(guildId) {
+    let manager = this.#scheduledEvents.get(guildId);
+    if (!manager)
+      this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager(this.#rest, guildId));
+    return manager;
+  }
   async create(options) {
     const data = await this.#rest.post("/guilds", options);
     return this.upsert(new Guild(data));
@@ -3109,7 +3665,7 @@ class GuildManager extends ResourceManager {
       params.set("after", options.after);
     if (options.limit !== undefined)
       params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
-    return this.#rest.get(withQuery(Routes.guildAuditLog(guildId), params));
+    return this.#rest.get(withQuery2(Routes.guildAuditLog(guildId), params));
   }
   async fetchMembers(guildId, options = {}) {
     const params = new URLSearchParams;
@@ -3117,7 +3673,7 @@ class GuildManager extends ResourceManager {
       params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
     if (options.after)
       params.set("after", options.after);
-    return this.#rest.get(withQuery(Routes.guildMembers(guildId), params));
+    return this.#rest.get(withQuery2(Routes.guildMembers(guildId), params));
   }
   async fetchAutoModerationRules(guildId) {
     const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
@@ -3248,9 +3804,7 @@ class GuildMemberManager extends ResourceManager {
     this.delete(userId);
   }
   async ban(userId, options = {}) {
-    await this.#rest.put(Routes.guildBan(this.guildId, userId), {
-      delete_message_seconds: options.deleteMessageSeconds
-    });
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
     this.delete(userId);
   }
   async unban(userId) {
@@ -3382,6 +3936,9 @@ class ChannelManager extends Manager {
     }
     return manager;
   }
+  permissionOverwrites(channelId) {
+    return new PermissionOverwriteManager(this.#rest, channelId);
+  }
   threads(channelId) {
     return new ThreadManager(this.#rest, this.#context, channelId);
   }
@@ -3393,7 +3950,7 @@ class ChannelManager extends Manager {
   }
   upsert(data) {
     const existing = this.get(data.id);
-    const channel = new Channel(data, this.#context);
+    const channel = createChannel(data, this.#context);
     if (existing) {
       Object.assign(existing, channel);
       return existing;
@@ -3501,35 +4058,593 @@ class ChannelManager extends Manager {
   async unpinMessage(channelId, messageId) {
     await this.#rest.delete(Routes.channelPin(channelId, messageId));
   }
-  createThreadFromMessage(channelId, messageId, options) {
-    return this.threads(channelId).createFromMessage(messageId, options);
+  createThreadFromMessage(channelId, messageId, options) {
+    return this.threads(channelId).createFromMessage(messageId, options);
+  }
+  async fetchPage(channelId, options = {}) {
+    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+    const messages = await this.fetchMessages(channelId, {
+      ...options,
+      limit
+    });
+    return {
+      messages,
+      before: messages[0]?.id,
+      after: messages[messages.length - 1]?.id,
+      hasMore: messages.length === limit
+    };
+  }
+  async bulkDelete(channelId, messageIds) {
+    return this.bulkDeleteMessages(channelId, messageIds);
+  }
+  clear() {
+    this.#messageManagers.clear();
+    super.clear();
+  }
+}
+function isMessageQuery(value) {
+  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
+}
+
+// packages/ws/src/session.ts
+class GatewaySession {
+  #state = { status: "none" };
+  #sequence = null;
+  #generation = 0;
+  #lastInvalidation;
+  get lastInvalidation() {
+    return this.#lastInvalidation;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  get sessionId() {
+    return this.#state.status === "established" ? this.#state.sessionId : undefined;
+  }
+  get resumeURL() {
+    return this.#state.status === "established" ? this.#state.resumeURL : undefined;
+  }
+  get sequence() {
+    return this.#sequence;
+  }
+  get canResume() {
+    return this.#state.status === "established" && this.#sequence !== null;
+  }
+  beginConnection() {
+    return ++this.#generation;
+  }
+  owns(token) {
+    return token === this.#generation;
+  }
+  recordSequence(sequence, token) {
+    if (!this.owns(token))
+      return false;
+    if (!Number.isInteger(sequence))
+      return false;
+    this.#sequence = sequence;
+    return true;
+  }
+  activate(payload, token) {
+    if (!this.owns(token))
+      return false;
+    const ready = payload;
+    if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string")
+      return false;
+    this.#state = {
+      status: "established",
+      sessionId: ready.session_id,
+      resumeURL: ready.resume_gateway_url
+    };
+    return true;
+  }
+  invalidate(token, reason = "explicit") {
+    if (!this.owns(token))
+      return false;
+    this.#lastInvalidation = reason;
+    this.#state = { status: "none" };
+    this.#sequence = null;
+    return true;
+  }
+  resumeInfo() {
+    if (this.#state.status !== "established")
+      return;
+    if (this.#sequence === null)
+      return;
+    const { sessionId, resumeURL } = this.#state;
+    return { sessionId, sequence: this.#sequence, resumeURL };
+  }
+  handshake() {
+    const resume = this.resumeInfo();
+    return resume ? { type: "resume", ...resume } : { type: "identify" };
+  }
+  connectURL(fallback) {
+    return this.resumeInfo()?.resumeURL ?? fallback;
+  }
+}
+
+// packages/ws/src/heartbeat.ts
+var MAX_MONITOR_INTERVAL = 1000;
+
+class GatewayHeartbeat {
+  #options;
+  #now;
+  #interval = 0;
+  #acknowledged = true;
+  #sentAt = 0;
+  #latency = -1;
+  #lastMessageAt = 0;
+  #zombieReported = false;
+  #timer;
+  #initialTimer;
+  #ackTimer;
+  #monitorTimer;
+  constructor(options) {
+    if (options.zombieTimeout <= options.ackTimeout)
+      throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
+    this.#options = options;
+    this.#now = options.now ?? (() => Date.now());
+  }
+  get latency() {
+    return this.#latency;
+  }
+  get interval() {
+    return this.#interval;
+  }
+  get acknowledged() {
+    return this.#acknowledged;
+  }
+  get silentFor() {
+    return this.#lastMessageAt === 0 ? 0 : this.#now() - this.#lastMessageAt;
+  }
+  get stalenessDeadline() {
+    return Math.max(this.#options.zombieTimeout, this.#interval + this.#options.ackTimeout);
+  }
+  isHealthy() {
+    if (!this.#acknowledged)
+      return false;
+    if (this.#lastMessageAt === 0)
+      return true;
+    return this.silentFor < this.stalenessDeadline;
+  }
+  watch() {
+    this.#lastMessageAt = this.#now();
+    this.#zombieReported = false;
+    this.#startMonitor();
+  }
+  receivedMessage() {
+    this.#lastMessageAt = this.#now();
+    this.#zombieReported = false;
+  }
+  start(interval) {
+    this.#clearBeatTimers();
+    this.#interval = interval;
+    this.#acknowledged = true;
+    this.#initialTimer = setTimeout(() => this.sendHeartbeat(), Math.random() * interval);
+    this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+  }
+  stop() {
+    this.#clearBeatTimers();
+    if (this.#monitorTimer)
+      clearInterval(this.#monitorTimer);
+    this.#monitorTimer = undefined;
+  }
+  sendHeartbeat() {
+    this.#acknowledged = false;
+    this.#sentAt = this.#now();
+    if (!this.#options.send(this.#options.sequence())) {
+      this.#options.onError(new Error("Unable to send Gateway heartbeat because the WebSocket is not open."));
+      return;
+    }
+    this.#clearAckTimer();
+    this.#ackTimer = setTimeout(() => {
+      if (this.#acknowledged)
+        return;
+      this.#options.onTimeout({
+        type: "ack",
+        elapsedMs: this.#now() - this.#sentAt
+      });
+    }, this.#options.ackTimeout);
+  }
+  acknowledge() {
+    this.#acknowledged = true;
+    this.#latency = this.#now() - this.#sentAt;
+    this.#clearAckTimer();
+  }
+  #startMonitor() {
+    if (this.#monitorTimer)
+      clearInterval(this.#monitorTimer);
+    const interval = Math.max(1, Math.min(MAX_MONITOR_INTERVAL, this.#options.ackTimeout, this.#options.zombieTimeout / 2));
+    this.#monitorTimer = setInterval(() => this.#checkStaleness(), interval);
+  }
+  #checkStaleness() {
+    if (!this.#options.isConnected() || this.#lastMessageAt === 0)
+      return;
+    const silentFor = this.silentFor;
+    const deadline = this.stalenessDeadline;
+    if (silentFor < deadline || this.#zombieReported)
+      return;
+    this.#zombieReported = true;
+    this.#options.onTimeout({ type: "zombie", silentFor, deadline });
+  }
+  #clearAckTimer() {
+    if (this.#ackTimer)
+      clearTimeout(this.#ackTimer);
+    this.#ackTimer = undefined;
+  }
+  #clearBeatTimers() {
+    if (this.#timer)
+      clearInterval(this.#timer);
+    if (this.#initialTimer)
+      clearTimeout(this.#initialTimer);
+    this.#clearAckTimer();
+    this.#timer = undefined;
+    this.#initialTimer = undefined;
+  }
+}
+
+// packages/ws/src/close-codes.ts
+var GatewayCloseCodes = {
+  UnknownError: 4000,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSeq: 4007,
+  RateLimited: 4008,
+  SessionTimedOut: 4009,
+  InvalidShard: 4010,
+  ShardingRequired: 4011,
+  InvalidAPIVersion: 4012,
+  InvalidIntents: 4013,
+  DisallowedIntents: 4014
+};
+
+// packages/ws/src/reconnect.ts
+var FATAL_CLOSE_CODES = [
+  GatewayCloseCodes.AuthenticationFailed,
+  GatewayCloseCodes.InvalidShard,
+  GatewayCloseCodes.ShardingRequired,
+  GatewayCloseCodes.InvalidAPIVersion,
+  GatewayCloseCodes.InvalidIntents,
+  GatewayCloseCodes.DisallowedIntents
+];
+var IDENTIFY_CLOSE_CODES = [
+  GatewayCloseCodes.InvalidSeq,
+  GatewayCloseCodes.SessionTimedOut
+];
+function classifyCloseCode(code, canResume) {
+  if (FATAL_CLOSE_CODES.includes(code))
+    return "stop";
+  if (IDENTIFY_CLOSE_CODES.includes(code))
+    return "identify";
+  return canResume ? "resume" : "identify";
+}
+
+class GatewayReconnect {
+  #options;
+  #random;
+  #attempt = 0;
+  #timer;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(options) {
+    this.#options = options;
+    this.#random = options.random ?? Math.random;
+  }
+  get enabled() {
+    return this.#options.enabled;
+  }
+  get attempts() {
+    return this.#attempt;
+  }
+  get pending() {
+    return this.#timer !== undefined;
+  }
+  get exhausted() {
+    return this.#attempt >= this.#options.maxAttempts;
+  }
+  get connecting() {
+    return this.#promise !== undefined;
+  }
+  get attemptPromise() {
+    return this.#promise;
+  }
+  classifyClose(code, canResume) {
+    return classifyCloseCode(code, canResume);
+  }
+  canReconnect() {
+    return this.#options.enabled && !this.exhausted;
+  }
+  schedule(run) {
+    if (!this.#options.enabled)
+      return { scheduled: false, reason: "disabled" };
+    if (this.#timer)
+      return { scheduled: false, reason: "pending" };
+    if (this.exhausted)
+      return { scheduled: false, reason: "exhausted" };
+    const attempt = this.#attempt;
+    const delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
+    const jitter = this.#random() * Math.max(1, delay * 0.25);
+    const delayMs = delay + jitter;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      run();
+    }, delayMs);
+    return { scheduled: true, delayMs, attempt };
+  }
+  cancel() {
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+  }
+  reset() {
+    this.#attempt = 0;
+  }
+  attempt(start) {
+    if (this.#promise)
+      return this.#promise;
+    this.#promise = new Promise((resolve, reject) => {
+      this.#resolve = resolve;
+      this.#reject = reject;
+      start();
+    });
+    return this.#promise;
+  }
+  settle(error) {
+    const resolve = this.#resolve;
+    const reject = this.#reject;
+    this.#resolve = undefined;
+    this.#reject = undefined;
+    this.#promise = undefined;
+    if (error)
+      reject?.(error);
+    else
+      resolve?.();
+  }
+}
+
+// packages/ws/src/decoder.ts
+import {
+  createInflate,
+  constants as zlibConstants
+} from "zlib";
+async function toBytes(data) {
+  if (data instanceof Uint8Array)
+    return data;
+  if (data instanceof ArrayBuffer)
+    return new Uint8Array(data);
+  if (typeof Blob !== "undefined" && data instanceof Blob)
+    return new Uint8Array(await data.arrayBuffer());
+  throw new TypeError("Gateway returned an unsupported compressed frame type.");
+}
+
+class PlainTextDecoder {
+  push(data) {
+    return [String(data)];
+  }
+  reset() {}
+}
+
+class ZlibStreamDecoder {
+  #create;
+  #inflate;
+  #chunks = [];
+  #failure;
+  #pendingReject;
+  constructor(create = () => createInflate()) {
+    this.#create = create;
+  }
+  push(data) {
+    if (typeof data === "string")
+      return [data];
+    return this.#inflateFrame(data);
+  }
+  async#inflateFrame(data) {
+    const chunk = await toBytes(data);
+    const inflate = this.#inflate ??= this.#open();
+    if (this.#failure)
+      throw this.#failure;
+    const complete = chunk.length >= 4 && chunk[chunk.length - 4] === 0 && chunk[chunk.length - 3] === 0 && chunk[chunk.length - 2] === 255 && chunk[chunk.length - 1] === 255;
+    await this.#awaiting((settle) => inflate.write(chunk, (error) => error ? settle(error) : settle()));
+    if (!complete)
+      return [];
+    await this.#awaiting((settle) => inflate.flush(zlibConstants.Z_SYNC_FLUSH, () => settle()));
+    const parts = this.#chunks;
+    this.#chunks = [];
+    if (parts.length === 0)
+      return [];
+    const total = parts.reduce((size, part) => size + part.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+      merged.set(part, offset);
+      offset += part.length;
+    }
+    return [new TextDecoder().decode(merged)];
+  }
+  reset() {
+    const inflate = this.#inflate;
+    this.#inflate = undefined;
+    this.#chunks = [];
+    this.#failure = undefined;
+    this.#pendingReject = undefined;
+    if (!inflate)
+      return;
+    inflate.removeAllListeners();
+    try {
+      inflate.close();
+    } catch {}
+  }
+  #awaiting(run) {
+    if (this.#failure)
+      return Promise.reject(this.#failure);
+    return new Promise((resolve, reject) => {
+      this.#pendingReject = reject;
+      run((error) => {
+        this.#pendingReject = undefined;
+        if (error)
+          reject(error);
+        else if (this.#failure)
+          reject(this.#failure);
+        else
+          resolve();
+      });
+    });
+  }
+  #open() {
+    const inflate = this.#create();
+    inflate.on("data", (chunk) => this.#chunks.push(chunk));
+    inflate.on("error", (error) => {
+      this.#failure = error;
+      const reject = this.#pendingReject;
+      this.#pendingReject = undefined;
+      reject?.(error);
+    });
+    return inflate;
+  }
+}
+function createDecoder(compress) {
+  return compress ? new ZlibStreamDecoder : new PlainTextDecoder;
+}
+
+// packages/ws/src/transport.ts
+var OPEN = 1;
+
+class WebSocketTransport {
+  #handlers;
+  #decoder;
+  #createSocket;
+  #compress;
+  #socket;
+  #generation = 0;
+  #queue = Promise.resolve();
+  constructor(options) {
+    this.#handlers = options.handlers;
+    this.#compress = options.compress ?? false;
+    this.#decoder = options.decoder ?? createDecoder(options.compress);
+    this.#createSocket = options.createSocket ?? ((url) => new WebSocket(url));
+  }
+  get connected() {
+    return this.#socket?.readyState === OPEN;
+  }
+  get live() {
+    return this.#socket !== undefined && this.#socket.readyState <= OPEN;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  connect(url) {
+    this.#discard(1000, "Superseded by a new connection");
+    const generation = ++this.#generation;
+    this.#decoder.reset();
+    this.#queue = Promise.resolve();
+    let socket;
+    try {
+      socket = this.#createSocket(url);
+    } catch (error) {
+      return { ok: false, error: this.#asError(error) };
+    }
+    if (this.#compress) {
+      try {
+        socket.binaryType = "arraybuffer";
+      } catch {}
+    }
+    this.#socket = socket;
+    socket.addEventListener("open", () => {
+      if (!this.#owns(generation))
+        return;
+      this.#handlers.onOpen();
+    });
+    socket.addEventListener("message", (event) => {
+      if (!this.#owns(generation))
+        return;
+      let decoded;
+      try {
+        decoded = this.#decoder.push(event.data);
+      } catch (error) {
+        this.#handlers.onError(this.#asError(error));
+        return;
+      }
+      if (!(decoded instanceof Promise)) {
+        for (const frame of decoded)
+          this.#handlers.onFrame(frame);
+        return;
+      }
+      this.#queue = this.#queue.then(async () => {
+        const frames = await decoded;
+        if (!this.#owns(generation))
+          return;
+        for (const frame of frames)
+          this.#handlers.onFrame(frame);
+      }).catch((error) => {
+        if (!this.#owns(generation))
+          return;
+        this.#handlers.onError(this.#asError(error));
+      });
+    });
+    socket.addEventListener("close", (event) => {
+      if (!this.#owns(generation))
+        return;
+      this.#socket = undefined;
+      this.#generation++;
+      this.#decoder.reset();
+      this.#handlers.onClose(event.code, event.reason ?? "");
+    });
+    socket.addEventListener("error", () => {
+      if (!this.#owns(generation))
+        return;
+      this.#handlers.onError(new Error("Gateway WebSocket error"));
+    });
+    return { ok: true };
+  }
+  send(data) {
+    if (!this.connected)
+      return false;
+    try {
+      this.#socket.send(data);
+      return true;
+    } catch (error) {
+      this.#handlers.onError(this.#asError(error));
+      return false;
+    }
+  }
+  close(code = 1000, reason = "") {
+    const socket = this.#socket;
+    if (!socket)
+      return;
+    try {
+      socket.close(code, reason);
+    } catch (error) {
+      this.#handlers.onError(this.#asError(error));
+    }
+  }
+  destroy(code = 1000, reason = "") {
+    this.#discard(code, reason);
+    this.#decoder.reset();
   }
-  async fetchPage(channelId, options = {}) {
-    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
-    const messages = await this.fetchMessages(channelId, {
-      ...options,
-      limit
-    });
-    return {
-      messages,
-      before: messages[0]?.id,
-      after: messages[messages.length - 1]?.id,
-      hasMore: messages.length === limit
-    };
+  #owns(generation) {
+    return generation === this.#generation;
   }
-  async bulkDelete(channelId, messageIds) {
-    return this.bulkDeleteMessages(channelId, messageIds);
+  #discard(code, reason) {
+    const socket = this.#socket;
+    if (!socket)
+      return;
+    this.#generation++;
+    this.#socket = undefined;
+    try {
+      socket.close(code, reason);
+    } catch (error) {
+      this.#handlers.onError(this.#asError(error));
+    }
   }
-  clear() {
-    this.#messageManagers.clear();
-    super.clear();
+  #asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
   }
 }
-function isMessageQuery(value) {
-  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
-}
 
-// packages/ws/src/index.ts
+// packages/ws/src/opcodes.ts
 var GatewayOpcodes = {
   Dispatch: 0,
   Heartbeat: 1,
@@ -3543,33 +4658,142 @@ var GatewayOpcodes = {
   Hello: 10,
   HeartbeatAck: 11
 };
-var GatewayCloseCodes = {
-  UnknownError: 4000,
-  UnknownOpcode: 4001,
-  DecodeError: 4002,
-  NotAuthenticated: 4003,
-  AuthenticationFailed: 4004,
-  AlreadyAuthenticated: 4005,
-  InvalidSeq: 4007,
-  RateLimited: 4008,
-  SessionTimedOut: 4009,
-  InvalidShard: 4010,
-  ShardingRequired: 4011,
-  InvalidAPIVersion: 4012,
-  InvalidIntents: 4013,
-  DisallowedIntents: 4014
-};
+
+// packages/ws/src/protocol.ts
+function classifyFrame(raw) {
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (error) {
+    return {
+      sequence: null,
+      action: {
+        type: "invalid",
+        violation: "invalid-json",
+        message: "Gateway returned invalid JSON",
+        cause: error
+      }
+    };
+  }
+  return classifyPayload(payload);
+}
+function classifyPayload(payload) {
+  if (payload === null || typeof payload !== "object" || typeof payload.op !== "number")
+    return {
+      sequence: null,
+      action: {
+        type: "invalid",
+        violation: "invalid-payload",
+        message: "Gateway returned an invalid payload"
+      }
+    };
+  const frame = payload;
+  const sequence = typeof frame.s === "number" ? frame.s : null;
+  switch (frame.op) {
+    case GatewayOpcodes.Dispatch:
+      return {
+        sequence,
+        action: {
+          type: "dispatch",
+          event: typeof frame.t === "string" ? frame.t : null,
+          data: frame.d
+        }
+      };
+    case GatewayOpcodes.Hello: {
+      const interval = frame.d?.heartbeat_interval;
+      if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0)
+        return {
+          sequence,
+          action: {
+            type: "invalid",
+            violation: "invalid-hello",
+            message: "Gateway HELLO payload contains an invalid heartbeat interval"
+          }
+        };
+      return {
+        sequence,
+        action: { type: "hello", heartbeatInterval: interval }
+      };
+    }
+    case GatewayOpcodes.Heartbeat:
+      return { sequence, action: { type: "heartbeat" } };
+    case GatewayOpcodes.HeartbeatAck:
+      return {
+        sequence,
+        action: { type: "heartbeat-ack", data: frame.d }
+      };
+    case GatewayOpcodes.Reconnect:
+      return { sequence, action: { type: "reconnect" } };
+    case GatewayOpcodes.InvalidSession:
+      return {
+        sequence,
+        action: {
+          type: "invalid-session",
+          resumable: frame.d === true
+        }
+      };
+    default:
+      return { sequence, action: { type: "unknown", opcode: frame.op } };
+  }
+}
+function identifyPayload(options) {
+  const props = options.properties ?? {};
+  const os = props.os ?? "Android";
+  const browser = props.browser ?? "Discord Android";
+  const device = props.device ?? "Discord Android";
+  return {
+    op: GatewayOpcodes.Identify,
+    d: {
+      token: options.token,
+      intents: options.intents,
+      properties: {
+        os,
+        browser,
+        device,
+        $os: os,
+        $browser: browser,
+        $device: device,
+        ...props
+      },
+      presence: {
+        since: options.presence?.since ?? null,
+        activities: options.presence?.activities ?? [],
+        status: options.presence?.status ?? "online",
+        afk: Boolean(options.presence?.afk)
+      },
+      shard: [options.shardId, options.shardCount]
+    },
+    s: null,
+    t: null
+  };
+}
+function resumePayload(token, resume) {
+  return {
+    op: GatewayOpcodes.Resume,
+    d: {
+      token,
+      session_id: resume.sessionId,
+      seq: resume.sequence
+    },
+    s: null,
+    t: null
+  };
+}
+function heartbeatPayload(sequence) {
+  return { op: GatewayOpcodes.Heartbeat, d: sequence, s: null, t: null };
+}
+// packages/ws/src/state.ts
 var GatewayState;
-((GatewayState2) => {
-  GatewayState2["Connect"] = "CONNECT";
-  GatewayState2["Hello"] = "HELLO";
-  GatewayState2["Identify"] = "IDENTIFY";
-  GatewayState2["Resume"] = "RESUME";
-  GatewayState2["Ready"] = "READY";
-  GatewayState2["Dispatch"] = "DISPATCH";
-  GatewayState2["Heartbeat"] = "HEARTBEAT";
-  GatewayState2["Reconnect"] = "RECONNECT";
-  GatewayState2["Closed"] = "CLOSED";
+((GatewayState) => {
+  GatewayState["Connect"] = "CONNECT";
+  GatewayState["Hello"] = "HELLO";
+  GatewayState["Identify"] = "IDENTIFY";
+  GatewayState["Resume"] = "RESUME";
+  GatewayState["Ready"] = "READY";
+  GatewayState["Dispatch"] = "DISPATCH";
+  GatewayState["Heartbeat"] = "HEARTBEAT";
+  GatewayState["Reconnect"] = "RECONNECT";
+  GatewayState["Closed"] = "CLOSED";
 })(GatewayState ||= {});
 class GatewayError extends Error {
   code;
@@ -3579,33 +4803,43 @@ class GatewayError extends Error {
     this.code = code;
   }
 }
+// packages/ws/src/send-budget.ts
+class SendBudget {
+  #timestamps = [];
+  #limit;
+  #windowMs;
+  constructor(limit = 115, windowMs = 60000) {
+    this.#limit = limit;
+    this.#windowMs = windowMs;
+  }
+  get used() {
+    return this.#timestamps.length;
+  }
+  allows(privileged, now = Date.now()) {
+    while (this.#timestamps.length && now - this.#timestamps[0] >= this.#windowMs)
+      this.#timestamps.shift();
+    return privileged || this.#timestamps.length < this.#limit;
+  }
+  record(now = Date.now()) {
+    this.#timestamps.push(now);
+  }
+}
+
+// packages/ws/src/index.ts
+var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
 
 class Gateway {
   state = "CONNECT" /* Connect */;
   #options;
-  #ws;
-  #sequence = null;
-  #sessionId;
-  #resumeURL;
-  #heartbeatTimer;
-  #initialHeartbeat;
-  #heartbeatAckTimer;
-  #heartbeatACK = true;
-  #heartbeatInterval = 0;
-  #heartbeatSentAt = 0;
-  #lastMessageAt = 0;
-  #zombieTimer;
-  #zombieReported = false;
+  #transport;
+  #session = new GatewaySession;
+  #token = 0;
+  #heartbeat;
   #closed = false;
-  #attempt = 0;
-  #reconnectTimer;
-  #connectPromise;
-  #resolveConnect;
-  #rejectConnect;
+  #reconnect;
   #listeners = new Map;
-  #sendTimestamps = [];
+  #sendBudget = new SendBudget;
   ping = -1;
-  #decompressor;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Gateway token is required.");
@@ -3632,41 +4866,72 @@ class Gateway {
         afk: false,
         since: null
       },
-      ...options
+      ...options,
+      intents: resolvedIntents
     };
     if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
       throw new RangeError("Gateway shardId must be within the configured shard count.");
     if (this.#options.zombieTimeout <= this.#options.heartbeatAckTimeout)
       throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
+    this.#transport = new WebSocketTransport({
+      compress: this.#options.compress,
+      createSocket: options.createSocket,
+      handlers: {
+        onOpen: () => this.#onOpen(),
+        onFrame: (raw) => this.#message(raw, this.#token),
+        onClose: (code) => this.#close(code, this.#token),
+        onError: (error) => this.#emitError(error instanceof GatewayError ? error : new GatewayError(error.message, undefined, {
+          cause: error
+        }))
+      }
+    });
+    this.#reconnect = new GatewayReconnect({
+      enabled: this.#options.reconnect,
+      maxAttempts: this.#options.maxReconnectAttempts,
+      baseDelay: this.#options.reconnectBaseDelay,
+      maxDelay: this.#options.reconnectMaxDelay
+    });
+    this.#heartbeat = new GatewayHeartbeat({
+      ackTimeout: this.#options.heartbeatAckTimeout,
+      zombieTimeout: this.#options.zombieTimeout,
+      send: (sequence) => this.#dispatch(heartbeatPayload(sequence), true),
+      sequence: () => this.#session.sequence,
+      isConnected: () => !this.#closed && this.#transport.connected,
+      onTimeout: (timeout) => this.#onHeartbeatTimeout(timeout),
+      onError: (error) => this.#emitError(error)
+    });
+  }
+  #onHeartbeatTimeout(timeout) {
+    if (timeout.type === "zombie") {
+      this.#emit("zombie", {
+        silentFor: timeout.silentFor,
+        timeout: timeout.deadline
+      });
+      this.#emitError(new GatewayError(`Gateway connection appears stale after ${timeout.silentFor}ms without traffic.`));
+    } else {
+      this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${timeout.elapsedMs}ms.`));
+    }
+    this.#transport.close(1001, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
   }
-  connect(url = "wss://gateway.discord.gg/?v=10&encoding=json") {
+  connect(url = DEFAULT_GATEWAY_URL) {
     if (this.state === "CLOSED" /* Closed */)
       throw new GatewayError("Gateway has been permanently closed.");
-    if (this.#connectPromise)
-      return this.#connectPromise;
+    const inFlight = this.#reconnect.attemptPromise;
+    if (inFlight)
+      return inFlight;
+    if (this.#transport.live)
+      return Promise.resolve();
+    this.#reconnect.cancel();
     this.#closed = false;
     this.#setState("CONNECT" /* Connect */);
     const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}&compress=zlib-stream` : url;
-    if (this.#options.compress)
-      this.#initDecompressor();
-    this.#connectPromise = new Promise((resolve, reject) => {
-      this.#resolveConnect = resolve;
-      this.#rejectConnect = reject;
-      this.#open(connectURL);
-    });
-    return this.#connectPromise;
+    return this.#reconnect.attempt(() => this.#open(connectURL));
   }
   close() {
     this.#closed = true;
     this.#clearTimers();
     this.#settleConnect(new GatewayError("Gateway connection closed before socket open."));
-    const ws = this.#ws;
-    this.#ws = undefined;
-    try {
-      ws?.close(1000, "Client closed connection");
-    } catch (error) {
-      this.#emitError(error);
-    }
+    this.#transport.destroy(1000, "Client closed connection");
     this.#setState("CLOSED" /* Closed */);
   }
   emit(event, data) {
@@ -3691,23 +4956,17 @@ class Gateway {
     return this.#dispatch(payload, false);
   }
   #dispatch(payload, privileged) {
-    if (this.#ws?.readyState !== WebSocket.OPEN)
+    if (!this.#transport.connected)
       return false;
     const now = Date.now();
-    while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
-      this.#sendTimestamps.shift();
-    if (!privileged && this.#sendTimestamps.length >= 115) {
+    if (!this.#sendBudget.allows(privileged, now)) {
       this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
       return false;
     }
-    try {
-      this.#ws.send(JSON.stringify(payload));
-      this.#sendTimestamps.push(now);
-      return true;
-    } catch (error) {
-      this.#emitError(error);
+    if (!this.#transport.send(JSON.stringify(payload)))
       return false;
-    }
+    this.#sendBudget.record(now);
+    return true;
   }
   setPresence(data) {
     this.#options.presence = { ...this.#options.presence, ...data };
@@ -3743,127 +5002,80 @@ class Gateway {
   #open(url) {
     if (this.#closed)
       return;
-    let ws;
-    try {
-      ws = new WebSocket(url);
-    } catch (error) {
-      const failure = this.#normalizeError(error);
-      this.#emitError(failure);
-      if (this.#options.reconnect) {
-        this.#setState("RECONNECT" /* Reconnect */);
-        this.#scheduleReconnect();
-      } else
-        this.#settleConnect(failure);
+    this.#token = this.#session.beginConnection();
+    const result = this.#transport.connect(url);
+    if (result.ok)
       return;
+    const failure = this.#normalizeError(result.error);
+    this.#emitError(failure);
+    if (this.#options.reconnect) {
+      this.#setState("RECONNECT" /* Reconnect */);
+      this.#scheduleReconnect();
+    } else {
+      this.#settleConnect(failure);
     }
-    this.#ws = ws;
-    ws.addEventListener("open", () => {
-      this.#lastMessageAt = Date.now();
-      this.#zombieReported = false;
-      this.#startZombieDetection();
-      this.#emit("open", undefined);
-      this.#settleConnect();
-    });
-    ws.addEventListener("message", (event) => {
-      this.#lastMessageAt = Date.now();
-      this.#zombieReported = false;
-      if (this.#options.compress && event.data instanceof ArrayBuffer) {
-        this.#decompress(new Uint8Array(event.data)).then((text) => this.#message(ws, text)).catch((err) => this.#emitError(err));
-      } else {
-        this.#message(ws, String(event.data));
-      }
-    });
-    ws.addEventListener("close", (event) => this.#close(ws, event.code));
-    ws.addEventListener("error", () => this.#emitError(new GatewayError("Gateway WebSocket error")));
-  }
-  #startZombieDetection() {
-    if (this.#zombieTimer)
-      clearInterval(this.#zombieTimer);
-    const interval = Math.max(1, Math.min(1000, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
-    this.#zombieTimer = setInterval(() => {
-      if (this.#closed || this.#ws?.readyState !== WebSocket.OPEN || this.#lastMessageAt === 0)
-        return;
-      const silentFor = Date.now() - this.#lastMessageAt;
-      const deadline = Math.max(this.#options.zombieTimeout, this.#heartbeatInterval + this.#options.heartbeatAckTimeout);
-      if (silentFor < deadline || this.#zombieReported)
-        return;
-      this.#zombieReported = true;
-      const error = new GatewayError(`Gateway connection appears stale after ${silentFor}ms without traffic.`);
-      this.#emit("zombie", { silentFor, timeout: deadline });
-      this.#emitError(error);
-      try {
-        this.#ws.close(1001, "Zombie Gateway connection");
-      } catch (closeError) {
-        this.#emitError(closeError);
-      }
-    }, interval);
   }
-  #message(ws, raw) {
-    let payload;
-    try {
-      payload = JSON.parse(raw);
-    } catch (error) {
-      this.#emitError(new GatewayError("Gateway returned invalid JSON", undefined, {
-        cause: error
-      }));
-      ws.close(1002, "Invalid JSON");
-      return;
-    }
-    if (!payload || typeof payload.op !== "number") {
-      this.#emitError(new GatewayError("Gateway returned an invalid payload"));
-      ws.close(1002, "Invalid payload");
+  #onOpen() {
+    this.#heartbeat.watch();
+    this.#emit("open", undefined);
+    this.#settleConnect();
+  }
+  #message(raw, token) {
+    if (!this.#session.owns(token))
       return;
-    }
-    if (typeof payload.s === "number")
-      this.#sequence = payload.s;
-    switch (payload.op) {
-      case GatewayOpcodes.Dispatch:
+    const { sequence, action } = classifyFrame(raw);
+    if (sequence !== null)
+      this.#session.recordSequence(sequence, token);
+    this.#apply(action, token);
+  }
+  #apply(action, token) {
+    switch (action.type) {
+      case "dispatch":
         this.#setState("DISPATCH" /* Dispatch */);
-        this.#handleDispatch(payload.t, payload.d);
-        break;
-      case GatewayOpcodes.Hello:
-        this.#handleHello(payload.d);
-        break;
-      case GatewayOpcodes.Heartbeat:
+        this.#handleDispatch(action.event, action.data, token);
+        return;
+      case "hello":
+        this.#handleHello(action.heartbeatInterval);
+        return;
+      case "heartbeat":
         this.#setState("HEARTBEAT" /* Heartbeat */);
-        this.#sendHeartbeat();
-        break;
-      case GatewayOpcodes.HeartbeatAck:
-        this.#heartbeatACK = true;
-        this.ping = Date.now() - this.#heartbeatSentAt;
-        this.#clearHeartbeatAckTimer();
-        this.#emit("heartbeatAck", payload.d);
-        break;
-      case GatewayOpcodes.Reconnect:
-        ws.close(1001, "Server requested reconnect");
-        break;
-      case GatewayOpcodes.InvalidSession: {
-        const resumable = payload.d === true;
-        if (!resumable) {
-          this.#sessionId = undefined;
-          this.#sequence = null;
-          this.#resumeURL = undefined;
-        }
-        this.#emit("invalidSession", resumable);
-        ws.close(resumable ? GatewayCloseCodes.UnknownError : 1000, resumable ? "Invalid session (resumable)" : "Invalid session");
-        break;
+        this.#heartbeat.sendHeartbeat();
+        return;
+      case "heartbeat-ack":
+        this.#heartbeat.acknowledge();
+        this.ping = this.#heartbeat.latency;
+        this.#emit("heartbeatAck", action.data);
+        return;
+      case "reconnect":
+        this.#transport.close(1001, "Server requested reconnect");
+        return;
+      case "invalid-session": {
+        if (!action.resumable)
+          this.#session.invalidate(token, "invalid-session");
+        this.#emit("invalidSession", action.resumable);
+        this.#transport.close(action.resumable ? GatewayCloseCodes.UnknownError : 1000, action.resumable ? "Invalid session (resumable)" : "Invalid session");
+        return;
       }
+      case "invalid":
+        this.#emitError(new GatewayError(action.message, undefined, action.cause === undefined ? undefined : { cause: action.cause }));
+        this.#transport.close(1002, action.violation === "invalid-json" ? "Invalid JSON" : action.violation === "invalid-hello" ? "Invalid heartbeat interval" : "Invalid payload");
+        return;
+      case "unknown":
+        return;
     }
   }
-  #handleDispatch(event, data) {
+  #handleDispatch(event, data, token) {
     if (event === "READY") {
-      const ready = data;
-      if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string") {
-        this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
+      if (!this.#session.activate(data, token)) {
+        if (this.#session.owns(token))
+          this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
         return;
       }
-      this.#sessionId = ready.session_id;
-      this.#resumeURL = ready.resume_gateway_url;
-      this.#attempt = 0;
+      this.#reconnect.reset();
       this.#setState("READY" /* Ready */);
       this.#emit("ready", data);
     } else if (event === "RESUMED") {
-      this.#attempt = 0;
+      this.#reconnect.reset();
       this.#setState("READY" /* Ready */);
       this.#emit("resumed", data);
     }
@@ -3872,183 +5084,60 @@ class Gateway {
       return;
     this.#emit(event ?? "dispatch", data);
   }
-  #handleHello(data) {
-    const interval = data?.heartbeat_interval;
-    if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0) {
-      this.#emitError(new GatewayError("Gateway HELLO payload contains an invalid heartbeat interval"));
-      this.#ws?.close(1002, "Invalid heartbeat interval");
-      return;
-    }
-    this.#heartbeatInterval = interval;
-    this.#setState(this.#sessionId && this.#sequence !== null && this.#resumeURL ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
-    this.#startHeartbeat(interval);
+  #handleHello(interval) {
+    this.#setState(this.#session.canResume ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
+    this.#heartbeat.start(interval);
     this.#identifyOrResume();
   }
   #identifyOrResume() {
-    if (this.#sessionId && this.#sequence !== null && this.#resumeURL) {
+    const intent = this.#session.handshake();
+    if (intent.type === "resume") {
       this.#setState("RESUME" /* Resume */);
-      this.send({
-        op: GatewayOpcodes.Resume,
-        d: {
-          token: this.#options.token,
-          session_id: this.#sessionId,
-          seq: this.#sequence
-        },
-        s: null,
-        t: null
-      });
+      this.#dispatch(resumePayload(this.#options.token, intent), true);
       return;
     }
     this.#setState("IDENTIFY" /* Identify */);
-    const props = this.#options.properties ?? {
-      os: "Android",
-      browser: "Discord Android",
-      device: "Discord Android"
-    };
-    const os = props.os ?? "Android";
-    const browser = props.browser ?? "Discord Android";
-    const device = props.device ?? "Discord Android";
-    this.send({
-      op: GatewayOpcodes.Identify,
-      d: {
-        token: this.#options.token,
-        intents: this.#options.intents,
-        properties: {
-          os,
-          browser,
-          device,
-          $os: os,
-          $browser: browser,
-          $device: device,
-          ...props
-        },
-        presence: {
-          since: this.#options.presence?.since ?? null,
-          activities: this.#options.presence?.activities ?? [],
-          status: this.#options.presence?.status ?? "online",
-          afk: Boolean(this.#options.presence?.afk)
-        },
-        shard: [this.#options.shardId, this.#options.shardCount]
-      },
-      s: null,
-      t: null
-    });
-  }
-  #startHeartbeat(interval) {
-    this.#clearHeartbeatTimers();
-    this.#heartbeatACK = true;
-    this.#initialHeartbeat = setTimeout(() => this.#sendHeartbeat(), Math.random() * interval);
-    this.#heartbeatTimer = setInterval(() => this.#sendHeartbeat(), interval);
-  }
-  #sendHeartbeat() {
-    this.#heartbeatACK = false;
-    this.#heartbeatSentAt = Date.now();
-    if (!this.#dispatch({
-      op: GatewayOpcodes.Heartbeat,
-      d: this.#sequence,
-      s: null,
-      t: null
-    }, true)) {
-      this.#emitError(new GatewayError("Unable to send Gateway heartbeat because the WebSocket is not open."));
-      return;
-    }
-    this.#clearHeartbeatAckTimer();
-    this.#heartbeatAckTimer = setTimeout(() => {
-      if (!this.#heartbeatACK) {
-        const elapsed = Date.now() - this.#heartbeatSentAt;
-        this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${elapsed}ms.`));
-        try {
-          this.#ws?.close(1001, "Heartbeat timeout");
-        } catch (error) {
-          this.#emitError(error);
-        }
-      }
-    }, this.#options.heartbeatAckTimeout);
+    this.#dispatch(identifyPayload({
+      token: this.#options.token,
+      intents: this.#options.intents,
+      shardId: this.#options.shardId,
+      shardCount: this.#options.shardCount,
+      properties: this.#options.properties,
+      presence: this.#options.presence
+    }), true);
   }
-  #close(ws, code) {
-    if (this.#ws !== ws)
-      return;
-    this.#ws = undefined;
+  #close(code, token) {
     this.#clearTimers();
-    const action = this.#closeAction(code);
+    const action = this.#reconnect.classifyClose(code, this.#session.canResume);
     this.#emit("close", { code, action });
-    if (this.#closed || !this.#options.reconnect || action === "stop") {
+    if (this.#closed || !this.#reconnect.enabled || action === "stop") {
+      if (action === "stop")
+        this.#closed = true;
       this.#setState(this.#closed ? "CLOSED" /* Closed */ : "CONNECT" /* Connect */);
-      if (this.#connectPromise)
-        this.#settleConnect(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
+      if (this.#reconnect.connecting)
+        this.#reconnect.settle(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
       return;
     }
-    if (action === "identify") {
-      this.#sequence = null;
-      this.#sessionId = undefined;
-      this.#resumeURL = undefined;
-    }
+    if (action === "identify")
+      this.#session.invalidate(token, "session-timeout");
     this.#setState("RECONNECT" /* Reconnect */);
     this.#scheduleReconnect();
   }
-  #closeAction(code) {
-    const fatal = [
-      GatewayCloseCodes.AuthenticationFailed,
-      GatewayCloseCodes.InvalidShard,
-      GatewayCloseCodes.ShardingRequired,
-      GatewayCloseCodes.InvalidAPIVersion,
-      GatewayCloseCodes.InvalidIntents,
-      GatewayCloseCodes.DisallowedIntents
-    ];
-    if (fatal.includes(code))
-      return "stop";
-    if (code === GatewayCloseCodes.InvalidSeq || code === GatewayCloseCodes.SessionTimedOut)
-      return "identify";
-    return this.#sessionId && this.#sequence !== null ? "resume" : "identify";
-  }
   #scheduleReconnect() {
-    if (this.#closed || !this.#options.reconnect || this.#reconnectTimer)
+    if (this.#closed)
       return;
-    if (this.#attempt >= this.#options.maxReconnectAttempts) {
-      this.#settleConnect(new GatewayError("Gateway reconnect attempts exhausted."));
-      this.#setState("CONNECT" /* Connect */);
+    const result = this.#reconnect.schedule(() => this.#open(this.#session.connectURL(DEFAULT_GATEWAY_URL)));
+    if (result.scheduled || result.reason !== "exhausted")
       return;
-    }
-    const delay = Math.min(this.#options.reconnectMaxDelay, this.#options.reconnectBaseDelay * 2 ** this.#attempt++);
-    const jitter = Math.random() * Math.max(1, delay * 0.25);
-    this.#reconnectTimer = setTimeout(() => {
-      this.#reconnectTimer = undefined;
-      this.#open(this.#resumeURL ?? "wss://gateway.discord.gg/?v=10&encoding=json");
-    }, delay + jitter);
+    this.#reconnect.settle(new GatewayError("Gateway reconnect attempts exhausted."));
+    this.#setState("CONNECT" /* Connect */);
   }
   #settleConnect(error) {
-    const resolve = this.#resolveConnect;
-    const reject = this.#rejectConnect;
-    this.#resolveConnect = undefined;
-    this.#rejectConnect = undefined;
-    this.#connectPromise = undefined;
-    if (error)
-      reject?.(error);
-    else
-      resolve?.();
-  }
-  #clearHeartbeatAckTimer() {
-    if (this.#heartbeatAckTimer)
-      clearTimeout(this.#heartbeatAckTimer);
-    this.#heartbeatAckTimer = undefined;
-  }
-  #clearHeartbeatTimers() {
-    if (this.#heartbeatTimer)
-      clearInterval(this.#heartbeatTimer);
-    if (this.#initialHeartbeat)
-      clearTimeout(this.#initialHeartbeat);
-    this.#clearHeartbeatAckTimer();
-    this.#heartbeatTimer = undefined;
-    this.#initialHeartbeat = undefined;
+    this.#reconnect.settle(error);
   }
   #clearTimers() {
-    if (this.#reconnectTimer)
-      clearTimeout(this.#reconnectTimer);
-    if (this.#zombieTimer)
-      clearInterval(this.#zombieTimer);
-    this.#reconnectTimer = undefined;
-    this.#zombieTimer = undefined;
-    this.#clearHeartbeatTimers();
+    this.#reconnect.cancel();
+    this.#heartbeat.stop();
   }
   #normalizeError(error) {
     return error instanceof GatewayError ? error : new GatewayError("Gateway connection failed.", undefined, {
@@ -4080,37 +5169,6 @@ class Gateway {
     this.state = next;
     this.#emit("stateChange", { previous, next });
   }
-  #initDecompressor() {
-    const ds = new DecompressionStream("deflate-raw");
-    this.#decompressor = {
-      writer: ds.writable.getWriter(),
-      reader: ds.readable.getReader()
-    };
-  }
-  async#decompress(chunk) {
-    if (!this.#decompressor)
-      this.#initDecompressor();
-    const { writer, reader } = this.#decompressor;
-    await writer.write(chunk);
-    const parts = [];
-    while (true) {
-      const { done, value } = await Promise.race([
-        reader.read(),
-        new Promise((resolve) => setTimeout(() => resolve({ done: true, value: undefined }), 50))
-      ]);
-      if (done || !value)
-        break;
-      parts.push(value);
-    }
-    const total = parts.reduce((n, p) => n + p.length, 0);
-    const merged = new Uint8Array(total);
-    let offset = 0;
-    for (const p of parts) {
-      merged.set(p, offset);
-      offset += p.length;
-    }
-    return new TextDecoder().decode(merged);
-  }
 }
 
 // packages/core/src/index.ts
@@ -4181,6 +5239,7 @@ class Client extends EventEmitter2 {
   users;
   guilds;
   channels;
+  stageInstances;
   application;
   get ws() {
     return this.#gateway;
@@ -4223,14 +5282,15 @@ class Client extends EventEmitter2 {
     this.users = new UserManager(this.rest);
     this.guilds = new GuildManager(this.rest);
     this.channels = new ChannelManager(this.rest);
+    this.stageInstances = new StageInstanceManager(this.rest);
     const placeholderAppCommands = new ApplicationCommandManager(this.rest, "0");
     this.application = { commands: placeholderAppCommands };
     this.#resourceContext = {
-      sendMessage: (channelId, options2) => this.channels.send(channelId, options2),
-      editMessage: (channelId, messageId, options2) => this.channels.editMessage(channelId, messageId, options2),
+      sendMessage: (channelId, options) => this.channels.send(channelId, options),
+      editMessage: (channelId, messageId, options) => this.channels.editMessage(channelId, messageId, options),
       deleteMessage: (channelId, messageId) => this.channels.deleteMessage(channelId, messageId),
       crosspostMessage: (channelId, messageId) => this.channels.crosspostMessage(channelId, messageId),
-      editChannel: (channelId, options2) => this.channels.edit(channelId, options2),
+      editChannel: (channelId, options) => this.channels.edit(channelId, options),
       deleteChannel: (channelId) => this.channels.deleteChannel(channelId),
       addReaction: (channelId, messageId, emoji) => this.channels.addReaction(channelId, messageId, emoji),
       removeOwnReaction: (channelId, messageId, emoji) => this.channels.removeOwnReaction(channelId, messageId, emoji),
@@ -4302,7 +5362,7 @@ class Client extends EventEmitter2 {
         ...payload.channels ?? [],
         ...payload.threads ?? []
       ])
-        this.channels.set(channelData.id, new Channel(channelData, this.#resourceContext));
+        this.channels.set(channelData.id, createChannel(channelData, this.#resourceContext));
       this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
     });
     this.#gateway.on("GUILD_UPDATE", (data) => {
@@ -4349,12 +5409,12 @@ class Client extends EventEmitter2 {
     this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, data));
     this.#gateway.on("AUTO_MODERATION_ACTION_EXECUTION", (data) => this.emit("autoModerationActionExecution" /* AutoModerationActionExecution */, data));
     this.#gateway.on("CHANNEL_CREATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("channelCreate" /* ChannelCreate */, channel);
     });
     this.#gateway.on("CHANNEL_UPDATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("channelUpdate" /* ChannelUpdate */, channel);
     });
@@ -4365,12 +5425,12 @@ class Client extends EventEmitter2 {
     });
     this.#gateway.on("CHANNEL_PINS_UPDATE", (data) => this.emit("channelPinsUpdate" /* ChannelPinsUpdate */, data));
     this.#gateway.on("THREAD_CREATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("threadCreate" /* ThreadCreate */, channel);
     });
     this.#gateway.on("THREAD_UPDATE", (data) => {
-      const channel = new Channel(data, this.#resourceContext);
+      const channel = createChannel(data, this.#resourceContext);
       this.channels.update(channel);
       this.emit("threadUpdate" /* ThreadUpdate */, channel);
     });
@@ -4450,7 +5510,7 @@ class Client extends EventEmitter2 {
     if (options?.guildScheduledEventId)
       query.set("guild_scheduled_event_id", options.guildScheduledEventId);
     const qs = query.toString();
-    return this.rest.get(`/invites/${code}${qs ? `?${qs}` : ""}`);
+    return this.rest.get(`/invites/${encodeURIComponent(code)}${qs ? `?${qs}` : ""}`);
   }
   fetchSticker(id) {
     return this.rest.get(`/stickers/${id}`);
@@ -4459,14 +5519,14 @@ class Client extends EventEmitter2 {
     return this.rest.get(`/sticker-packs`);
   }
   fetchGuildTemplate(code) {
-    return this.rest.get(`/guilds/templates/${code}`);
+    return this.rest.get(`/guilds/templates/${encodeURIComponent(code)}`);
   }
   generateInvite(options) {
     if (!this.user)
       throw new Error("Client must be ready to generate invite.");
     const params = new URLSearchParams({
       client_id: this.user.id,
-      scopes: (options?.scopes ?? ["bot"]).join(" ")
+      scope: (options?.scopes ?? ["bot"]).join(" ")
     });
     if (options?.permissions) {
       params.set("permissions", String(options.permissions));
@@ -4588,13 +5648,17 @@ class HandlerRegistry {
   }
 }
 // packages/sharding/src/bus.ts
+var REPLY_TYPE = "__lunibee:reply";
+
 class ShardBus {
   #channel;
   #handlers = new Map;
+  #errorHandlers = new Set;
   #shardId;
   #namespace;
   channelName;
   #counter = 0;
+  #pending = new Map;
   constructor(shardId, channelName) {
     if (!Number.isInteger(shardId) || shardId < 0)
       throw new RangeError("Shard ID must be a non-negative integer.");
@@ -4619,6 +5683,16 @@ class ShardBus {
     this.#handlers.get(type)?.delete(handler);
     return this;
   }
+  onError(handler) {
+    if (typeof handler !== "function")
+      throw new TypeError("Shard bus error handler is required.");
+    this.#errorHandlers.add(handler);
+    return this;
+  }
+  offError(handler) {
+    this.#errorHandlers.delete(handler);
+    return this;
+  }
   send(target, type, data) {
     if (!Number.isInteger(target) || target < 0)
       throw new RangeError("Shard target must be a non-negative integer.");
@@ -4627,11 +5701,56 @@ class ShardBus {
   broadcast(type, data) {
     return this.#publish(null, type, data);
   }
+  respond(type, handler) {
+    return this.on(type, async (message) => {
+      if (!message.expectsReply)
+        return;
+      const reply = { requestId: message.id };
+      try {
+        reply.result = await handler(message.data, message);
+      } catch (error) {
+        reply.error = error instanceof Error ? error.message : String(error);
+      }
+      this.#publish(message.source, REPLY_TYPE, reply);
+    });
+  }
+  async request(target, type, data, timeoutMs = 5000) {
+    if (!Number.isInteger(target) || target < 0)
+      throw new RangeError("Shard target must be a non-negative integer.");
+    const [reply] = await this.#collect(target, type, data, timeoutMs, 1);
+    if (!reply)
+      throw new Error(`Shard ${target} did not reply to "${type}" within ${timeoutMs}ms.`);
+    if (reply.error !== undefined)
+      throw new Error(reply.error);
+    return reply.result;
+  }
+  broadcastRequest(type, data, options = {}) {
+    return this.#collect(null, type, data, options.timeoutMs ?? 5000, options.expected ?? Number.POSITIVE_INFINITY);
+  }
+  #collect(target, type, data, timeoutMs, expected) {
+    const replies = [];
+    return new Promise((resolve) => {
+      let requestId = "";
+      const finish = () => {
+        clearTimeout(timer);
+        this.#pending.delete(requestId);
+        resolve(replies);
+      };
+      const timer = setTimeout(finish, timeoutMs);
+      requestId = this.#publish(target, type, data, true);
+      this.#pending.set(requestId, (reply) => {
+        replies.push(reply);
+        if (replies.length >= expected)
+          finish();
+      });
+    });
+  }
   close() {
     this.#channel.close();
     this.#handlers.clear();
+    this.#errorHandlers.clear();
   }
-  #publish(target, type, data) {
+  #publish(target, type, data, expectsReply = false) {
     if (!type.trim())
       throw new TypeError("Shard message type is required.");
     const id = `${this.#namespace}:${this.#shardId}:${++this.#counter}`;
@@ -4640,7 +5759,8 @@ class ShardBus {
       target,
       type,
       data,
-      id
+      id,
+      ...expectsReply ? { expectsReply } : {}
     });
     return id;
   }
@@ -4649,13 +5769,28 @@ class ShardBus {
       return;
     if (message.source === this.#shardId || message.target !== null && message.target !== this.#shardId)
       return;
+    if (message.type === REPLY_TYPE) {
+      const reply = message.data;
+      this.#pending.get(reply?.requestId)?.({
+        shardId: message.source,
+        ...reply.error !== undefined ? { error: reply.error } : { result: reply.result }
+      });
+      return;
+    }
     for (const handler of this.#handlers.get(message.type) ?? []) {
       try {
         const result = handler(message);
         if (result && typeof result.then === "function")
-          Promise.resolve(result).catch(() => {
-            return;
-          });
+          Promise.resolve(result).catch((error) => this.#reportError(error, message));
+      } catch (error) {
+        this.#reportError(error, message);
+      }
+    }
+  }
+  #reportError(error, message) {
+    for (const handler of this.#errorHandlers) {
+      try {
+        handler(error, message);
       } catch {}
     }
   }
@@ -4663,7 +5798,7 @@ class ShardBus {
 // packages/sharding/src/cluster.ts
 import { fork } from "child_process";
 import { cpus } from "os";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 class ClusterManager {
   clusters = new Map;
@@ -4672,6 +5807,8 @@ class ClusterManager {
   #auto;
   #autoScaleTimer;
   #spawned = false;
+  #stopping = false;
+  #restartTimers = new Set;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
@@ -4716,20 +5853,8 @@ class ClusterManager {
     for (let i = 0;i < clusterCount; i++) {
       if (chunks[i].length === 0)
         continue;
-      const child = fork(this.#options.script, [], {
-        env: {
-          ...process.env,
-          SHARD_LIST: chunks[i].join(","),
-          SHARD_COUNT: count.toString(),
-          CLUSTER_ID: i.toString()
-        }
-      });
-      this.clusters.set(i, {
-        id: i,
-        process: child,
-        shards: chunks[i]
-      });
-      await sleep(500);
+      this.#launch(i, chunks[i], count);
+      await sleep2(500);
     }
     if (this.#options.autoScaleInterval && this.#options.autoScaleInterval > 0) {
       this.#autoScaleTimer = setInterval(() => {
@@ -4737,6 +5862,37 @@ class ClusterManager {
       }, this.#options.autoScaleInterval);
     }
   }
+  #launch(id, shards, shardCount) {
+    const child = fork(this.#options.script, [], {
+      env: {
+        ...process.env,
+        SHARD_LIST: shards.join(","),
+        SHARD_COUNT: shardCount.toString(),
+        CLUSTER_ID: id.toString()
+      }
+    });
+    const info = { id, process: child, shards };
+    this.clusters.set(id, info);
+    child.once("exit", (code, signal) => {
+      if (this.clusters.get(id)?.process !== child)
+        return;
+      try {
+        this.#options.onClusterExit?.(info, code, signal);
+      } catch {}
+      if (this.#stopping || this.#options.restartOnExit === false)
+        return;
+      this.clusters.delete(id);
+      const timer = setTimeout(() => {
+        this.#restartTimers.delete(timer);
+        if (this.#stopping || !this.#spawned)
+          return;
+        this.#launch(id, shards, shardCount);
+      }, this.#options.restartDelay ?? 5000);
+      timer.unref?.();
+      this.#restartTimers.add(timer);
+    });
+    return info;
+  }
   async checkAutoScale() {
     if (!this.#auto)
       return;
@@ -4757,6 +5913,8 @@ class ClusterManager {
     await this.spawn();
   }
   async shutdownAll(timeoutMs = this.#options.shutdownTimeout ?? 5000) {
+    this.#stopping = true;
+    this.#clearRestartTimers();
     if (this.#autoScaleTimer) {
       clearInterval(this.#autoScaleTimer);
       this.#autoScaleTimer = undefined;
@@ -4764,6 +5922,12 @@ class ClusterManager {
     await Promise.all([...this.clusters.values()].map((cluster) => this.#shutdownCluster(cluster, timeoutMs)));
     this.clusters.clear();
     this.#spawned = false;
+    this.#stopping = false;
+  }
+  #clearRestartTimers() {
+    for (const timer of this.#restartTimers)
+      clearTimeout(timer);
+    this.#restartTimers.clear();
   }
   async#shutdownCluster(cluster, timeoutMs) {
     const child = cluster.process;
@@ -4792,6 +5956,8 @@ class ClusterManager {
     });
   }
   killAll() {
+    this.#stopping = true;
+    this.#clearRestartTimers();
     if (this.#autoScaleTimer) {
       clearInterval(this.#autoScaleTimer);
       this.#autoScaleTimer = undefined;
@@ -4803,13 +5969,15 @@ class ClusterManager {
     }
     this.clusters.clear();
     this.#spawned = false;
+    this.#stopping = false;
   }
 }
 
 // packages/sharding/src/index.ts
-var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 class ShardManager {
+  static IDENTIFY_INTERVAL = 5000;
   shards = new Map;
   get shardCount() {
     return this.shards.size;
@@ -4829,8 +5997,13 @@ class ShardManager {
       throw new RangeError("Shard count must be a positive integer.");
     if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000))
       throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
+    if (options.spawnDelay !== undefined && (!Number.isFinite(options.spawnDelay) || options.spawnDelay < 0))
+      throw new RangeError("spawnDelay must be a non-negative finite number of milliseconds.");
     this.#auto = options.shardCount === "auto";
-    this.#options = { ...options };
+    this.#options = {
+      spawnDelay: ShardManager.IDENTIFY_INTERVAL,
+      ...options
+    };
     if (options.shardCount !== "auto")
       this.#initialize(count);
   }
@@ -4864,7 +6037,7 @@ class ShardManager {
         });
       }
       if (id + 1 < this.shardCount && this.#options.spawnDelay && this.#options.spawnDelay > 0)
-        await sleep2(this.#options.spawnDelay);
+        await sleep3(this.#options.spawnDelay);
     }
     if (this.#options.autoScaleInterval && !this.#autoScaleTimer) {
       this.#autoScaleTimer = setInterval(() => {
@@ -4936,7 +6109,7 @@ class ShardManager {
   }
 }
 // packages/utils/src/index.ts
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function randomInt(min, max) {
@@ -4947,11 +6120,11 @@ function isSnowflake(value) {
 }
 // packages/voice/src/index.ts
 var VoiceConnectionState;
-((VoiceConnectionState2) => {
-  VoiceConnectionState2["Disconnected"] = "disconnected";
-  VoiceConnectionState2["Connecting"] = "connecting";
-  VoiceConnectionState2["Connected"] = "connected";
-  VoiceConnectionState2["Destroyed"] = "destroyed";
+((VoiceConnectionState) => {
+  VoiceConnectionState["Disconnected"] = "disconnected";
+  VoiceConnectionState["Connecting"] = "connecting";
+  VoiceConnectionState["Connected"] = "connected";
+  VoiceConnectionState["Destroyed"] = "destroyed";
 })(VoiceConnectionState ||= {});
 
 class VoiceError extends Error {
@@ -5293,6 +6466,52 @@ class VoiceReceiver {
     }
   }
 }
+var voiceConnections = new Map;
+function joinVoiceChannel(options) {
+  let connection = voiceConnections.get(options.guildId);
+  if (!connection) {
+    connection = new VoiceConnection(options);
+    const created = connection;
+    created.on("stateChange", (next) => {
+      if (next === "destroyed" /* Destroyed */ && voiceConnections.get(created.guildId) === created)
+        voiceConnections.delete(created.guildId);
+    });
+    voiceConnections.set(options.guildId, connection);
+  }
+  connection.setChannel(options.channelId);
+  connection.setSuppression(options);
+  connection.connect();
+  return connection;
+}
+function getVoiceConnection(guildId) {
+  return voiceConnections.get(guildId);
+}
+function createAudioPlayer() {
+  return new AudioPlayer;
+}
+function createAudioResource(stream, metadata) {
+  return new AudioStream(stream, metadata);
+}
+function entersState(target, status, timeoutMs) {
+  if (target.state === status)
+    return Promise.resolve(target);
+  const emitter = target;
+  const isConnection = target instanceof VoiceConnection;
+  return new Promise((resolve, reject) => {
+    const onChange = (first, second) => {
+      if ((isConnection ? first : second) !== status)
+        return;
+      clearTimeout(timer);
+      emitter.off("stateChange", onChange);
+      resolve(target);
+    };
+    const timer = setTimeout(() => {
+      emitter.off("stateChange", onChange);
+      reject(new VoiceError(`Did not enter state "${String(status)}" within ${timeoutMs}ms.`));
+    }, timeoutMs);
+    emitter.on("stateChange", onChange);
+  });
+}
 // packages/builders/src/embed.ts
 class EmbedBuilder {
   #data = {};
@@ -5531,9 +6750,9 @@ class ButtonBuilder {
   }
   setURL(value) {
     validateText(value, 512, "Button URL");
-    let url2;
+    let url;
     try {
-      url2 = new URL(value);
+      url = new URL(value);
     } catch (error) {
       throw new TypeError("Button URL must be a valid URL.", {
         cause: error
@@ -5541,7 +6760,7 @@ class ButtonBuilder {
     }
     this.#data.style = ButtonStyle.Link;
     delete this.#data.custom_id;
-    this.#data.url = url2.toString();
+    this.#data.url = url.toString();
     return this;
   }
   setEmoji(emoji) {
@@ -5698,8 +6917,8 @@ class ContainerBuilder {
     this.#accentColor = color;
     return this;
   }
-  setSpoiler(spoiler2 = true) {
-    this.#spoiler = spoiler2;
+  setSpoiler(spoiler = true) {
+    this.#spoiler = spoiler;
     return this;
   }
   toJSON() {
@@ -5775,13 +6994,13 @@ class MediaGalleryBuilder {
 class FileComponentBuilder {
   #url = "";
   #spoiler;
-  setUrl(url2) {
-    validateText(url2, 2048, "File component URL");
-    this.#url = url2;
+  setUrl(url) {
+    validateText(url, 2048, "File component URL");
+    this.#url = url;
     return this;
   }
-  setSpoiler(spoiler2 = true) {
-    this.#spoiler = spoiler2;
+  setSpoiler(spoiler = true) {
+    this.#spoiler = spoiler;
     return this;
   }
   toJSON() {
@@ -5824,9 +7043,9 @@ class ThumbnailBuilder {
   #url = "";
   #description;
   #spoiler;
-  setUrl(url2) {
-    validateText(url2, 2048, "Thumbnail URL");
-    this.#url = url2;
+  setUrl(url) {
+    validateText(url, 2048, "Thumbnail URL");
+    this.#url = url;
     return this;
   }
   setDescription(description) {
@@ -5834,8 +7053,8 @@ class ThumbnailBuilder {
     this.#description = description;
     return this;
   }
-  setSpoiler(spoiler2 = true) {
-    this.#spoiler = spoiler2;
+  setSpoiler(spoiler = true) {
+    this.#spoiler = spoiler;
     return this;
   }
   toJSON() {
@@ -5881,6 +7100,29 @@ function validateLength(value, field, max = 4000) {
   if (!Number.isInteger(value) || value < 0 || value > max)
     throw new RangeError(`${field} must be an integer between 0 and ${max}.`);
 }
+class UserSelectMenuBuilder extends EntitySelectBuilder {
+  constructor() {
+    super(ComponentType.UserSelect);
+  }
+}
+
+class RoleSelectMenuBuilder extends EntitySelectBuilder {
+  constructor() {
+    super(ComponentType.RoleSelect);
+  }
+}
+
+class MentionableSelectMenuBuilder extends EntitySelectBuilder {
+  constructor() {
+    super(ComponentType.MentionableSelect);
+  }
+}
+
+class ChannelSelectMenuBuilder extends EntitySelectBuilder {
+  constructor() {
+    super(ComponentType.ChannelSelect);
+  }
+}
 // packages/builders/src/commands.ts
 var ApplicationCommandOptionType2 = {
   Subcommand: 1,
@@ -6239,9 +7481,15 @@ function validateNumberRange(value, minimum, maximum, field, integerOnly = true)
 
 class ContextMenuCommandBuilder {
   data;
-  constructor(type) {
+  constructor(type = 2) {
     this.data = { type };
   }
+  setType(type) {
+    if (type !== 2 && type !== 3)
+      throw new RangeError("Context menu command type must be 2 or 3.");
+    this.data.type = type;
+    return this;
+  }
   setName(name) {
     if (typeof name !== "string" || name.trim().length < 1 || name.length > 32)
       throw new RangeError("Command name must contain 1-32 characters.");
@@ -6343,9 +7591,12 @@ export {
   ButtonBuilder,
   ButtonStyle,
   Cache,
+  ResourceManager as CachedManager,
+  CategoryChannel,
   Channel,
   ChannelManager,
   ChannelOptionBuilder,
+  ChannelSelectMenuBuilder,
   ChannelType,
   Client,
   ClientEvent,
@@ -6358,113 +7609,165 @@ export {
   ComponentType,
   ContainerBuilder,
   ContentInventoryEntryBuilder,
+  ContextMenuCommandBuilder,
+  DMChannel,
   RESTError as DiscordAPIError,
   Embed,
   EmbedBuilder,
   Emoji,
   EmojiManager,
   EntitySelectBuilder,
+  ClientEvent as Events,
+  FATAL_CLOSE_CODES,
   FileComponentBuilder,
+  ForumChannel,
   Gateway,
   GatewayCloseCodes,
   GatewayError,
+  GatewayHeartbeat,
   GatewayIntentBits,
   GatewayOpcodes,
+  GatewayReconnect,
+  GatewaySession,
   GatewayState,
   Guild,
+  GuildBanManager,
   GuildManager,
   GuildMember,
   GuildMemberManager,
   GuildOnboarding,
+  GuildScheduledEventManager,
   GuildWelcomeScreen,
   HandlerRegistry,
+  HttpTransport,
+  IDENTIFY_CLOSE_CODES,
   IntegerOptionBuilder,
   IntentBits,
   Intents,
+  IntentsBitField,
   Interaction,
   InteractionResponse,
   InteractionResponseType,
   InteractionType,
   Invite,
   Manager,
+  MediaChannel,
   MediaGalleryBuilder,
   MemoryRateLimitStore,
   MentionableOptionBuilder,
+  MentionableSelectMenuBuilder,
   Message,
   MessageCommandBuilder,
   MessageFlags,
   MessageManager,
   ModalBuilder,
   ModalSubmitInteraction,
+  NewsChannel,
   NumberOptionBuilder,
   OnboardingPrompt,
   OnboardingPromptOption,
   Permission,
   PermissionFlagsBits,
+  PermissionOverwriteManager,
   PermissionOverwriteType,
   PermissionSet,
   Permissions,
   PermissionsBitField,
+  PlainTextDecoder,
   PremiumTier,
   REST,
   RESTError,
+  RateLimiter,
   RedisRateLimitStore,
+  RequestScheduler,
   ResourceManager,
+  ResponseDecoder,
   Role,
   RoleManager,
   RoleOptionBuilder,
+  RoleSelectMenuBuilder,
   Routes,
   SectionBuilder,
   SeparatorBuilder,
   ShardBus,
   ShardManager,
+  ShardManager as ShardingManager,
   SlashCommandBuilder,
   SpeakingFlags,
+  StageChannel,
+  StageInstanceManager,
   GatewayState as Status,
   StickerFormatType,
   StickerType,
   StringOptionBuilder,
   StringSelectBuilder,
+  StringSelectBuilder as StringSelectMenuBuilder,
   SubcommandBuilder,
   SubcommandGroupBuilder,
   TextChannel,
   TextDisplayBuilder,
   TextInputBuilder,
   TextInputStyle,
+  ThreadChannel,
   ThreadManager,
   ThumbnailBuilder,
+  TransportError,
   User,
   UserCommandBuilder,
   UserManager,
   UserOptionBuilder,
+  UserSelectMenuBuilder,
   VerificationLevel,
+  VoiceChannel,
   VoiceConnection,
   VoiceConnectionState,
+  VoiceConnectionState as VoiceConnectionStatus,
   VoiceError,
   VoiceReceiver,
+  WebSocketTransport,
   Webhook,
   WebhookClient,
   WebhookType,
   WelcomeScreenChannel,
+  ZlibStreamDecoder,
+  abortError,
   blockQuote,
   bold,
   bulletList,
   channelMention,
+  classifyCloseCode,
+  classifyFrame,
+  classifyPayload,
   codeBlock,
+  createAudioPlayer,
+  createAudioResource,
+  createChannel,
+  createDecoder,
   createInteraction,
   createRetryPolicy,
+  createRouteKey,
+  entersState,
   escapeMarkdown,
+  getVoiceConnection,
   heading,
+  heartbeatPayload,
+  identifyPayload,
   inlineCode,
   isSnowflake,
   italic,
+  joinVoiceChannel,
   link,
+  majorParameter,
   masked,
+  normalizeRoutePath,
   orderedList,
   randomInt,
   resolveGatewayIntents,
+  resumePayload,
   roleMention,
-  sleep3 as sleep,
+  scopeBucket,
+  serializeQuery,
+  sleep4 as sleep,
   spoiler,
   strikethrough,
   subtext,
@@ -6473,4 +7776,4 @@ export {
   userMention
 };
 
-//# debugId=CB787B7E0E4365B464756E2164756E21
+//# debugId=58F0E8EFC21C568E64756E2164756E21