@bakit/gateway 3.0.0 → 3.0.2

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

@@ -20,4 +20,4 @@ var {
   }
 });
 ClusterProcess.bindProcess(cluster);
-await cluster.spawn();
+cluster.spawn();

package/dist/index.cjs

@@ -0,0 +1,647 @@
+'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 collection = require('@discordjs/collection');
+var PQueue = require('p-queue');
+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);
+var PQueue__default = /*#__PURE__*/_interopDefault(PQueue);
+
+// 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();
+  #shards = /* @__PURE__ */ new Set();
+  get shards() {
+    return new Set(this.#shards);
+  }
+  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.#handleDispatchPayload(message);
+        return;
+      }
+      if (isEvalResponsePayload(message)) {
+        this.#handleEvalResponse(message);
+        return;
+      }
+    }
+  }
+  #handleDispatchPayload(payload) {
+    payload.t === "shardAdd" && this.#shards.add(payload.d[0]), this.emit(payload.t, ...payload.d);
+  }
+  #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 collection.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 collection.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.totalClusters > 0 && 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 PQueue__default.default({
+      concurrency: limit.max_concurrency,
+      intervalCap: limit.max_concurrency,
+      interval: 5e3
+    });
+    let { totalShards, totalClusters } = this;
+    this.emit("debug", `Spawning ${totalClusters} clusters (${totalShards} total shards)...`);
+    for (let i = 0; i < totalClusters; i++)
+      this.#spawnCluster(i);
+    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);
+  }
+  send(shardId, payload) {
+    let cluster = this.clusters.find((cluster2) => cluster2.shards.has(shardId));
+    if (!cluster)
+      throw new Error(`Shard ${shardId} not found`);
+    cluster.send(payload);
+  }
+  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);
+  }
+  #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;

package/dist/index.d.cts

