@bakit/gateway 2.1.9 → 3.0.1

package/dist/index.js

@@ -1,486 +1,619 @@
-import { WebSocket } from 'ws';
+import EventEmitter from 'events';
 import { createInflate, constants } from 'zlib';
-import { attachEventBus, Collection, createQueue } from '@bakit/utils';
-import { GatewayOpcodes, GatewayCloseCodes, GatewayDispatchEvents } from 'discord-api-types/gateway';
-import { fileURLToPath } from 'url';
+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 '@bakit/rest';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { isCommonJS, Collection, Queue } from '@bakit/utils';
+import { REST } from '@bakit/rest';
 
-// src/lib/shard.ts
-var DEFAULT_SHARD_OPTIONS = {
-  gateway: {
-    baseURL: "wss://gateway.discord.gg",
-    version: 10
-  }
-}, ShardState = {
-  /** Not connected. */
-  Idle: 0,
-  /** Initialzing connection. */
-  Connecting: 1,
-  /** Connected to gateway and identified. */
-  Ready: 2,
-  /** Resuming the session. */
-  Resuming: 3,
-  /** Disconnected the connection. */
-  Disconnected: 4
-}, ShardStrategy = {
-  /** No decision yet (default on close). */
-  Unknown: 1,
-  /** Reconnect with IDENTIFY (new session). */
-  Reconnect: 2,
-  /** Reconnect and try RESUME. */
-  Resume: 3,
-  /** Do not reconnect. */
-  Shutdown: 4
-};
-function createShard(options) {
-  let resolvedOptions = { ...DEFAULT_SHARD_OPTIONS, ...options }, textDecoder = new TextDecoder(), state = ShardState.Idle, strategy = ShardStrategy.Unknown, ws, resumeGatewayURL, inflater, decompressBuffer = [], sessionId, lastSequence, lastHeartbeatSent = -1, lastHeartbeatAcknowledged = -1, missedHeartbeats = 0, reconnectTimeout, heartbeatTimeout, heartbeatInterval, self = attachEventBus({
-    send,
-    connect,
-    disconnect,
-    identify,
-    get id() {
-      return options.id;
-    },
-    get state() {
-      return state;
-    },
-    get latency() {
-      return lastHeartbeatSent === -1 || lastHeartbeatAcknowledged === -1 ? -1 : lastHeartbeatAcknowledged - lastHeartbeatSent;
-    }
-  });
-  function init() {
-    if (state !== ShardState.Idle && state !== ShardState.Disconnected) {
-      self.emit("error", new Error("Shard is already connected or connecting."));
-      return;
-    }
-    if (strategy === ShardStrategy.Shutdown)
-      return;
-    state = ShardState.Connecting;
-    let { gateway } = resolvedOptions, baseURL = isResumable() && resumeGatewayURL ? resumeGatewayURL : gateway.baseURL, url = new URL(baseURL);
-    url.searchParams.set("v", gateway.version.toString()), url.searchParams.set("encoding", "json"), url.searchParams.set("compress", "zlib-stream"), ws = new WebSocket(url.toString(), {
-      perMessageDeflate: false
-    }), inflater = createInflate({
-      flush: constants.Z_SYNC_FLUSH
-    }), inflater.on("data", onInflate), inflater.on("error", (err) => {
-      self.emit("error", err), ws?.terminate();
-    }), ws.on("message", onMessage), ws.on("close", onClose), ws.on("error", (err) => self.emit("error", err));
-  }
-  function cleanup() {
-    heartbeatInterval && (clearInterval(heartbeatInterval), heartbeatInterval = void 0), heartbeatTimeout && (clearTimeout(heartbeatTimeout), heartbeatTimeout = void 0), reconnectTimeout && (clearTimeout(reconnectTimeout), reconnectTimeout = void 0), inflater && (inflater.destroy(), inflater = void 0), ws && (ws.readyState !== WebSocket.CLOSED && ws.terminate(), ws.removeAllListeners(), ws = void 0), decompressBuffer = [], missedHeartbeats = 0, lastHeartbeatSent = -1, lastHeartbeatAcknowledged = -1;
-  }
-  function connect() {
-    return new Promise((resolve) => {
-      state !== ShardState.Idle && state !== ShardState.Disconnected || (strategy = ShardStrategy.Unknown, self.once("ready", () => resolve()), init());
+// 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();
     });
   }
-  function disconnect(code = 1e3) {
-    return new Promise((resolve) => {
-      if (strategy = ShardStrategy.Shutdown, !ws) {
-        resolve();
+  disconnect(code) {
+    return new Promise((resolve2) => {
+      if (this.#state = 4 /* Disconnecting */, this.#strategy = 2 /* Shutdown */, !this.#ws) {
+        resolve2();
         return;
       }
-      ws.once("close", () => {
-        resolve();
-      }), ws.close(code);
+      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]
+      }
     });
   }
-  function onMessage(data) {
-    if (!inflater) {
+  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);
-        handlePayload(payload);
+        this.#handlePayload(payload);
       } catch (error) {
-        self.emit("error", 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;
-    inflater.write(buffer, (writeError) => {
+    this.#inflater.write(buffer, (writeError) => {
       if (writeError) {
-        self.emit("error", writeError);
+        this.emit("error", writeError);
         return;
       }
-      hasSyncFlush && inflater?.flush(constants.Z_SYNC_FLUSH);
+      hasSyncFlush && this.#inflater?.flush(constants.Z_SYNC_FLUSH);
     });
   }
-  function onInflate(chunk) {
-    decompressBuffer.push(chunk);
+  #onInflate(chunk) {
+    this.#decompressBuffer.push(chunk);
+    let fullBuffer = Buffer.concat(this.#decompressBuffer);
     try {
-      let fullBuffer = Buffer.concat(decompressBuffer), text = textDecoder.decode(fullBuffer), payload = JSON.parse(text);
-      handlePayload(payload), decompressBuffer = [];
+      let text = this.#textDecoder.decode(fullBuffer), payload = JSON.parse(text);
+      this.#handlePayload(payload), this.#decompressBuffer = [];
     } catch (error) {
       if (error instanceof SyntaxError) {
-        let fullBuffer = Buffer.concat(decompressBuffer), text = textDecoder.decode(fullBuffer);
+        let text = this.#textDecoder.decode(fullBuffer);
         if (text.includes("{") && !isValidJSON(text))
           return;
-        self.emit("error", error), decompressBuffer = [];
-      }
-    }
-  }
-  function isValidJSON(str) {
-    try {
-      return JSON.parse(str), !0;
-    } catch {
-      return false;
-    }
-  }
-  function onClose(code) {
-    if (cleanup(), state = ShardState.Disconnected, self.emit("disconnect", code), strategy === ShardStrategy.Shutdown) {
-      switch (code) {
-        case GatewayCloseCodes.AuthenticationFailed:
-          self.emit("error", new Error("Invalid token provided"));
-          break;
-        case GatewayCloseCodes.InvalidIntents:
-          self.emit("error", new Error("Invalid intents provided"));
-          break;
-        case GatewayCloseCodes.DisallowedIntents:
-          self.emit("error", new Error("Disallowed intents provided"));
-          break;
+        this.emit("error", error), this.#decompressBuffer = [];
       }
-      return;
     }
-    strategy === ShardStrategy.Unknown && (strategy = getReconnectStrategy(code)), (strategy === ShardStrategy.Reconnect || strategy === ShardStrategy.Resume) && scheduleReconnect();
   }
-  function handlePayload(payload) {
-    switch (self.emit("raw", payload), payload.op) {
+  #handlePayload(payload) {
+    switch (this.emit("raw", payload), payload.op) {
       case GatewayOpcodes.Dispatch: {
-        handleDispatch(payload);
+        this.#handleDispatch(payload);
         break;
       }
       case GatewayOpcodes.Hello: {
-        startHeartbeat(payload.d.heartbeat_interval), isResumable() ? resume() : self.emit("requestIdentify");
+        this.#startHeartbeat(payload.d.heartbeat_interval), this.resumable ? this.resume() : this.emit("needIdentify");
         break;
       }
       case GatewayOpcodes.Heartbeat: {
-        sendHeartbeat();
+        this.sendHeartbeat();
         break;
       }
       case GatewayOpcodes.HeartbeatAck: {
-        lastHeartbeatAcknowledged = Date.now();
+        this.#lastHeartbeatAck = Date.now();
         break;
       }
       case GatewayOpcodes.InvalidSession: {
-        payload.d ? strategy = ShardStrategy.Resume : (strategy = ShardStrategy.Reconnect, sessionId = void 0, lastSequence = void 0, resumeGatewayURL = void 0), self.emit("debug", `Invalid session (resumable=${isResumable()})`), ws?.terminate();
+        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: {
-        strategy = ShardStrategy.Resume, self.emit("debug", "Reconnecting to gateway"), ws?.terminate();
+        this.#strategy = 0 /* Resume */, this.emit("debug", "Reconnecting to gateway"), this.#ws?.terminate();
         break;
       }
     }
   }
-  function handleDispatch(payload) {
-    switch (lastSequence = payload.s, self.emit("dispatch", payload), payload.t) {
+  #handleDispatch(payload) {
+    switch (this.#lastSequence = payload.s, this.emit("dispatch", payload), payload.t) {
       case GatewayDispatchEvents.Ready: {
         let { d: data } = payload;
-        state = ShardState.Ready, sessionId = data.session_id, resumeGatewayURL = data.resume_gateway_url, self.emit("ready", data);
+        this.#state = 2 /* Ready */, this.#sessionId = data.session_id, this.#resumeGatewayURL = data.resume_gateway_url, this.emit("ready", data);
         break;
       }
       case GatewayDispatchEvents.Resumed: {
-        state = ShardState.Ready, strategy = ShardStrategy.Unknown, self.emit("resume");
+        this.#state = 2 /* Ready */, this.#strategy = void 0, this.emit("resume");
         break;
       }
     }
   }
-  function isResumable() {
-    let hasSessionId = sessionId !== void 0, hasSequence = lastSequence !== void 0;
-    return strategy === ShardStrategy.Resume && hasSequence && hasSessionId;
+  #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();
   }
-  function getReconnectStrategy(code) {
+  #getStrategy(code) {
     switch (code) {
       case GatewayCloseCodes.AuthenticationFailed:
       case GatewayCloseCodes.InvalidIntents:
       case GatewayCloseCodes.DisallowedIntents:
-        return ShardStrategy.Shutdown;
+        return 2 /* Shutdown */;
       case GatewayCloseCodes.InvalidSeq:
       case GatewayCloseCodes.SessionTimedOut:
-        return ShardStrategy.Reconnect;
+        return 1 /* Reconnect */;
       default:
-        return ShardStrategy.Resume;
+        return 0 /* Resume */;
     }
   }
-  function identify() {
-    send({
-      op: GatewayOpcodes.Identify,
-      d: {
-        token: resolvedOptions.token,
-        intents: Number(resolvedOptions.intents),
-        properties: {
-          os: process.platform,
-          browser: "bakit",
-          device: "bakit"
-        },
-        shard: [resolvedOptions.id, resolvedOptions.total]
+  #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();
+  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 }
+      });
     });
   }
-  function resume() {
-    state = ShardState.Resuming, send({
-      op: GatewayOpcodes.Resume,
-      d: {
-        token: resolvedOptions.token,
-        session_id: sessionId,
-        seq: lastSequence
-      }
+  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 }
     });
   }
-  function sendHeartbeat() {
-    if (lastHeartbeatSent !== -1 && lastHeartbeatAcknowledged < lastHeartbeatSent ? missedHeartbeats++ : missedHeartbeats = 0, missedHeartbeats >= 2) {
-      self.emit("debug", "Missed 2 heartbeats, reconnecting"), ws?.terminate();
-      return;
-    }
-    send({
-      op: GatewayOpcodes.Heartbeat,
-      d: lastSequence ?? null
-    }), lastHeartbeatSent = Date.now();
-  }
-  function startHeartbeat(interval) {
-    heartbeatInterval && (clearInterval(heartbeatInterval), heartbeatInterval = void 0);
-    let jitter = Math.random(), firstDelay = Math.floor(interval * jitter);
-    self.emit("debug", `Starting heartbeat (interval=${interval}ms, jitter=${firstDelay}ms)`), heartbeatTimeout = setTimeout(() => {
-      sendHeartbeat(), heartbeatInterval = setInterval(sendHeartbeat, interval);
-    }, firstDelay);
+  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);
+      }
   }
-  function scheduleReconnect(delay = 1e3) {
-    reconnectTimeout || (reconnectTimeout = setTimeout(() => {
-      reconnectTimeout = void 0, state = ShardState.Idle, init();
-    }, delay));
+  identifyShard(id) {
+    this.sendIPC({
+      op: "identify",
+      d: id
+    });
   }
-  function send(payload) {
-    ws?.readyState === WebSocket.OPEN && ws.send(JSON.stringify(payload));
+  #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();
+    });
   }
-  return self;
-}
-var GatewayWorkerState = {
-  Idle: 0,
-  Starting: 1,
-  Ready: 2,
-  Degraded: 3,
-  Stopped: 4
-};
-function createWorker(options) {
-  let shards = new Collection(), state = GatewayWorkerState.Idle, readyShards = /* @__PURE__ */ new Set(), self = attachEventBus({
-    get id() {
-      return options.id;
-    },
-    get shards() {
-      return shards;
-    },
-    get shardIds() {
-      return [...options.shards];
-    },
-    get latency() {
-      let count = 0, sumLatency = shards.reduce((acc, shard) => shard.latency === -1 ? acc : (count++, acc + shard.latency), 0);
-      return count === 0 ? -1 : sumLatency / count;
-    },
-    get state() {
-      return state;
-    },
-    start,
-    stop,
-    broadcast
-  });
-  async function start() {
-    if (!(state !== GatewayWorkerState.Idle && state !== GatewayWorkerState.Stopped)) {
-      state = GatewayWorkerState.Starting;
-      for (let id of options.shards) {
-        let shard = createShard({
-          id,
-          token: options.token,
-          intents: options.intents,
-          total: options.total,
-          gateway: {
-            baseURL: options.gatewayURL,
-            version: 10
-          }
-        });
-        shards.set(id, shard), shard.on("ready", (data) => {
-          if (readyShards.add(id), self.emit("shardReady", id, data), state !== GatewayWorkerState.Ready && readyShards.size === options.shards.length) {
-            let wasDegraded = state === GatewayWorkerState.Degraded;
-            state = GatewayWorkerState.Ready, self.emit(wasDegraded ? "resume" : "ready");
-          }
-        }), shard.on("disconnect", (code) => {
-          readyShards.delete(id), self.emit("shardDisconnect", id, code), state !== GatewayWorkerState.Starting && state !== GatewayWorkerState.Degraded && readyShards.size < options.shards.length && (state = GatewayWorkerState.Degraded, self.emit("degrade", readyShards.size, options.shards.length));
-        }), shard.on("raw", (payload) => self.emit("shardRaw", id, payload)), shard.on("dispatch", (payload) => self.emit("shardDispatch", id, payload)), shard.on("error", (err) => self.emit("error", err)), shard.on("debug", (msg) => self.emit("debug", `[Shard ${id}] ${msg}`)), shard.on("requestIdentify", () => self.emit("shardRequestIdentify", id)), shard.connect();
+  #handleIPC(message) {
+    if (this.#isValidPayload(message)) {
+      if (isDispatchPayload(message)) {
+        this.emit(message.t, ...message.d);
+        return;
+      }
+      if (isEvalResponsePayload(message)) {
+        this.#handleEvalResponse(message);
+        return;
       }
     }
   }
-  async function stop(code = 1e3) {
-    await Promise.all(shards.map((shard) => shard.disconnect(code))), state = GatewayWorkerState.Stopped, shards.clear(), readyShards.clear(), self.emit("stop");
+  #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
+      });
+    }
   }
-  function broadcast(payload) {
-    for (let shard of shards.values())
-      shard.state === ShardState.Ready && shard.send(payload);
+  #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";
   }
-  return self;
-}
-function bindWorkerToProcess(worker) {
-  worker.on("shardRaw", (shardId, payload) => send("shardRaw", { shardId, payload })), worker.on("shardDispatch", (shardId, payload) => send("shardDispatch", { shardId, payload })), worker.on("shardReady", (shardId, payload) => send("shardReady", { shardId, payload })), worker.on("shardDisconnect", (shardId, code) => send("shardDisconnect", { shardId, code })), worker.on("shardRequestIdentify", (shardId) => send("shardRequestIdentify", { shardId })), worker.on("ready", () => send("ready", {})), worker.on("stop", () => send("stop", {})), worker.on("error", (error) => {
-    send("workerError", {
-      error: { message: error.message, stack: error.stack }
-    });
-  });
-  function send(type, payload) {
-    process.send && process.connected && process.send({ type, ...payload });
-  }
-  process.on("SIGINT", () => {
-  }), process.on("SIGTERM", async () => {
-    await worker.stop(1e3), process.exit(0);
-  }), process.on("message", (message) => {
-    switch (message.type) {
-      case "identifyShard": {
-        worker.shards.get(message.shardId)?.identify();
-        break;
+  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;
       }
-      case "broadcast": {
-        worker.broadcast(message.payload);
-        break;
+      if (isSendPayload(message)) {
+        message.d.shardId !== void 0 ? cluster.send(message.d.shardId, message.d.data) : cluster.send(message.d.data);
+        return;
       }
-      case "sendToShard": {
-        worker.shards.get(message.shardId)?.send(message.payload);
-        break;
+      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)
+        }
+      });
     }
-  });
-}
-function getWorkerOptions() {
-  let { WORKER_DATA } = process.env;
-  if (!WORKER_DATA)
-    throw new Error("WORKER_DATA is not set");
-  return JSON.parse(WORKER_DATA);
-}
-var DEFAULT_WORKER_PATH = fileURLToPath(new URL("./services/worker.js", import.meta.url)), DEFAULT_GATEWAY_MANAGER_OPTIONS = {
-  gatewayURL: "wss://gateway.discord.gg",
-  totalShards: "auto",
-  shardsPerWorker: 5
+  }
 };
