lunibee 0.2.3 → 0.3.0

package/dist/sharding/index.js

@@ -2,7 +2,7 @@
 // packages/sharding/package.json
 var package_default = {
   name: "@lunibee/sharding",
-  version: "0.2.3",
+  version: "0.3.0",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -14,6 +14,31 @@ var package_default = {
   }
 };
 
+// packages/sharding/src/gateway-bot.ts
+async function fetchGatewayBot(token) {
+  const response = await fetch("https://discord.com/api/v10/gateway/bot", {
+    headers: {
+      Authorization: `Bot ${token}`,
+      "User-Agent": `Lunibee/${package_default.version}`
+    }
+  });
+  if (!response.ok)
+    throw new Error(`Gateway discovery failed with status ${response.status}`);
+  const data = await response.json();
+  if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1)
+    throw new Error("Gateway discovery returned an invalid shard count.");
+  const limit = data.session_start_limit;
+  const info = { shards: data.shards };
+  if (limit && typeof limit.total === "number" && typeof limit.remaining === "number" && typeof limit.reset_after === "number" && typeof limit.max_concurrency === "number")
+    info.sessionStartLimit = {
+      total: limit.total,
+      remaining: limit.remaining,
+      resetAfter: limit.reset_after,
+      maxConcurrency: Math.max(1, limit.max_concurrency)
+    };
+  return info;
+}
+
 // packages/ws/src/session.ts
 class GatewaySession {
   #state = { status: "none" };
@@ -88,7 +113,26 @@ class GatewaySession {
     return resume ? { type: "resume", ...resume } : { type: "identify" };
   }
   connectURL(fallback) {
-    return this.resumeInfo()?.resumeURL ?? fallback;
+    const resume = this.resumeInfo()?.resumeURL;
+    return resume !== undefined && isTrustedGatewayURL(resume, fallback) ? resume : fallback;
+  }
+}
+function isTrustedGatewayURL(url, fallback) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "wss:" || parsed.username || parsed.password)
+    return false;
+  const host = parsed.hostname.toLowerCase();
+  if (host === "discord.gg" || host.endsWith(".discord.gg"))
+    return true;
+  try {
+    return host === new URL(fallback).hostname.toLowerCase();
+  } catch {
+    return false;
   }
 }
 