@@ -0,0 +1,203 @@
+import EventEmitter from 'node:events';
+import { GatewayReadyDispatchData, GatewayReceivePayload, GatewayDispatchPayload, GatewaySendPayload } from 'discord-api-types/v10';
+import { ChildProcess } from 'node:child_process';
+import { Collection } from '@discordjs/collection';
+import { RESTLike } from '@bakit/rest';
+
+declare enum ShardState {
+    Idle = 0,
+    Connecting = 1,
+    Ready = 2,
+    Resuming = 3,
+    Disconnecting = 4,
+    Disconnected = 5
+}
+declare enum ShardStrategy {
+    Resume = 0,
+    Reconnect = 1,
+    Shutdown = 2
+}
+interface ShardOptions {
+    total: number;
+    token: string;
+    intents: number | bigint;
+    gateway: {
+        baseURL: string;
+        version: number;
+    };
+}
+interface ShardEvents {
+    ready: [data: GatewayReadyDispatchData];
+    disconnect: [code: number];
+    resume: [];
+    error: [error: Error];
+    debug: [message: string];
+    raw: [payload: GatewayReceivePayload];
+    dispatch: [payload: GatewayDispatchPayload];
+    needIdentify: [];
+}
+declare class Shard extends EventEmitter<ShardEvents> {
+    #private;
+    readonly id: number;
+    readonly options: ShardOptions;
+    constructor(id: number, options: ShardOptions);
+    get state(): ShardState;
+    get latency(): number;
+    get resumable(): boolean;
+    connect(): Promise<void>;
+    disconnect(code: number): Promise<void>;
+    resume(): void;
+    identify(): void;
+    send(payload: GatewaySendPayload): void;
+    sendHeartbeat(): void;
+}
+
+interface ClusterOptions {
+    token: string;
+    intents: bigint | number;
+    shards: number[];
+    total: number;
+    gateway: {
+        baseURL: string;
+        version: number;
+    };
+}
+interface ClusterEvents {
+    shardAdd: [id: number];
+    shardReady: [id: number];
+    shardDisconnect: [id: number, code: number];
+    shardResume: [id: number];
+    shardError: [id: number, error: Error];
+    needIdentify: [id: number];
+    debug: [message: string];
+    dispatch: [shardId: number, payload: GatewayDispatchPayload];
+    raw: [shardId: number, payload: GatewayReceivePayload];
+    ready: [];
+    error: [error: Error];
+}
+declare class Cluster extends EventEmitter<ClusterEvents> {
+    #private;
+    readonly id: number;
+    readonly options: ClusterOptions;
+    readonly shards: Collection<number, Shard>;
+    constructor(id: number, options: ClusterOptions);
+    get size(): number;
+    get ready(): boolean;
+    spawn(): Promise<void>;
+    shutdown(code?: number): Promise<void>;
+    broadcast(fn: (shard: Shard) => void): void;
+    send(payload: GatewaySendPayload): void;
+    send(shardId: number, payload: GatewaySendPayload): void;
+}
+
+interface ShardingManagerOptions {
+    token: string;
+    intents: bigint | number;
+    totalShards?: number | "auto";
+    shardsPerCluster?: number;
+}
+interface ShardingManagerEvents {
+    shardAdd: [cluster: ClusterProcess, shardId: number];
+    shardReady: [cluster: ClusterProcess, shardId: number];
+    shardDisconnect: [cluster: ClusterProcess, shardId: number, code: number];
+    shardResume: [cluster: ClusterProcess, shardId: number];
+    shardError: [cluster: ClusterProcess, shardId: number, error: Error];
+    clusterCreate: [cluster: ClusterProcess];
+    clusterReady: [cluster: ClusterProcess];
+    clusterExit: [cluster: ClusterProcess, code: number | null];
+    clusterError: [cluster: ClusterProcess, error: Error];
+    dispatch: [cluster: ClusterProcess, shardId: number, payload: GatewayDispatchPayload];
+    raw: [cluster: ClusterProcess, shardId: number, payload: GatewayReceivePayload];
+    debug: [message: string];
+    ready: [];
+}
+declare class ShardingManager extends EventEmitter<ShardingManagerEvents> {
+    #private;
+    readonly clusters: Collection<number, ClusterProcess>;
+    readonly options: Required<ShardingManagerOptions>;
+    readonly rest: RESTLike;
+    constructor(options: ShardingManagerOptions, rest?: RESTLike);
+    get totalClusters(): number;
+    get totalShards(): number;
+    get ready(): boolean;
+    spawn(): Promise<void>;
+    kill(signal?: NodeJS.Signals): Promise<void>;
+    broadcast(payload: GatewaySendPayload): void;
+    broadcastEval<T>(fn: (cluster: Cluster) => T | Promise<T>): Promise<EvalResult<T>[]>;
+    send(shardId: number, payload: GatewaySendPayload): void;
+    protected requestIdentify(cluster: ClusterProcess, shardId: number): void;
+}
+
+type ClusterIPCDispatchPayload<E extends keyof ClusterEvents = keyof ClusterEvents> = {
+    op: "dispatch";
+    t: E;
+    d: ClusterEvents[E];
+};
+interface ClusterIPCIdentifyPayload {
+    op: "identify";
+    d: number;
+}
+interface ClusterIPCGatewaySendPayload {
+    op: "send";
+    d: {
+        shardId?: number;
+        data: GatewaySendPayload;
+    };
+}
+interface ClusterIPCEvalRequestPayload {
+    op: "eval";
+    d: {
+        nonce: string;
+        script: string;
+    };
+}
+interface ClusterIPCEvalResponsePayload {
+    op: "evalResponse";
+    d: {
+        nonce: string;
+        success: boolean;
+        result: unknown;
+        error?: string;
+    };
+}
+type ClusterIPCPayload = ClusterIPCDispatchPayload | ClusterIPCIdentifyPayload | ClusterIPCGatewaySendPayload | ClusterIPCEvalRequestPayload | ClusterIPCEvalResponsePayload;
+interface EvalResult<T> {
+    /**
+     * Whether the evaluation was successful
+     */
+    success: boolean;
+    /**
+     * The result of the evaluation if successful
+     */
+    data?: T;
+    /**
+     * The error if evaluation failed
+     */
+    error?: Error;
+    /**
+     * The cluster process that executed the evaluation
+     */
+    cluster: ClusterProcess;
+}
+interface ClusterProcessOptions {
+    env?: NodeJS.ProcessEnv;
+    execArgv?: string[];
+}
+declare class ClusterProcess extends EventEmitter<ClusterEvents> {
+    #private;
+    readonly manager: ShardingManager;
+    readonly id: number;
+    readonly process: ChildProcess;
+    constructor(manager: ShardingManager, id: number, options?: ClusterProcessOptions);
+    get shards(): Set<number>;
+    get killed(): boolean;
+    kill(signal?: NodeJS.Signals): void;
+    eval<T, C = unknown>(fn: (cluster: Cluster, ctx: C) => T | Promise<T>, ctx?: C): Promise<EvalResult<T>>;
+    send(payload: GatewaySendPayload): void;
+    send(shardId: number, payload: GatewaySendPayload): void;
+    sendIPC(message: ClusterIPCPayload): void;
+    identifyShard(id: number): void;
+    static bindProcess(cluster: Cluster): void;
+}
+
+export { Cluster, type ClusterEvents, type ClusterIPCDispatchPayload, type ClusterIPCEvalRequestPayload, type ClusterIPCEvalResponsePayload, type ClusterIPCGatewaySendPayload, type ClusterIPCIdentifyPayload, type ClusterIPCPayload, type ClusterOptions, ClusterProcess, type ClusterProcessOptions, type EvalResult, Shard, type ShardEvents, type ShardOptions, ShardState, ShardStrategy, ShardingManager, type ShardingManagerEvents, type ShardingManagerOptions };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import EventEmitter from 'node:events';
 import { GatewayReadyDispatchData, GatewayReceivePayload, GatewayDispatchPayload, GatewaySendPayload } from 'discord-api-types/v10';
 import { ChildProcess } from 'node:child_process';
