@bakit/gateway 2.1.9 → 3.0.1

package/dist/cluster.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var gateway = require('@bakit/gateway');
+
+// src/lib/internal/cluster.ts
+var {
+  BAKIT_CLUSTER_ID,
+  BAKIT_DISCORD_TOKEN,
+  BAKIT_DISCORD_INTENTS,
+  BAKIT_DISCORD_GATEWAY_URL,
+  BAKIT_DISCORD_GATEWAY_VERSION,
+  BAKIT_CLUSTER_SHARD_TOTAL,
+  BAKIT_CLUSTER_SHARD_LIST
+} = process.env, cluster = new gateway.Cluster(Number(BAKIT_CLUSTER_ID), {
+  token: BAKIT_DISCORD_TOKEN,
+  intents: Number(BAKIT_DISCORD_INTENTS),
+  total: Number(BAKIT_CLUSTER_SHARD_TOTAL),
+  shards: JSON.parse(BAKIT_CLUSTER_SHARD_LIST),
+  gateway: {
+    baseURL: BAKIT_DISCORD_GATEWAY_URL,
+    version: Number(BAKIT_DISCORD_GATEWAY_VERSION)
+  }
+});
+gateway.ClusterProcess.bindProcess(cluster);
+cluster.spawn();

package/dist/cluster.js

@@ -0,0 +1,23 @@
+import { Cluster, ClusterProcess } from '@bakit/gateway';
+
+// src/lib/internal/cluster.ts
+var {
+  BAKIT_CLUSTER_ID,
+  BAKIT_DISCORD_TOKEN,
+  BAKIT_DISCORD_INTENTS,
+  BAKIT_DISCORD_GATEWAY_URL,
+  BAKIT_DISCORD_GATEWAY_VERSION,
+  BAKIT_CLUSTER_SHARD_TOTAL,
+  BAKIT_CLUSTER_SHARD_LIST
+} = process.env, cluster = new Cluster(Number(BAKIT_CLUSTER_ID), {
+  token: BAKIT_DISCORD_TOKEN,
+  intents: Number(BAKIT_DISCORD_INTENTS),
+  total: Number(BAKIT_CLUSTER_SHARD_TOTAL),
+  shards: JSON.parse(BAKIT_CLUSTER_SHARD_LIST),
+  gateway: {
+    baseURL: BAKIT_DISCORD_GATEWAY_URL,
+    version: Number(BAKIT_DISCORD_GATEWAY_VERSION)
+  }
+});
+ClusterProcess.bindProcess(cluster);
+cluster.spawn();

package/dist/index.cjs