@@ -260,6 +304,7 @@ class GatewayReconnect {
   #options;
   #random;
   #attempt = 0;
+  #recent = [];
   #timer;
   #promise;
   #resolve;
@@ -300,14 +345,29 @@ class GatewayReconnect {
     if (this.exhausted)
       return { scheduled: false, reason: "exhausted" };
     const attempt = this.#attempt;
-    const delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
+    const now = (this.#options.now ?? Date.now)();
+    const window = this.#options.stormWindow ?? 60000;
+    const limit = this.#options.stormLimit ?? 5;
+    while (this.#recent.length && now - this.#recent[0] >= window)
+      this.#recent.shift();
+    const over = this.#recent.length - limit;
+    this.#recent.push(now);
+    let delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
+    const unstable = over >= 0;
+    if (unstable)
+      delay = Math.min(this.#options.maxDelay, Math.max(delay, this.#options.baseDelay * 2 ** (over + 1)));
     const jitter = this.#random() * Math.max(1, delay * 0.25);
     const delayMs = delay + jitter;
     this.#timer = setTimeout(() => {
       this.#timer = undefined;
       run();
     }, delayMs);
-    return { scheduled: true, delayMs, attempt };
+    return {
+      scheduled: true,
+      delayMs,
+      attempt,
+      ...unstable ? { unstable: { reconnects: this.#recent.length } } : {}
+    };
   }
   cancel() {
     if (this.#timer)
@@ -364,12 +424,15 @@ class PlainTextDecoder {
 
 class ZlibStreamDecoder {
   #create;
+  #maxFrameBytes;
   #inflate;
   #chunks = [];
+  #size = 0;
   #failure;
   #pendingReject;
-  constructor(create = () => createInflate()) {
+  constructor(create = () => createInflate(), maxFrameBytes = 64 * 1024 * 1024) {
     this.#create = create;
+    this.#maxFrameBytes = maxFrameBytes;
   }
   push(data) {
     if (typeof data === "string")
@@ -388,6 +451,7 @@ class ZlibStreamDecoder {
     await this.#awaiting((settle) => inflate.flush(zlibConstants.Z_SYNC_FLUSH, () => settle()));
     const parts = this.#chunks;
     this.#chunks = [];
+    this.#size = 0;
     if (parts.length === 0)
       return [];
     const total = parts.reduce((size, part) => size + part.length, 0);
@@ -403,6 +467,7 @@ class ZlibStreamDecoder {
     const inflate = this.#inflate;
     this.#inflate = undefined;
     this.#chunks = [];
+    this.#size = 0;
     this.#failure = undefined;
     this.#pendingReject = undefined;
     if (!inflate)
@@ -430,7 +495,17 @@ class ZlibStreamDecoder {
   }
   #open() {
     const inflate = this.#create();
-    inflate.on("data", (chunk) => this.#chunks.push(chunk));
+    inflate.on("data", (chunk) => {
+      if (this.#failure)
+        return;
+      this.#size += chunk.length;
+      if (this.#size > this.#maxFrameBytes) {
+        this.#chunks = [];
+        inflate.emit("error", new Error(`Gateway frame inflated past ${this.#maxFrameBytes} bytes.`));
+        return;
+      }
+      this.#chunks.push(chunk);
+    });
     inflate.on("error", (error) => {
       this.#failure = error;
       const reject = this.#pendingReject;
@@ -673,9 +748,9 @@ function classifyPayload(payload) {
 }
 function identifyPayload(options) {
   const props = options.properties ?? {};
-  const os = props.os ?? "Android";
-  const browser = props.browser ?? "Discord Android";
-  const device = props.device ?? "Discord Android";
+  const os = props.os ?? process.platform;
+  const browser = props.browser ?? "Lunibee";
+  const device = props.device ?? "Lunibee";
   return {
     op: GatewayOpcodes.Identify,
     d: {
@@ -718,6 +793,21 @@ function heartbeatPayload(sequence) {
   return { op: GatewayOpcodes.Heartbeat, d: sequence, s: null, t: null };
 }
 
+// packages/types/src/channel-kind.ts
+var ChannelKinds = {
+  text: [0],
+  dm: [1],
+  voice: [2],
+  "group-dm": [3],
+  category: [4],
+  announcement: [5],
+  thread: [10, 11, 12],
+  stage: [13],
+  directory: [14],
+  forum: [15],
+  media: [16]
+};
+var KIND_OF_TYPE = new Map(Object.keys(ChannelKinds).flatMap((kind) => ChannelKinds[kind].map((type) => [type, kind])));
 // packages/types/src/gateway.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
@@ -771,40 +861,59 @@ var IntentBits = {
   directMessagePolls: 1 << 25
 };
 function resolveGatewayIntents(intents) {
-  if (typeof intents === "number")
-    return intents;
-  if (intents && typeof intents === "object" && !Array.isArray(intents))
-    return intents.bitfield;
-  if (Array.isArray(intents)) {
-    return intents.reduce((acc, intent) => {
-      return acc | resolveGatewayIntents(intent);
-    }, 0);
-  }
-  if (typeof intents === "string") {
-    if (intents in GatewayIntentBits)
-      return GatewayIntentBits[intents];
-    if (intents in IntentBits)
-      return IntentBits[intents];
-    const lower = intents.charAt(0).toLowerCase() + intents.slice(1);
-    if (lower in IntentBits)
-      return IntentBits[lower];
-    const num = Number(intents);
-    if (!Number.isNaN(num))
-      return num;
-  }
-  return 0;
+  if (!Array.isArray(intents))
+    throw new TypeError("Gateway intents must be an array, e.g. [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages].");
+  return intents.reduce((acc, intent) => acc | resolveIntent(intent), 0);
 }
-// packages/ws/src/state.ts
-class GatewayError extends Error {
-  code;
-  constructor(message, code, options) {
-    super(message, options);
-    this.name = "GatewayError";
-    this.code = code;
+function resolveIntent(intent) {
+  if (typeof intent === "number")
+    return intent;
+  const bits = {
+    ...IntentBits,
+    ...GatewayIntentBits
+  };
+  const lower = intent.charAt(0).toLowerCase() + intent.slice(1);
+  if (Object.hasOwn(bits, intent))
+    return bits[intent];
+  if (Object.hasOwn(bits, lower))
+    return bits[lower];
+  const num = Number(intent);
+  return Number.isNaN(num) ? 0 : num;
+}
+// packages/ws/src/dispatcher.ts
+class GatewayDispatcher {
+  #listeners = new Map;
+  #onFailure;
+  constructor(onFailure) {
+    this.#onFailure = onFailure;
+  }
+  on(event, listener) {
+    let listeners = this.#listeners.get(event);
+    if (!listeners)
+      this.#listeners.set(event, listeners = new Set);
+    listeners.add(listener);
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+  }
+  emit(event, data) {
+    for (const listener of this.#listeners.get(event) ?? []) {
+      try {
+        const result = listener(data);
+        if (result && typeof result.then === "function")
+          Promise.resolve(result).catch((error) => {
+            if (event !== "error")
+              this.#onFailure(error);
+          });
+      } catch (error) {
+        if (event !== "error")
+          this.#onFailure(error);
+      }
+    }
   }
 }
 // packages/ws/src/send-budget.ts
-class SendBudget {
+class GatewaySendLimiter {
   #timestamps = [];
   #limit;
   #windowMs;
@@ -824,7 +933,15 @@ class SendBudget {
     this.#timestamps.push(now);
   }
 }
-
+// packages/ws/src/state.ts
+class GatewayError extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = "GatewayError";
+    this.code = code;
+  }
+}
 // packages/ws/src/index.ts
 var RESUMABLE_CLOSE_CODE = 4900;
 var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
@@ -838,8 +955,9 @@ class Gateway {
   #heartbeat;
   #closed = false;
   #reconnect;
-  #listeners = new Map;
-  #sendBudget = new SendBudget;
+  #events = new GatewayDispatcher((error) => this.#emitError(error));
+  #sendBudget = new GatewaySendLimiter;
+  #reconnects = 0;
   ping = -1;
   constructor(options) {
     if (!options.token?.trim())
@@ -857,9 +975,9 @@ class Gateway {
       heartbeatAckTimeout: 1e4,
       zombieTimeout: 30000,
       properties: {
-        os: "Android",
-        browser: "Discord Android",
-        device: "Discord Android"
+        os: process.platform,
+        browser: "Lunibee",
+        device: "Lunibee"
       },
       presence: {
         status: "online",
@@ -890,7 +1008,9 @@ class Gateway {
       enabled: this.#options.reconnect,
       maxAttempts: this.#options.maxReconnectAttempts,
       baseDelay: this.#options.reconnectBaseDelay,
-      maxDelay: this.#options.reconnectMaxDelay
+      maxDelay: this.#options.reconnectMaxDelay,
+      stormLimit: options.reconnectStormLimit,
+      stormWindow: options.reconnectStormWindow
     });
     this.#heartbeat = new GatewayHeartbeat({
       ackTimeout: this.#options.heartbeatAckTimeout,
@@ -941,16 +1061,21 @@ class Gateway {
   on(event, listener) {
     if (!event || typeof listener !== "function")
       throw new TypeError("Gateway event and listener are required.");
-    let listeners = this.#listeners.get(event);
-    if (!listeners)
-      this.#listeners.set(event, listeners = new Set);
-    listeners.add(listener);
+    this.#events.on(event, listener);
     return this;
   }
   off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
+    this.#events.off(event, listener);
     return this;
   }
+  health() {
+    return {
+      state: this.state,
+      latency: this.#heartbeat.latency,
+      silentFor: this.#heartbeat.silentFor,
+      reconnects: this.#reconnects
+    };
+  }
   send(payload) {
     if (!payload || !Number.isInteger(payload.op))
       throw new TypeError("Gateway payload must contain an integer opcode.");
@@ -992,6 +1117,22 @@ class Gateway {
       t: null
     });
   }
+  sendVoiceState(guildId, channelId, options = {}) {
+    if (!this.ownsGuild(guildId))
+      return false;
+    return this.setVoiceState({
+      guild_id: guildId,
+      channel_id: channelId,
+      self_mute: options.selfMute ?? false,
+      self_deaf: options.selfDeaf ?? false
+    });
+  }
+  ownsGuild(guildId) {
+    const count = this.#options.shardCount;
+    if (count <= 1)
+      return true;
+    return Number((BigInt(guildId) >> 22n) % BigInt(count)) === this.#options.shardId;
+  }
   requestGuildMembers(data) {
     return this.send({
       op: GatewayOpcodes.RequestGuildMembers,
@@ -1129,7 +1270,16 @@ class Gateway {
     if (this.#closed)
       return;
     const result = this.#reconnect.schedule(() => this.#open(this.#session.connectURL(DEFAULT_GATEWAY_URL)));
-    if (result.scheduled || result.reason !== "exhausted")
+    if (result.scheduled) {
+      this.#reconnects++;
+      if (result.unstable)
+        this.#emit("unstable", {
+          reconnects: result.unstable.reconnects,
+          delay: result.delayMs
+        });
+      return;
+    }
+    if (result.reason !== "exhausted")
       return;
     this.#reconnect.settle(new GatewayError("Gateway reconnect attempts exhausted."));
     this.#setState("CONNECT" /* Connect */);
@@ -1150,19 +1300,7 @@ class Gateway {
     this.#emit("error", error instanceof Error ? error : new GatewayError(String(error)));
   }
   #emit(event, data) {
-    for (const listener of this.#listeners.get(event) ?? []) {
-      try {
-        const result = listener(data);
-        if (result && typeof result.then === "function")
-          Promise.resolve(result).catch((error) => {
-            if (event !== "error")
-              this.#emitError(error);
-          });
-      } catch (error) {
-        if (event !== "error")
-          this.#emitError(error);
-      }
-    }
+    this.#events.emit(event, data);
   }
   #setState(next) {
     if (this.state === next)
@@ -1172,12 +1310,70 @@ class Gateway {
     this.#emit("stateChange", { previous, next });
   }
 }
+// packages/sharding/src/transport.ts
+class BroadcastChannelTransport {
+  #channel;
+  constructor(name) {
+    this.#channel = new BroadcastChannel(name);
+  }
+  post(message) {
+    this.#channel.postMessage(message);
+  }
+  onMessage(listener) {
+    this.#channel.addEventListener("message", (event) => listener(event.data));
+  }
+  close() {
+    this.#channel.close();
+  }
+}
+var BUS_FRAME = "__lunibeeBus";
+var PEER_DOWN_FRAME = "__lunibeePeerDown";
+
+class IpcTransport {
+  #endpoint;
+  #listener;
+  #message;
+  #down;
+  constructor(endpoint = process) {
+    if (typeof endpoint.send !== "function")
+      throw new Error("IpcTransport needs an IPC channel: run the shard in a process forked by ClusterManager.");
+    this.#endpoint = endpoint;
+    this.#listener = (frame) => {
+      const record = frame;
+      if (!record || typeof record !== "object")
+        return;
+      if (BUS_FRAME in record)
+        this.#message?.(record[BUS_FRAME]);
+      else if (PEER_DOWN_FRAME in record)
+        this.#down?.(record[PEER_DOWN_FRAME]);
+    };
+    endpoint.on("message", this.#listener);
+  }
+  post(message) {
+    this.#endpoint.send({ [BUS_FRAME]: message });
+  }
+  onMessage(listener) {
+    this.#message = listener;
+  }
+  onPeerDown(listener) {
+    this.#down = listener;
+  }
+  close() {
+    this.#endpoint.off("message", this.#listener);
+  }
+}
+function defaultTransport(name) {
+  if (process.env.LUNIBEE_SHARD_BUS === "ipc" && typeof process.send === "function")
+    return new IpcTransport;
+  return new BroadcastChannelTransport(name);
+}
 
 // packages/sharding/src/bus.ts
 var REPLY_TYPE = "__lunibee:reply";
 
 class ShardBus {
-  #channel;
+  #transport;
+  #maxPending;
   #handlers = new Map;
   #errorHandlers = new Set;
   #shardId;
@@ -1185,7 +1381,7 @@ class ShardBus {
   channelName;
   #counter = 0;
   #pending = new Map;
-  constructor(shardId, channelName) {
+  constructor(shardId, channelName, options = {}) {
     if (!Number.isInteger(shardId) || shardId < 0)
       throw new RangeError("Shard ID must be a non-negative integer.");
     if (!channelName?.trim())
@@ -1193,8 +1389,10 @@ class ShardBus {
     this.#shardId = shardId;
     this.#namespace = channelName.trim();
     this.channelName = this.#namespace;
-    this.#channel = new BroadcastChannel(this.channelName);
-    this.#channel.addEventListener("message", (event) => this.#dispatch(event.data));
+    this.#maxPending = options.maxPending ?? 1e4;
+    this.#transport = options.transport ?? defaultTransport(this.channelName);
+    this.#transport.onMessage((message) => this.#dispatch(message));
+    this.#transport.onPeerDown?.((shardIds) => this.#peerDown(shardIds));
   }
   on(type, handler) {
     if (!type.trim() || typeof handler !== "function")
@@ -1243,7 +1441,7 @@ class ShardBus {
   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);
+    const [reply] = await this.#collect(target, type, data, timeoutMs, 1, true);
     if (!reply)
       throw new Error(`Shard ${target} did not reply to "${type}" within ${timeoutMs}ms.`);
     if (reply.error !== undefined)
@@ -1253,9 +1451,11 @@ class ShardBus {
   broadcastRequest(type, data, options = {}) {
     return this.#collect(null, type, data, options.timeoutMs ?? 5000, options.expected ?? Number.POSITIVE_INFINITY);
   }
-  #collect(target, type, data, timeoutMs, expected) {
+  #collect(target, type, data, timeoutMs, expected, rejectOnPeerDown = false) {
     const replies = [];
-    return new Promise((resolve) => {
+    if (this.#pending.size >= this.#maxPending)
+      return Promise.reject(new Error(`Too many shard requests waiting for a reply (${this.#maxPending}).`));
+    return new Promise((resolve, reject) => {
       let requestId = "";
       const finish = () => {
         clearTimeout(timer);
@@ -1264,15 +1464,25 @@ class ShardBus {
       };
       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();
+      this.#pending.set(requestId, {
+        target,
+        reply: (reply) => {
+          replies.push(reply);
+          if (replies.length >= expected)
+            finish();
+        },
+        fail: (error) => {
+          if (rejectOnPeerDown) {
+            clearTimeout(timer);
+            this.#pending.delete(requestId);
+            reject(error);
+          }
+        }
       });
     });
   }
   close() {
-    this.#channel.close();
+    this.#transport.close();
     this.#handlers.clear();
     this.#errorHandlers.clear();
   }
@@ -1280,7 +1490,7 @@ class ShardBus {
     if (!type.trim())
       throw new TypeError("Shard message type is required.");
     const id = `${this.#namespace}:${this.#shardId}:${++this.#counter}`;
-    this.#channel.postMessage({
+    this.#transport.post({
       source: this.#shardId,
       target,
       type,
@@ -1297,7 +1507,7 @@ class ShardBus {
       return;
     if (message.type === REPLY_TYPE) {
       const reply = message.data;
-      this.#pending.get(reply?.requestId)?.({
+      this.#pending.get(reply?.requestId)?.reply({
         shardId: message.source,
         ...reply.error !== undefined ? { error: reply.error } : { result: reply.result }
       });
@@ -1313,7 +1523,19 @@ class ShardBus {
       }
     }
   }
+  #peerDown(shardIds) {
+    const down = new Set(shardIds);
+    for (const [id, pending] of this.#pending)
+      if (pending.target !== null && down.has(pending.target)) {
+        pending.fail(new Error(`Shard ${pending.target} went away before it replied.`));
+        this.#pending.delete(id);
+      }
+  }
   #reportError(error, message) {
+    if (this.#errorHandlers.size === 0) {
+      process.emitWarning(error instanceof Error ? error : new Error(String(error)), { code: "LUNIBEE_SHARD_BUS_ERROR" });
+      return;
+    }
     for (const handler of this.#errorHandlers) {
       try {
         handler(error, message);
@@ -1321,6 +1543,50 @@ class ShardBus {
     }
   }
 }
+// packages/sharding/src/supervisor.ts
+class ShardSupervisor {
+  #options;
+  #restarts = new Map;
+  #random;
+  constructor(options = {}, random = Math.random) {
+    this.#options = {
+      restartDelay: options.restartDelay ?? 5000,
+      backoff: options.backoff ?? 1,
+      maxDelay: options.maxDelay ?? 300000,
+      jitter: options.jitter ?? 0,
+      maxRestarts: options.maxRestarts ?? Number.POSITIVE_INFINITY,
+      window: options.window ?? 60000
+    };
+    const { restartDelay, backoff, jitter, maxDelay, window, maxRestarts } = this.#options;
+    if (!(restartDelay >= 0) || !(maxDelay >= 0) || !(window > 0))
+      throw new RangeError("restartDelay and maxDelay cannot be negative, and window must be positive.");
+    if (!(backoff >= 1))
+      throw new RangeError("backoff must be at least 1.");
+    if (!(jitter >= 0 && jitter <= 1))
+      throw new RangeError("jitter must be between 0 and 1.");
+    if (!(maxRestarts >= 0))
+      throw new RangeError("maxRestarts cannot be negative.");
+    this.#random = random;
+  }
+  next(id, now = Date.now()) {
+    const { window, maxRestarts, restartDelay, backoff, maxDelay, jitter } = this.#options;
+    const recent = (this.#restarts.get(id) ?? []).filter((at) => now - at < window);
+    if (recent.length >= maxRestarts) {
+      this.#restarts.delete(id);
+      return null;
+    }
+    recent.push(now);
+    this.#restarts.set(id, recent);
+    const base = Math.min(maxDelay, restartDelay * backoff ** (recent.length - 1));
+    return Math.round(base * (1 + jitter * this.#random()));
+  }
+  reset(id) {
+    if (id === undefined)
+      this.#restarts.clear();
+    else
+      this.#restarts.delete(id);
+  }
+}
 // packages/sharding/src/cluster.ts
 import { fork } from "child_process";
 import { cpus } from "os";
@@ -1335,6 +1601,7 @@ class ClusterManager {
   #spawned = false;
   #stopping = false;
   #restartTimers = new Set;
+  #supervisor;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
@@ -1345,22 +1612,13 @@ class ClusterManager {
     }
     this.#auto = options.shardCount === "auto";
     this.#options = { ...options };
+    this.#supervisor = new ShardSupervisor({
+      restartDelay: options.restartDelay,
+      ...options.supervisor
+    });
   }
   async fetchRecommendedShardCount() {
-    const response = await fetch("https://discord.com/api/v10/gateway/bot", {
-      headers: {
-        Authorization: `Bot ${this.#options.token}`,
-        "User-Agent": `Lunibee/${package_default.version}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Gateway discovery failed with status ${response.status}`);
-    }
-    const data = await response.json();
-    if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1) {
-      throw new Error("Gateway discovery returned an invalid shard count.");
-    }
-    return data.shards;
+    return (await fetchGatewayBot(this.#options.token)).shards;
   }
   async spawn() {
     if (this.#spawned)
@@ -1394,31 +1652,62 @@ class ClusterManager {
         ...process.env,
         SHARD_LIST: shards.join(","),
         SHARD_COUNT: shardCount.toString(),
-        CLUSTER_ID: id.toString()
+        CLUSTER_ID: id.toString(),
+        LUNIBEE_SHARD_BUS: "ipc"
       }
     });
     const info = { id, process: child, shards };
     this.clusters.set(id, info);
+    child.on("message", (frame) => this.#relay(id, frame));
     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.#announceDown(id, shards);
       if (this.#stopping || this.#options.restartOnExit === false)
         return;
       this.clusters.delete(id);
+      const delay = this.#supervisor.next(id);
+      if (delay === null) {
+        try {
+          this.#options.onGiveUp?.(info);
+        } catch {}
+        return;
+      }
       const timer = setTimeout(() => {
         this.#restartTimers.delete(timer);
         if (this.#stopping || !this.#spawned)
           return;
         this.#launch(id, shards, shardCount);
-      }, this.#options.restartDelay ?? 5000);
+      }, delay);
       timer.unref?.();
       this.#restartTimers.add(timer);
     });
     return info;
   }
+  #relay(from, frame) {
+    if (!frame || typeof frame !== "object" || !(BUS_FRAME in frame))
+      return;
+    for (const [id, cluster] of this.clusters)
+      if (id !== from)
+        this.#sendFrame(cluster, frame);
+  }
+  #announceDown(exited, shards) {
+    for (const [id, cluster] of this.clusters)
+      if (id !== exited)
+        this.#sendFrame(cluster, { [PEER_DOWN_FRAME]: shards });
+  }
+  #sendFrame(cluster, frame) {
+    const child = cluster.process;
+    if (typeof child.send !== "function" || !child.connected)
+      return;
+    try {
+      child.send(frame);
+    } catch {}
+  }
   async checkAutoScale() {
     if (!this.#auto)
       return;
@@ -1436,6 +1725,7 @@ class ClusterManager {
     this.#options.shardCount = newShardCount;
     await this.shutdownAll();
     this.#spawned = false;
+    this.#supervisor.reset();
     await this.spawn();
   }
   async shutdownAll(timeoutMs = this.#options.shutdownTimeout ?? 5000) {
@@ -1541,12 +1831,14 @@ class ShardManager {
   #destroyed = false;
   #auto;
   #autoScaleTimer;
+  #total;
+  #listeners = new Map;
   #gatewayInfo;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
-    if (!Number.isInteger(options.intents) || options.intents < 0)
-      throw new TypeError("Gateway intents must be a non-negative integer.");
+    if (!Array.isArray(options.intents))
+      throw new TypeError("Gateway intents must be an array, e.g. [GatewayIntentBits.Guilds].");
     const count = options.shardCount === "auto" || options.shardCount === undefined ? 1 : options.shardCount;
     if (!Number.isInteger(count) || count < 1)
       throw new RangeError("Shard count must be a positive integer.");
@@ -1558,6 +1850,7 @@ class ShardManager {
       throw new RangeError("maxConcurrency must be a positive integer.");
     if (options.handshakeTimeout !== undefined && (!Number.isFinite(options.handshakeTimeout) || options.handshakeTimeout < 0))
       throw new RangeError("handshakeTimeout must be a non-negative number of milliseconds.");
+    this.#total = count;
     this.#auto = options.shardCount === "auto";
     this.#options = {
       spawnDelay: ShardManager.IDENTIFY_INTERVAL,
@@ -1570,26 +1863,7 @@ class ShardManager {
     return (await this.fetchGatewayInfo()).shards;
   }
   async fetchGatewayInfo() {
-    const response = await fetch("https://discord.com/api/v10/gateway/bot", {
-      headers: {
-        Authorization: `Bot ${this.#options.token}`,
-        "User-Agent": `Lunibee/${package_default.version}`
-      }
-    });
-    if (!response.ok)
-      throw new Error(`Gateway discovery failed with status ${response.status}`);
-    const data = await response.json();
-    if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1)
-      throw new Error("Gateway discovery returned an invalid shard count.");
-    const limit = data.session_start_limit;
-    const info = { shards: data.shards };
-    if (limit && typeof limit.total === "number" && typeof limit.remaining === "number" && typeof limit.reset_after === "number" && typeof limit.max_concurrency === "number")
-      info.sessionStartLimit = {
-        total: limit.total,
-        remaining: limit.remaining,
-        resetAfter: limit.reset_after,
-        maxConcurrency: Math.max(1, limit.max_concurrency)
-      };
+    const info = await fetchGatewayBot(this.#options.token);
     this.#gatewayInfo = info;
     return info;
   }
@@ -1604,8 +1878,18 @@ class ShardManager {
     if (limit && limit.remaining < ids.length)
       throw new Error(`Session start limit exhausted: ${limit.remaining} of ${limit.total} IDENTIFYs left for ${ids.length} shards; resets in ${Math.ceil(limit.resetAfter / 1000)}s.`);
     const concurrency = Math.min(this.#options.maxConcurrency ?? limit?.maxConcurrency ?? 1, limit?.maxConcurrency ?? Infinity);
-    for (let start = 0;start < ids.length; start += concurrency) {
-      const round = ids.slice(start, start + concurrency);
+    const buckets = new Map;
+    for (const id of ids) {
+      const key = id % concurrency;
+      const bucket = buckets.get(key);
+      if (bucket)
+        bucket.push(id);
+      else
+        buckets.set(key, [id]);
+    }
+    const rounds = Math.max(0, ...[...buckets.values()].map((bucket) => bucket.length));
+    for (let index = 0;index < rounds; index++) {
+      const round = [...buckets.values()].map((bucket) => bucket[index]).filter((id) => id !== undefined);
       const results = await Promise.allSettled(round.map((id) => this.shards.get(id).connect()));
       const failed = results.findIndex((result) => result.status === "rejected");
       if (failed !== -1) {
@@ -1614,7 +1898,7 @@ class ShardManager {
           cause: results[failed].reason
         });
       }
-      if (start + concurrency < ids.length && this.#options.spawnDelay && this.#options.spawnDelay > 0) {
+      if (index + 1 < rounds && this.#options.spawnDelay && this.#options.spawnDelay > 0) {
         await Promise.all(round.map((id) => handshakeSent(this.shards.get(id), this.#options.handshakeTimeout ?? 15000)));
         await sleep2(this.#options.spawnDelay);
       }
@@ -1653,9 +1937,29 @@ class ShardManager {
       this.#autoScaleTimer = undefined;
     }
   }
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set)
+      this.#listeners.set(event, set = new Set);
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  #emit(event, ...args) {
+    for (const listener of this.#listeners.get(event) ?? [])
+      try {
+        listener(...args);
+      } catch {}
+  }
   getShardIdForGuild(guildId) {
     const id = BigInt(guildId);
-    return Number((id >> 22n) % BigInt(this.shardCount || 1));
+    return Number((id >> 22n) % BigInt(this.#total));
+  }
+  sendVoiceState(guildId, channelId, options = {}) {
+    return this.shards.get(this.getShardIdForGuild(guildId))?.sendVoiceState(guildId, channelId, options) ?? false;
   }
   get(id) {
     return this.shards.get(id);
@@ -1681,25 +1985,36 @@ class ShardManager {
   #initialize(count) {
     if (this.#resolved)
       return;
+    this.#total = count;
     for (let id = 0;id < count; id++)
       this.shards.set(id, this.#createShard(id, count));
     this.#resolved = true;
   }
   #createShard(id, count) {
-    return new Gateway({
+    const gateway = new Gateway({
       token: this.#options.token,
       intents: this.#options.intents,
       shardId: id,
       shardCount: count,
       reconnect: this.#options.reconnect ?? true
     });
+    gateway.on("ready", () => this.#emit("shardReady", id));
+    gateway.on("resumed", () => this.#emit("shardResume", id));
+    gateway.on("close", (close) => this.#emit("shardDisconnect", id, close));
+    gateway.on("error", (error) => this.#emit("shardError", id, error));
+    gateway.on("unstable", (info) => this.#emit("shardUnstable", id, info));
+    return gateway;
   }
 }
 export {
+  BroadcastChannelTransport,
   ClusterManager,
+  IpcTransport,
   ShardBus,
   ShardManager,
-  ShardManager as ShardingManager
+  ShardSupervisor,
+  ShardManager as ShardingManager,
+  fetchGatewayBot
 };
 
-//# debugId=B02B71EDFB220DDE64756E2164756E21
+//# debugId=8B521E4F34BB811E64756E2164756E21