-import { Collection } from '@bakit/utils';
-import { REST, RESTProxy } from '@bakit/rest';
+import { Collection } from '@discordjs/collection';
+import { RESTLike } from '@bakit/rest';
 
 declare enum ShardState {
     Idle = 0,
@@ -115,8 +115,8 @@ declare class ShardingManager extends EventEmitter<ShardingManagerEvents> {
     #private;
     readonly clusters: Collection<number, ClusterProcess>;
     readonly options: Required<ShardingManagerOptions>;
-    readonly rest: REST | RESTProxy;
-    constructor(options: ShardingManagerOptions, rest?: REST | RESTProxy);
+    readonly rest: RESTLike;
+    constructor(options: ShardingManagerOptions, rest?: RESTLike);
     get totalClusters(): number;
     get totalShards(): number;
     get ready(): boolean;
@@ -124,6 +124,7 @@ declare class ShardingManager extends EventEmitter<ShardingManagerEvents> {
     kill(signal?: NodeJS.Signals): Promise<void>;
     broadcast(payload: GatewaySendPayload): void;
     broadcastEval<T>(fn: (cluster: Cluster) => T | Promise<T>): Promise<EvalResult<T>[]>;
+    send(shardId: number, payload: GatewaySendPayload): void;
     protected requestIdentify(cluster: ClusterProcess, shardId: number): void;
 }
 
@@ -188,6 +189,7 @@ declare class ClusterProcess extends EventEmitter<ClusterEvents> {
     readonly id: number;
     readonly process: ChildProcess;
     constructor(manager: ShardingManager, id: number, options?: ClusterProcessOptions);
+    get shards(): Set<number>;
     get killed(): boolean;
     kill(signal?: NodeJS.Signals): void;
     eval<T, C = unknown>(fn: (cluster: Cluster, ctx: C) => T | Promise<T>, ctx?: C): Promise<EvalResult<T>>;

package/dist/index.js

@@ -7,7 +7,9 @@ import { GatewayOpcodes, GatewayDispatchEvents, GatewayCloseCodes } from 'discor
 import { fork } from 'child_process';
 import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { Collection, Queue } from '@bakit/utils';
+import { isCommonJS } from '@bakit/utils';
+import { Collection } from '@discordjs/collection';
+import PQueue from 'p-queue';
 import { REST } from '@bakit/rest';
 
 // src/lib/Shard.ts
@@ -266,7 +268,7 @@ var ClusterProcess = class _ClusterProcess extends EventEmitter {
     this.manager = manager;
     this.id = id;
     this.setMaxListeners(0);
-    let entry = resolve(__dirname$1, "cluster.js");
+    let entry = resolve(__dirname$1, isCommonJS() ? "cluster.cjs" : "cluster.js");
     this.process = fork(entry, {
       env: options.env,
       execArgv: options.execArgv,
@@ -275,6 +277,10 @@ var ClusterProcess = class _ClusterProcess extends EventEmitter {
   }
   process;
   #pendingEvals = /* @__PURE__ */ new Map();
+  #shards = /* @__PURE__ */ new Set();
+  get shards() {
+    return new Set(this.#shards);
+  }
   get killed() {
     return this.process.killed || !this.process.connected;
   }
@@ -343,7 +349,7 @@ var ClusterProcess = class _ClusterProcess extends EventEmitter {
   #handleIPC(message) {
     if (this.#isValidPayload(message)) {
       if (isDispatchPayload(message)) {
-        this.emit(message.t, ...message.d);
+        this.#handleDispatchPayload(message);
         return;
       }
       if (isEvalResponsePayload(message)) {
@@ -352,6 +358,9 @@ var ClusterProcess = class _ClusterProcess extends EventEmitter {
       }
     }
   }
+  #handleDispatchPayload(payload) {
+    payload.t === "shardAdd" && this.#shards.add(payload.d[0]), this.emit(payload.t, ...payload.d);
+  }
   #handleEvalResponse(payload) {
     let pending = this.#pendingEvals.get(payload.d.nonce);
     if (!pending) {
@@ -529,22 +538,21 @@ var ShardingManager = class extends EventEmitter {
     return this.#totalShards;
   }
   get ready() {
-    return this.#readyCount === this.totalClusters;
+    return this.totalClusters > 0 && 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 Queue({
+    this.#totalShards = typeof this.options.totalShards == "number" ? this.options.totalShards : this.#gatewayInfo.shards, this.#identifyQueue = new PQueue({
       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");
+      this.#spawnCluster(i);
+    this.emit("debug", "All clusters spawned");
   }
   async kill(signal = "SIGTERM") {
     this.emit("debug", "Shutting down all clusters...");
@@ -565,6 +573,12 @@ var ShardingManager = class extends EventEmitter {
     let promises = this.clusters.map((cluster) => cluster.eval(fn));
     return Promise.all(promises);
   }
+  send(shardId, payload) {
+    let cluster = this.clusters.find((cluster2) => cluster2.shards.has(shardId));
+    if (!cluster)
+      throw new Error(`Shard ${shardId} not found`);
+    cluster.send(payload);
+  }
   requestIdentify(cluster, shardId) {
     this.#identifyQueue?.add(() => cluster.identifyShard(shardId));
   }
@@ -572,7 +586,7 @@ var ShardingManager = class extends EventEmitter {
     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) {
+  #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 = {

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@bakit/gateway",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Gateway manager for bakit framework",
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [
@@ -28,11 +34,13 @@
   "author": "louiszn",
   "license": "MIT",
   "dependencies": {
-    "discord-api-types": "^0.38.37",
+    "@discordjs/collection": "^2.1.1",
+    "discord-api-types": "^0.38.38",
+    "p-queue": "^9.1.0",
     "type-fest": "^4.41.0",
     "ws": "^8.19.0",
-    "@bakit/utils": "^2.2.0",
-    "@bakit/rest": "^3.0.0"
+    "@bakit/rest": "^3.0.2",
+    "@bakit/utils": "^3.0.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"