@bakit/gateway 3.0.2 → 3.0.3

package/dist/index.js

@@ -1,633 +0,0 @@
-import EventEmitter from 'events';
-import { createInflate, constants } from 'zlib';
-import { TextDecoder } from 'util';
-import { randomInt, randomUUID } from 'crypto';
-import WebSocket from 'ws';
-import { GatewayOpcodes, GatewayDispatchEvents, GatewayCloseCodes } from 'discord-api-types/v10';
-import { fork } from 'child_process';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { isCommonJS } from '@bakit/utils';
-import { Collection } from '@discordjs/collection';
-import PQueue from 'p-queue';
-import { REST } from '@bakit/rest';
-
-// 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 {
-  constructor(id, options) {
-    super();
-    this.id = id;
-    this.options = options;
-  }
-  #state = 0 /* Idle */;
-  #ws;
-  #inflater;
-  #textDecoder = new 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: GatewayOpcodes.Resume,
-      d: {
-        token: this.options.token,
-        session_id: this.#sessionId,
-        seq: this.#lastSequence
-      }
-    }));
-  }
-  identify() {
-    this.send({
-      op: 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.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: 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(url, { perMessageDeflate: false }), this.#inflater = createInflate({ flush: 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(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 GatewayOpcodes.Dispatch: {
-        this.#handleDispatch(payload);
-        break;
-      }
-      case GatewayOpcodes.Hello: {
-        this.#startHeartbeat(payload.d.heartbeat_interval), this.resumable ? this.resume() : this.emit("needIdentify");
-        break;
-      }
-      case GatewayOpcodes.Heartbeat: {
-        this.sendHeartbeat();
-        break;
-      }
-      case GatewayOpcodes.HeartbeatAck: {
-        this.#lastHeartbeatAck = Date.now();
-        break;
-      }
-      case 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 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 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 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 GatewayCloseCodes.AuthenticationFailed:
-          this.emit("error", new Error("Invalid token provided"));
-          break;
-        case GatewayCloseCodes.InvalidIntents:
-          this.emit("error", new Error("Invalid intents provided"));
-          break;
-        case 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 GatewayCloseCodes.AuthenticationFailed:
-      case GatewayCloseCodes.InvalidIntents:
-      case GatewayCloseCodes.DisallowedIntents:
-        return 2 /* Shutdown */;
-      case GatewayCloseCodes.InvalidSeq:
-      case 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 = 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 = fileURLToPath(import.meta.url), __dirname$1 = 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 {
-  constructor(manager, id, options = {}) {
-    super();
-    this.manager = manager;
-    this.id = id;
-    this.setMaxListeners(0);
-    let entry = resolve(__dirname$1, isCommonJS() ? "cluster.cjs" : "cluster.js");
-    this.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 = 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 {
-  constructor(id, options) {
-    super();
-    this.id = id;
-    this.options = options;
-  }
-  shards = new 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 {
-  clusters = new Collection();
-  options;
-  rest;
-  #gatewayInfo;
-  #totalShards = 0;
-  #readyCount = 0;
-  #identifyQueue;
-  constructor(options, rest) {
-    super(), this.setMaxListeners(0), this.options = {
-      shardsPerCluster: 5,
-      totalShards: options.totalShards ?? "auto",
-      ...options
-    }, rest || (rest = new REST({ token: this.options.token })), this.rest = rest;
-  }
-  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({
-      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);
-    });
-  }
-};
-
-export { Cluster, ClusterProcess, Shard, ShardState, ShardStrategy, ShardingManager };