@@ -0,0 +1,632 @@
+'use strict';
+
+var EventEmitter = require('events');
+var zlib = require('zlib');
+var util = require('util');
+var crypto = require('crypto');
+var WebSocket = require('ws');
+var v10 = require('discord-api-types/v10');
+var child_process = require('child_process');
+var path = require('path');
+var url = require('url');
+var utils = require('@bakit/utils');
+var rest = require('@bakit/rest');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+
+// src/lib/Shard.ts
+var MIN_HEARTBEAT_INTERVAL = 1e3, MAX_HEARTBEAT_INTERVAL = 6e4, SAFE_HEARTBEAT_INTERVAL = 45e3, ShardState = /* @__PURE__ */ ((ShardState2) => (ShardState2[ShardState2.Idle = 0] = "Idle", ShardState2[ShardState2.Connecting = 1] = "Connecting", ShardState2[ShardState2.Ready = 2] = "Ready", ShardState2[ShardState2.Resuming = 3] = "Resuming", ShardState2[ShardState2.Disconnecting = 4] = "Disconnecting", ShardState2[ShardState2.Disconnected = 5] = "Disconnected", ShardState2))(ShardState || {}), ShardStrategy = /* @__PURE__ */ ((ShardStrategy2) => (ShardStrategy2[ShardStrategy2.Resume = 0] = "Resume", ShardStrategy2[ShardStrategy2.Reconnect = 1] = "Reconnect", ShardStrategy2[ShardStrategy2.Shutdown = 2] = "Shutdown", ShardStrategy2))(ShardStrategy || {}), Shard = class extends EventEmitter__default.default {
+  constructor(id, options) {
+    super();
+    this.id = id;
+    this.options = options;
+  }
+  #state = 0 /* Idle */;
+  #ws;
+  #inflater;
+  #textDecoder = new util.TextDecoder();
+  #decompressBuffer = [];
+  #sessionId;
+  #lastSequence;
+  #resumeGatewayURL;
+  #lastHeartbeatSent = -1;
+  #lastHeartbeatAck = -1;
+  #missedHeartbeats = 0;
+  #heartbeatInterval;
+  #heartbeatTimeout;
+  #reconnectTimeout;
+  #strategy;
+  get state() {
+    return this.#state;
+  }
+  get latency() {
+    return this.#lastHeartbeatSent === -1 || this.#lastHeartbeatAck === -1 ? -1 : this.#lastHeartbeatAck - this.#lastHeartbeatSent;
+  }
+  get resumable() {
+    let hasSessionId = this.#sessionId !== void 0, hasSequence = this.#lastSequence !== void 0;
+    return this.#strategy === 0 /* Resume */ && hasSequence && hasSessionId;
+  }
+  async connect() {
+    if (this.#state !== 0 /* Idle */ && this.#state !== 5 /* Disconnected */)
+      throw new Error("Shard already connecting or connected");
+    return new Promise((resolve2, reject) => {
+      let cleanup = () => {
+        this.off("error", onError), this.off("ready", onReady);
+      }, onReady = () => {
+        cleanup(), resolve2();
+      }, onError = (err) => {
+        cleanup(), reject(err);
+      };
+      this.once("ready", onReady), this.once("error", onError), this.#init();
+    });
+  }
+  disconnect(code) {
+    return new Promise((resolve2) => {
+      if (this.#state = 4 /* Disconnecting */, this.#strategy = 2 /* Shutdown */, !this.#ws) {
+        resolve2();
+        return;
+      }
+      this.#ws.once("close", () => {
+        resolve2();
+      }), this.#ws.close(code);
+    });
+  }
+  resume() {
+    this.resumable && (this.#state = 3 /* Resuming */, this.send({
+      op: v10.GatewayOpcodes.Resume,
+      d: {
+        token: this.options.token,
+        session_id: this.#sessionId,
+        seq: this.#lastSequence
+      }
+    }));
+  }
+  identify() {
+    this.send({
+      op: v10.GatewayOpcodes.Identify,
+      d: {
+        token: this.options.token,
+        intents: Number(this.options.intents),
+        properties: {
+          os: process.platform,
+          browser: "bakit",
+          device: "bakit"
+        },
+        shard: [this.id, this.options.total]
+      }
+    });
+  }
+  send(payload) {
+    this.#ws?.readyState === WebSocket__default.default.OPEN && this.#ws.send(JSON.stringify(payload));
+  }
+  sendHeartbeat() {
+    if (this.#lastHeartbeatSent !== -1 && this.#lastHeartbeatAck < this.#lastHeartbeatSent ? this.#missedHeartbeats++ : this.#missedHeartbeats = 0, this.#missedHeartbeats >= 2) {
+      this.emit("debug", "Missed 2 heartbeats, reconnecting"), this.#ws?.terminate();
+      return;
+    }
+    this.send({
+      op: v10.GatewayOpcodes.Heartbeat,
+      d: this.#lastSequence ?? null
+    }), this.#lastHeartbeatSent = Date.now();
+  }
+  #init() {
+    this.#state = 1 /* Connecting */, this.#strategy ??= 1 /* Reconnect */;
+    let url = new URL(
+      this.#strategy === 0 /* Resume */ && this.#resumeGatewayURL ? this.#resumeGatewayURL : this.options.gateway.baseURL
+    );
+    url.searchParams.set("v", String(this.options.gateway.version)), url.searchParams.set("encoding", "json"), url.searchParams.set("compress", "zlib-stream"), this.#ws = new WebSocket__default.default(url, { perMessageDeflate: false }), this.#inflater = zlib.createInflate({ flush: zlib.constants.Z_SYNC_FLUSH }), this.#inflater.on("data", (chunk) => this.#onInflate(chunk)), this.#inflater.on("error", (err) => {
+      this.emit("error", err), this.#ws?.terminate();
+    }), this.#ws.on("message", (data) => this.#onMessage(data)), this.#ws.on("close", (code) => this.#onClose(code)), this.#ws.on("error", (err) => this.emit("error", err));
+  }
+  #onMessage(data) {
+    if (!this.#inflater) {
+      try {
+        let text = data.toString(), payload = JSON.parse(text);
+        this.#handlePayload(payload);
+      } catch (error) {
+        this.emit("error", error);
+      }
+      return;
+    }
+    let buffer;
+    Buffer.isBuffer(data) ? buffer = data : Array.isArray(data) ? buffer = Buffer.concat(data) : data instanceof ArrayBuffer ? buffer = Buffer.from(data) : buffer = Buffer.from(String(data));
+    let hasSyncFlush = buffer.length >= 4 && buffer[buffer.length - 4] === 0 && buffer[buffer.length - 3] === 0 && buffer[buffer.length - 2] === 255 && buffer[buffer.length - 1] === 255;
+    this.#inflater.write(buffer, (writeError) => {
+      if (writeError) {
+        this.emit("error", writeError);
+        return;
+      }
+      hasSyncFlush && this.#inflater?.flush(zlib.constants.Z_SYNC_FLUSH);
+    });
+  }
+  #onInflate(chunk) {
+    this.#decompressBuffer.push(chunk);
+    let fullBuffer = Buffer.concat(this.#decompressBuffer);
+    try {
+      let text = this.#textDecoder.decode(fullBuffer), payload = JSON.parse(text);
+      this.#handlePayload(payload), this.#decompressBuffer = [];
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        let text = this.#textDecoder.decode(fullBuffer);
+        if (text.includes("{") && !isValidJSON(text))
+          return;
+        this.emit("error", error), this.#decompressBuffer = [];
+      }
+    }
+  }
+  #handlePayload(payload) {
+    switch (this.emit("raw", payload), payload.op) {
+      case v10.GatewayOpcodes.Dispatch: {
+        this.#handleDispatch(payload);
+        break;
+      }
+      case v10.GatewayOpcodes.Hello: {
+        this.#startHeartbeat(payload.d.heartbeat_interval), this.resumable ? this.resume() : this.emit("needIdentify");
+        break;
+      }
+      case v10.GatewayOpcodes.Heartbeat: {
+        this.sendHeartbeat();
+        break;
+      }
+      case v10.GatewayOpcodes.HeartbeatAck: {
+        this.#lastHeartbeatAck = Date.now();
+        break;
+      }
+      case v10.GatewayOpcodes.InvalidSession: {
+        payload.d ? this.#strategy = 0 /* Resume */ : (this.#strategy = 1 /* Reconnect */, this.#sessionId = void 0, this.#lastSequence = void 0, this.#resumeGatewayURL = void 0), this.emit("debug", `Invalid session (resumable=${this.resumable})`), this.#ws?.terminate();
+        break;
+      }
+      case v10.GatewayOpcodes.Reconnect: {
+        this.#strategy = 0 /* Resume */, this.emit("debug", "Reconnecting to gateway"), this.#ws?.terminate();
+        break;
+      }
+    }
+  }
+  #handleDispatch(payload) {
+    switch (this.#lastSequence = payload.s, this.emit("dispatch", payload), payload.t) {
+      case v10.GatewayDispatchEvents.Ready: {
+        let { d: data } = payload;
+        this.#state = 2 /* Ready */, this.#sessionId = data.session_id, this.#resumeGatewayURL = data.resume_gateway_url, this.emit("ready", data);
+        break;
+      }
+      case v10.GatewayDispatchEvents.Resumed: {
+        this.#state = 2 /* Ready */, this.#strategy = void 0, this.emit("resume");
+        break;
+      }
+    }
+  }
+  #onClose(code) {
+    if (this.#cleanup(), this.#state = 5 /* Disconnected */, this.emit("disconnect", code), this.#strategy === 2 /* Shutdown */) {
+      switch (code) {
+        case v10.GatewayCloseCodes.AuthenticationFailed:
+          this.emit("error", new Error("Invalid token provided"));
+          break;
+        case v10.GatewayCloseCodes.InvalidIntents:
+          this.emit("error", new Error("Invalid intents provided"));
+          break;
+        case v10.GatewayCloseCodes.DisallowedIntents:
+          this.emit("error", new Error("Disallowed intents provided"));
+          break;
+      }
+      return;
+    } else this.#strategy || (this.#strategy = this.#getStrategy(code));
+    (this.#strategy === 1 /* Reconnect */ || this.#strategy === 0 /* Resume */) && this.#scheduleReconnect();
+  }
+  #getStrategy(code) {
+    switch (code) {
+      case v10.GatewayCloseCodes.AuthenticationFailed:
+      case v10.GatewayCloseCodes.InvalidIntents:
+      case v10.GatewayCloseCodes.DisallowedIntents:
+        return 2 /* Shutdown */;
+      case v10.GatewayCloseCodes.InvalidSeq:
+      case v10.GatewayCloseCodes.SessionTimedOut:
+        return 1 /* Reconnect */;
+      default:
+        return 0 /* Resume */;
+    }
+  }
+  #scheduleReconnect(delay = 1e3) {
+    this.#reconnectTimeout || (this.#reconnectTimeout = setTimeout(() => {
+      this.#reconnectTimeout = void 0, this.#state = 0 /* Idle */, this.#init();
+    }, delay));
+  }
+  #startHeartbeat(interval) {
+    this.#heartbeatInterval && (clearInterval(this.#heartbeatInterval), this.#heartbeatInterval = void 0), (interval < MIN_HEARTBEAT_INTERVAL || interval > MAX_HEARTBEAT_INTERVAL) && (interval = SAFE_HEARTBEAT_INTERVAL);
+    let jitter = crypto.randomInt(0, 10) / 100, firstDelay = Math.floor(interval * jitter);
+    this.emit("debug", `Starting heartbeat (interval=${interval}ms, jitter=${firstDelay}ms)`), this.#heartbeatTimeout = setTimeout(() => {
+      this.sendHeartbeat(), this.#heartbeatInterval = setInterval(() => this.sendHeartbeat(), interval);
+    }, firstDelay);
+  }
+  #cleanup() {
+    clearTimeout(this.#reconnectTimeout), clearInterval(this.#heartbeatInterval), clearTimeout(this.#heartbeatTimeout), this.#inflater?.destroy(), this.#inflater = void 0, this.#ws?.removeAllListeners(), this.#ws = void 0, this.#decompressBuffer = [], this.#missedHeartbeats = 0;
+  }
+};
+function isValidJSON(str) {
+  try {
+    return JSON.parse(str), !0;
+  } catch {
+    return false;
+  }
+}
+var EVAL_TIMEOUT = 3e4, __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))), __dirname$1 = path.dirname(__filename$1);
+function isDispatchPayload(payload) {
+  return payload.op === "dispatch";
+}
+function isIdentifyPayload(payload) {
+  return payload.op === "identify";
+}
+function isSendPayload(payload) {
+  return payload.op === "send";
+}
+function isEvalRequestPayload(payload) {
+  return payload.op === "eval";
+}
+function isEvalResponsePayload(payload) {
+  return payload.op === "evalResponse";
+}
+var ClusterProcess = class _ClusterProcess extends EventEmitter__default.default {
+  constructor(manager, id, options = {}) {
+    super();
+    this.manager = manager;
+    this.id = id;
+    this.setMaxListeners(0);
+    let entry = path.resolve(__dirname$1, utils.isCommonJS() ? "cluster.cjs" : "cluster.js");
+    this.process = child_process.fork(entry, {
+      env: options.env,
+      execArgv: options.execArgv,
+      stdio: ["inherit", "inherit", "inherit", "ipc"]
+    }), this.#bindProcessEvents();
+  }
+  process;
+  #pendingEvals = /* @__PURE__ */ new Map();
+  get killed() {
+    return this.process.killed || !this.process.connected;
+  }
+  kill(signal = "SIGTERM") {
+    if (!this.killed) {
+      for (let [nonce, pending] of this.#pendingEvals)
+        clearTimeout(pending.timeout), pending.reject(new Error(`Process killed before eval completed (nonce: ${nonce})`));
+      this.#pendingEvals.clear(), this.process.kill(signal);
+    }
+  }
+  async eval(fn, ctx) {
+    let nonce = crypto.randomUUID();
+    return new Promise((resolve2, reject) => {
+      let timeoutId = setTimeout(() => {
+        this.#pendingEvals.delete(nonce), reject(new Error(`Eval timed out after ${EVAL_TIMEOUT}ms`));
+      }, EVAL_TIMEOUT);
+      this.#pendingEvals.set(nonce, {
+        resolve: resolve2,
+        reject,
+        timeout: timeoutId
+      });
+      let context;
+      try {
+        context = JSON.stringify(ctx ?? null);
+      } catch {
+        reject(new Error("Eval context is not serializable"));
+        return;
+      }
+      let script = `(${fn.toString()})(cluster, ${context})`;
+      this.sendIPC({
+        op: "eval",
+        d: { nonce, script }
+      });
+    });
+  }
+  send(idOrPayload, payload) {
+    let hasShardId = typeof idOrPayload == "number" && payload !== void 0, shardId = hasShardId ? idOrPayload : void 0, data = hasShardId ? payload : idOrPayload;
+    this.sendIPC({
+      op: "send",
+      d: { shardId, data }
+    });
+  }
+  sendIPC(message) {
+    if (!(!this.process.connected || this.process.killed))
+      try {
+        this.process.send(message, void 0, void 0, (err) => {
+          err && this.emit("error", err);
+        });
+      } catch (err) {
+        this.emit("error", err);
+      }
+  }
+  identifyShard(id) {
+    this.sendIPC({
+      op: "identify",
+      d: id
+    });
+  }
+  #bindProcessEvents() {
+    this.process.on("message", (message) => this.#handleIPC(message)), this.process.on("error", (err) => this.emit("error", err)), this.process.on("disconnect", () => this.emit("debug", "Process disconnected")), this.process.on("exit", (code) => {
+      for (let [nonce, pending] of this.#pendingEvals)
+        clearTimeout(pending.timeout), pending.reject(new Error(`Process exited (code: ${code}) before eval completed (nonce: ${nonce})`));
+      this.#pendingEvals.clear();
+    });
+  }
+  #handleIPC(message) {
+    if (this.#isValidPayload(message)) {
+      if (isDispatchPayload(message)) {
+        this.emit(message.t, ...message.d);
+        return;
+      }
+      if (isEvalResponsePayload(message)) {
+        this.#handleEvalResponse(message);
+        return;
+      }
+    }
+  }
+  #handleEvalResponse(payload) {
+    let pending = this.#pendingEvals.get(payload.d.nonce);
+    if (!pending) {
+      this.emit("debug", `Received eval response for unknown nonce: ${payload.d.nonce}`);
+      return;
+    }
+    if (pending.timeout && clearTimeout(pending.timeout), this.#pendingEvals.delete(payload.d.nonce), payload.d.success)
+      pending.resolve({
+        success: true,
+        data: payload.d.result,
+        cluster: this
+      });
+    else {
+      let error = new Error(payload.d.error ?? "Unknown eval error");
+      pending.resolve({
+        success: false,
+        error,
+        cluster: this
+      });
+    }
+  }
+  #isValidPayload(message) {
+    if (typeof message != "object" || message === null)
+      return false;
+    let payload = message;
+    return payload.op === "dispatch" || payload.op === "identify" || payload.op === "send" || payload.op === "eval" || payload.op === "evalResponse";
+  }
+  static bindProcess(cluster) {
+    let superEmit = cluster.emit.bind(cluster), safeSend = (message) => {
+      process.connected && process.send?.(message, void 0, void 0, (err) => {
+        err && cluster.emit("error", err);
+      });
+    };
+    cluster.emit = function(eventName, ...args) {
+      let result = superEmit(eventName, ...args);
+      return safeSend({
+        op: "dispatch",
+        t: eventName,
+        d: args
+      }), result;
+    };
+    let messageHandler = async (message) => {
+      if (isIdentifyPayload(message)) {
+        cluster.shards.get(message.d)?.identify();
+        return;
+      }
+      if (isSendPayload(message)) {
+        message.d.shardId !== void 0 ? cluster.send(message.d.shardId, message.d.data) : cluster.send(message.d.data);
+        return;
+      }
+      if (isEvalRequestPayload(message)) {
+        await _ClusterProcess.#handleEvalRequest(cluster, message, safeSend);
+        return;
+      }
+    };
+    process.on("message", messageHandler);
+  }
+  static async #handleEvalRequest(cluster, payload, safeSend) {
+    let { nonce, script } = payload.d, executeEval = async () => await new Function("cluster", `return ${script}`)(cluster), timeoutId;
+    try {
+      let evalPromise = executeEval(), timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`Eval execution timed out after ${EVAL_TIMEOUT}ms`));
+        }, EVAL_TIMEOUT);
+      }), result = await Promise.race([evalPromise, timeoutPromise]);
+      timeoutId && clearTimeout(timeoutId), safeSend({
+        op: "evalResponse",
+        d: {
+          nonce,
+          success: !0,
+          result
+        }
+      });
+    } catch (err) {
+      timeoutId && clearTimeout(timeoutId), safeSend({
+        op: "evalResponse",
+        d: {
+          nonce,
+          success: false,
+          result: void 0,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      });
+    }
+  }
+};
+var Cluster = class extends EventEmitter__default.default {
+  constructor(id, options) {
+    super();
+    this.id = id;
+    this.options = options;
+  }
+  shards = new utils.Collection();
+  #readyCount = 0;
+  #starting = false;
+  get size() {
+    return this.shards.size;
+  }
+  get ready() {
+    return this.#readyCount === this.options.shards.length;
+  }
+  async spawn() {
+    if (!this.#starting) {
+      this.#starting = true, this.emit("debug", `Spawning ${this.options.shards.length} shards...`);
+      for (let i of this.options.shards)
+        await this.#spawnShard(i);
+      this.emit("debug", "All shards spawned");
+    }
+  }
+  async shutdown(code = 1e3) {
+    this.emit("debug", "Shutting down cluster...");
+    let tasks = [];
+    for (let shard of this.shards.values())
+      tasks.push(shard.disconnect(code));
+    await Promise.allSettled(tasks), this.emit("debug", "Cluster shutdown complete");
+  }
+  broadcast(fn) {
+    for (let shard of this.shards.values())
+      fn(shard);
+  }
+  send(idOrPayload, payload) {
+    let hasId = typeof idOrPayload == "number" && payload !== void 0, shardId = hasId ? idOrPayload : void 0, data = hasId ? payload : idOrPayload;
+    shardId !== void 0 ? this.shards.get(shardId)?.send(data) : this.broadcast((shard) => shard.send(data));
+  }
+  async #spawnShard(id) {
+    let shard = new Shard(id, {
+      token: this.options.token,
+      intents: this.options.intents,
+      total: this.options.total,
+      gateway: this.options.gateway
+    });
+    this.#bindShardEvents(shard), this.shards.set(id, shard), this.emit("shardAdd", id), await shard.connect();
+  }
+  #bindShardEvents(shard) {
+    let id = shard.id;
+    shard.on("ready", () => {
+      this.#readyCount++, this.emit("debug", `Shard ${id} ready`), this.emit("shardReady", id), this.ready && this.emit("ready");
+    }), shard.on("resume", () => {
+      this.emit("debug", `Shard ${id} resumed`), this.emit("shardResume", id);
+    }), shard.on("disconnect", (code) => {
+      this.emit("debug", `Shard ${id} disconnected (${code})`), this.emit("shardDisconnect", id, code);
+    }), shard.on("error", (err) => {
+      this.emit("debug", `Shard ${id} error: ${err.message}`), this.emit("shardError", id, err);
+    }), shard.on("raw", (payload) => {
+      this.emit("raw", id, payload);
+    }), shard.on("dispatch", (payload) => {
+      this.emit("dispatch", id, payload);
+    }), shard.on("needIdentify", () => {
+      this.emit("needIdentify", id);
+    }), shard.on("debug", (msg) => {
+      this.emit("debug", `[Shard ${id}] ${msg}`);
+    });
+  }
+};
+var ShardingManager = class extends EventEmitter__default.default {
+  clusters = new utils.Collection();
+  options;
+  rest;
+  #gatewayInfo;
+  #totalShards = 0;
+  #readyCount = 0;
+  #identifyQueue;
+  constructor(options, rest$1) {
+    super(), this.setMaxListeners(0), this.options = {
+      shardsPerCluster: 5,
+      totalShards: options.totalShards ?? "auto",
+      ...options
+    }, rest$1 || (rest$1 = new rest.REST({ token: this.options.token })), this.rest = rest$1;
+  }
+  get totalClusters() {
+    let { shardsPerCluster } = this.options;
+    return shardsPerCluster <= 0 ? 0 : Math.ceil(this.totalShards / shardsPerCluster);
+  }
+  get totalShards() {
+    return this.#totalShards;
+  }
+  get ready() {
+    return this.#readyCount === this.totalClusters;
+  }
+  async spawn() {
+    this.#gatewayInfo = await this.rest.get("/gateway/bot");
+    let { session_start_limit: limit } = this.#gatewayInfo;
+    this.#totalShards = typeof this.options.totalShards == "number" ? this.options.totalShards : this.#gatewayInfo.shards, this.#identifyQueue = new utils.Queue({
+      concurrency: limit.max_concurrency,
+      intervalCap: limit.max_concurrency,
+      interval: 5e3
+    });
+    let { totalShards, totalClusters } = this;
+    this.emit("debug", `Spawning ${totalClusters} clusters (${totalShards} total shards)...`);
+    let promises = [];
+    for (let i = 0; i < totalClusters; i++)
+      promises.push(this.#spawnCluster(i));
+    await Promise.all(promises), this.emit("debug", "All clusters spawned");
+  }
+  async kill(signal = "SIGTERM") {
+    this.emit("debug", "Shutting down all clusters...");
+    let tasks = [];
+    for (let cluster of this.clusters.values())
+      tasks.push(
+        new Promise((resolve2) => {
+          cluster.process.once("exit", () => resolve2()), cluster.kill(signal);
+        })
+      );
+    await Promise.all(tasks), this.emit("debug", "All clusters shut down");
+  }
+  broadcast(payload) {
+    for (let cluster of this.clusters.values())
+      cluster.send(payload);
+  }
+  async broadcastEval(fn) {
+    let promises = this.clusters.map((cluster) => cluster.eval(fn));
+    return Promise.all(promises);
+  }
+  requestIdentify(cluster, shardId) {
+    this.#identifyQueue?.add(() => cluster.identifyShard(shardId));
+  }
+  #getShardIdsForCluster(clusterId) {
+    let start = clusterId * this.options.shardsPerCluster, end = Math.min(start + this.options.shardsPerCluster, this.totalShards);
+    return Array.from({ length: end - start }, (_, i) => start + i);
+  }
+  async #spawnCluster(id) {
+    let shardIds = this.#getShardIdsForCluster(id), firstShardId = shardIds[0], lastShardId = shardIds[shardIds.length - 1];
+    this.emit("debug", `Spawning cluster ${id} (shards ${firstShardId}-${lastShardId})`);
+    let env = {
+      ...process.env,
+      BAKIT_CLUSTER_ID: String(id),
+      BAKIT_CLUSTER_SHARD_TOTAL: String(this.totalShards),
+      BAKIT_CLUSTER_SHARD_LIST: JSON.stringify(shardIds),
+      BAKIT_DISCORD_TOKEN: this.options.token,
+      BAKIT_DISCORD_INTENTS: String(this.options.intents),
+      BAKIT_DISCORD_GATEWAY_URL: this.#gatewayInfo?.url,
+      BAKIT_DISCORD_GATEWAY_VERSION: "10"
+    }, cluster = new ClusterProcess(this, id, { env });
+    this.#bindClusterEvents(cluster, id), this.clusters.set(id, cluster), this.emit("clusterCreate", cluster);
+  }
+  #bindClusterEvents(cluster, id) {
+    cluster.on("ready", () => {
+      this.#readyCount++, this.emit("clusterReady", cluster), this.ready && this.emit("ready");
+    }), cluster.process.on("exit", (code) => {
+      this.emit("clusterExit", cluster, code), this.clusters.delete(id), this.#readyCount = Math.max(0, this.#readyCount - 1);
+    }), cluster.on("error", (err) => {
+      this.emit("clusterError", cluster, err);
+    }), cluster.on("debug", (msg) => {
+      this.emit("debug", `[Cluster ${id}] ${msg}`);
+    }), cluster.on("dispatch", (shardId, payload) => {
+      this.emit("dispatch", cluster, shardId, payload);
+    }), cluster.on("raw", (shardId, payload) => {
+      this.emit("raw", cluster, shardId, payload);
+    }), cluster.on("shardAdd", (shardId) => {
+      this.emit("shardAdd", cluster, shardId);
+    }), cluster.on("shardReady", (shardId) => {
+      this.emit("shardReady", cluster, shardId);
+    }), cluster.on("shardDisconnect", (shardId, code) => {
+      this.emit("shardDisconnect", cluster, shardId, code);
+    }), cluster.on("shardResume", (shardId) => {
+      this.emit("shardResume", cluster, shardId);
+    }), cluster.on("shardError", (shardId, error) => {
+      this.emit("shardError", cluster, shardId, error);
+    }), cluster.on("needIdentify", (shardId) => {
+      this.requestIdentify(cluster, shardId);
+    });
+  }
+};
+
+exports.Cluster = Cluster;
+exports.ClusterProcess = ClusterProcess;
+exports.Shard = Shard;
+exports.ShardState = ShardState;
+exports.ShardStrategy = ShardStrategy;
+exports.ShardingManager = ShardingManager;