-function createGatewayManager(options, rest) {
-  let opts = {
-    ...DEFAULT_GATEWAY_MANAGER_OPTIONS,
-    ...options
-  }, identifyQueue, workers = new Collection(), self = attachEventBus({
-    get rest() {
-      return rest;
-    },
-    spawn,
-    broadcast,
-    sendToWorker,
-    sendToShard
-  });
-  async function spawn() {
-    let gatewayBotInfo = await rest.get("/gateway/bot"), { session_start_limit: limit } = gatewayBotInfo, totalShards = opts.totalShards === "auto" ? gatewayBotInfo.shards : opts.totalShards, totalWorkers = Math.ceil(totalShards / opts.shardsPerWorker);
-    if (limit.remaining < totalShards) {
-      let error = new Error(
-        [
-          "Not enough remaining gateway sessions to spawn shards.",
-          `Required: ${totalShards}`,
-          `Remaining: ${limit.remaining}`,
-          `Resets in: ${Math.ceil(limit.reset_after / 1e3)}s`
-        ].join(" ")
-      );
-      self.emit("error", error);
-      return;
+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");
     }
-    identifyQueue && (identifyQueue.pause(), identifyQueue = void 0), identifyQueue = createQueue({
+  }
+  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.#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({
       concurrency: limit.max_concurrency,
       intervalCap: limit.max_concurrency,
       interval: 5e3
     });
-    for (let i = 0; i < totalWorkers; i++) {
-      let start = i * opts.shardsPerWorker, shards = Array.from({ length: Math.min(opts.shardsPerWorker, totalShards - start) }, (_, j) => start + j), workerOptions = {
-        id: i,
-        total: totalShards,
-        token: options.token,
-        intents: options.intents,
-        shards,
-        gatewayURL: opts.gatewayURL ?? "wss://gateway.discord.gg"
-      };
-      workers.set(i, spawnWorker(workerOptions));
-    }
+    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 function shutdown(signal) {
-    console.log(`Received ${signal}, shutting down...`), await Promise.all(
-      [...workers.values()].map((child) => new Promise((resolve) => {
-        child.once("exit", () => resolve()), child.kill("SIGTERM");
-      }))
-    ), process.exit(0);
-  }
-  process.once("SIGINT", shutdown), process.once("SIGTERM", shutdown);
-  function spawnWorker(payload) {
-    let child = fork(opts.workerPath ?? DEFAULT_WORKER_PATH, [], {
-      env: {
-        WORKER_DATA: JSON.stringify(payload)
-      },
-      stdio: "inherit"
-    });
-    return child.on("message", (msg) => {
-      switch (msg.type) {
-        case "shardRaw": {
-          self.emit("shardRaw", payload.id, msg.shardId, msg.payload);
-          break;
-        }
-        case "shardDispatch": {
-          self.emit("shardDispatch", payload.id, msg.shardId, msg.payload);
-          break;
-        }
-        case "shardReady": {
-          self.emit("shardReady", payload.id, msg.shardId, msg.payload);
-          break;
-        }
-        case "shardDisconnect": {
-          self.emit("shardDisconnect", payload.id, msg.shardId, msg.code);
-          break;
-        }
-        case "shardRequestIdentify": {
-          identifyQueue?.add(async () => {
-            child.connected && child.send({
-              type: "identifyShard",
-              shardId: msg.shardId
-            });
-          });
-          break;
-        }
-        case "ready": {
-          self.emit("workerReady", payload.id);
-          break;
-        }
-        case "stop": {
-          self.emit("workerStop", payload.id);
-          break;
-        }
-        case "workerError": {
-          self.emit("error", new Error(`[worker ${payload.id}] ${msg.error.message}`));
-          break;
-        }
-      }
-    }), child;
+  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");
   }
-  function broadcast(payload) {
-    for (let child of workers.values())
-      child.connected && child.send({
-        type: "broadcast",
-        payload
-      });
+  broadcast(payload) {
+    for (let cluster of this.clusters.values())
+      cluster.send(payload);
   }
-  function sendToShard(shardId, payload) {
-    let workerId = Math.floor(shardId / opts.shardsPerWorker), child = workers.get(workerId);
-    return child?.connected ? (child.send({
-      type: "sendToShard",
-      shardId,
-      payload
-    }), true) : false;
-  }
-  function sendToWorker(workerId, payload) {
-    let child = workers.get(workerId);
-    return child?.connected ? (child.send({
-      type: "broadcast",
-      payload
-    }), true) : false;
-  }
-  return self;
-}
+  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);
+    });
+  }
+};
 
-export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, GatewayWorkerState, ShardState, ShardStrategy, bindWorkerToProcess, createGatewayManager, createShard, createWorker, getWorkerOptions };
+export { Cluster, ClusterProcess, Shard, ShardState, ShardStrategy, ShardingManager };