@bakit/gateway 2.0.0-alpha.36

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Louis Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+import { EventBus, ReadonlyCollection } from '@bakit/utils';
+import { GatewayReadyDispatchData, GatewayReceivePayload, GatewayDispatchPayload, GatewaySendPayload } from 'discord-api-types/gateway';
+import { ValueOf } from 'type-fest';
+import { GatewayReadyDispatchData as GatewayReadyDispatchData$1, GatewayReceivePayload as GatewayReceivePayload$1, GatewayDispatchPayload as GatewayDispatchPayload$1, GatewaySendPayload as GatewaySendPayload$1 } from 'discord-api-types/v10';
+import { RESTOptions, REST } from '@bakit/rest';
+
+interface ShardOptions {
+    id: number;
+    total: number;
+    token: string;
+    intents: number | bigint;
+    gateway?: ShardGatewayOptions;
+}
+interface ShardGatewayOptions {
+    baseURL: string;
+    version: number;
+}
+interface ShardEvents {
+    ready: [payload: GatewayReadyDispatchData];
+    disconnect: [code: number];
+    resume: [];
+    error: [error: Error];
+    debug: [message: string];
+    raw: [payload: GatewayReceivePayload];
+    dispatch: [payload: GatewayDispatchPayload];
+    requestIdentify: [];
+}
+/**
+ * High-level lifecycle state of the shard connection.
+ */
+declare const ShardState: {
+    /** Not connected. */
+    Idle: number;
+    /** Initialzing connection. */
+    Connecting: number;
+    /** Connected to gateway and identified. */
+    Ready: number;
+    /** Resuming the session. */
+    Resuming: number;
+    /** Disconnected the connection. */
+    Disconnected: number;
+};
+type ShardState = ValueOf<typeof ShardState>;
+/**
+ * Strategy describes *what to do next after a disconnect*.
+ * This is intentionally separate from ShardState.
+ */
+declare const ShardStrategy: {
+    /** No decision yet (default on close). */
+    Unknown: number;
+    /** Reconnect with IDENTIFY (new session). */
+    Reconnect: number;
+    /** Reconnect and try RESUME. */
+    Resume: number;
+    /** Do not reconnect. */
+    Shutdown: number;
+};
+type ShardStrategy = ValueOf<typeof ShardStrategy>;
+interface Shard extends EventBus<ShardEvents> {
+    readonly id: number;
+    readonly state: ShardState;
+    readonly latency: number;
+    connect(): Promise<void>;
+    disconnect(code?: number): Promise<void>;
+    send(payload: GatewaySendPayload): void;
+    identify(): void;
+}
+/**
+ * Creates a shard object which can be used to connect to the Discord gateway.
+ *
+ * @param {ShardOptions} options - The options to create the shard with.
+ * @returns {Shard} - The created shard object.
+ */
+declare function createShard(options: ShardOptions): Shard;
+
+interface GatewayWorkerOptions {
+    id: number;
+    total: number;
+    token: string;
+    intents: number | bigint;
+    shards: number[];
+    gatewayURL: string;
+}
+interface GatewayWorker extends EventBus<GatewayWorkerEvents> {
+    readonly id: number;
+    readonly shards: ReadonlyCollection<number, Shard>;
+    readonly shardIds: number[];
+    readonly latency: number;
+    readonly state: GatewayWorkerState;
+    start(): Promise<void>;
+    stop(code?: number): Promise<void>;
+    /**
+     * Broadcast the given payload to all shards connections.
+     * @param {GatewaySendPayload} payload - The payload to send.
+     */
+    broadcast(payload: GatewaySendPayload$1): void;
+}
+interface GatewayWorkerEvents {
+    ready: [];
+    stop: [];
+    resume: [];
+    degrade: [readyCount: number, total: number];
+    shardReady: [shardId: number, payload: GatewayReadyDispatchData$1];
+    shardDisconnect: [shardId: number, code: number];
+    shardRaw: [shardId: number, payload: GatewayReceivePayload$1];
+    shardDispatch: [shardId: number, payload: GatewayDispatchPayload$1];
+    shardRequestIdentify: [shardId: number];
+    debug: [message: string];
+    error: [error: Error];
+}
+declare const GatewayWorkerState: {
+    readonly Idle: 0;
+    readonly Starting: 1;
+    readonly Ready: 2;
+    readonly Degraded: 3;
+    readonly Stopped: 4;
+};
+type GatewayWorkerState = ValueOf<typeof GatewayWorkerState>;
+declare function createWorker(options: GatewayWorkerOptions): GatewayWorker;
+declare function bindWorkerToProcess(worker: GatewayWorker): void;
+declare function getWorkerOptions(): GatewayWorkerOptions;
+
+declare const DEFAULT_WORKER_PATH: string;
+interface GatewayManagerOptions {
+    token: string;
+    intents: number | bigint;
+    workerPath?: string;
+    gatewayURL?: string;
+    totalShards?: number | "auto";
+    shardsPerWorker?: number;
+    rest?: RESTOptions;
+}
+declare const DEFAULT_GATEWAY_MANAGER_OPTIONS: {
+    readonly gatewayURL: "wss://gateway.discord.gg";
+    readonly totalShards: "auto";
+    readonly shardsPerWorker: 5;
+};
+interface GatewayManagerEvents {
+    error: [error: Error];
+    shardReady: [workerId: number, shardId: number, payload: GatewayReadyDispatchData$1];
+    shardDisconnect: [workerId: number, shardId: number, code?: number];
+    shardRaw: [workerId: number, shardId: number, payload: GatewayReceivePayload$1];
+    shardDispatch: [workerId: number, shardId: number, payload: GatewayDispatchPayload$1];
+    workerReady: [workerId: number];
+    workerStop: [workerId: number];
+}
+interface GatewayManager extends EventBus<GatewayManagerEvents> {
+    readonly rest: REST;
+    spawn(): Promise<void>;
+    broadcast(payload: GatewaySendPayload$1): void;
+    sendToWorker(id: number, payload: GatewaySendPayload$1): void;
+    sendToShard(id: number, payload: GatewaySendPayload$1): void;
+}
+declare function createGatewayManager(options: GatewayManagerOptions): GatewayManager;
+
+export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, type GatewayManager, type GatewayManagerEvents, type GatewayManagerOptions, type GatewayWorker, type GatewayWorkerEvents, type GatewayWorkerOptions, GatewayWorkerState, type Shard, type ShardEvents, type ShardGatewayOptions, type ShardOptions, ShardState, ShardStrategy, bindWorkerToProcess, createGatewayManager, createShard, createWorker, getWorkerOptions };

package/dist/index.js

@@ -0,0 +1,460 @@
+import { WebSocket } from 'ws';
+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 { fork } from 'child_process';
+import { createREST } from '@bakit/rest';
+
+// src/lib/shard.ts
+var ZLIB_FLUSH = Buffer.from([0, 0, 255, 255]), 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 }, state = ShardState.Idle, strategy = ShardStrategy.Unknown, ws, resumeGatewayURL, inflater, zlibBuffer, 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
+    }), zlibBuffer = Buffer.alloc(0), inflater = createInflate({
+      flush: constants.Z_SYNC_FLUSH
+    }), inflater.on("data", (chunk) => {
+      try {
+        let payload = JSON.parse(chunk.toString("utf8"));
+        handlePayload(payload);
+      } catch (err) {
+        self.emit("error", err);
+      }
+    }), 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), zlibBuffer && (zlibBuffer = void 0), ws && (ws.readyState !== WebSocket.CLOSED && ws.terminate(), ws.removeAllListeners(), ws = void 0), 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());
+    });
+  }
+  function disconnect(code = 1e3) {
+    return new Promise((resolve) => {
+      if (strategy = ShardStrategy.Shutdown, !ws) {
+        resolve();
+        return;
+      }
+      ws.once("close", () => {
+        resolve();
+      }), ws.close(code);
+    });
+  }
+  function onMessage(data) {
+    if (!(!(data instanceof Buffer) || !zlibBuffer)) {
+      if (data.length > 8 * 1024 * 1024) {
+        ws?.terminate();
+        return;
+      }
+      zlibBuffer = Buffer.concat([zlibBuffer, data]), zlibBuffer.subarray(zlibBuffer.length - 4).equals(ZLIB_FLUSH) && (inflater?.write(zlibBuffer), zlibBuffer = Buffer.alloc(0));
+    }
+  }
+  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;
+      }
+      return;
+    }
+    strategy === ShardStrategy.Unknown && (strategy = getReconnectStrategy(code)), (strategy === ShardStrategy.Reconnect || strategy === ShardStrategy.Resume) && scheduleReconnect();
+  }
+  function handlePayload(payload) {
+    switch (self.emit("raw", payload), payload.op) {
+      case GatewayOpcodes.Dispatch: {
+        handleDispatch(payload);
+        break;
+      }
+      case GatewayOpcodes.Hello: {
+        startHeartbeat(payload.d.heartbeat_interval), isResumable() ? resume() : self.emit("requestIdentify");
+        break;
+      }
+      case GatewayOpcodes.Heartbeat: {
+        sendHeartbeat();
+        break;
+      }
+      case GatewayOpcodes.HeartbeatAck: {
+        lastHeartbeatAcknowledged = 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();
+        break;
+      }
+      case GatewayOpcodes.Reconnect: {
+        strategy = ShardStrategy.Resume, self.emit("debug", "Reconnecting to gateway"), ws?.terminate();
+        break;
+      }
+    }
+  }
+  function handleDispatch(payload) {
+    switch (lastSequence = payload.s, self.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);
+        break;
+      }
+      case GatewayDispatchEvents.Resumed: {
+        state = ShardState.Ready, strategy = ShardStrategy.Unknown, self.emit("resume");
+        break;
+      }
+    }
+  }
+  function isResumable() {
+    let hasSessionId = sessionId !== void 0, hasSequence = lastSequence !== void 0;
+    return strategy === ShardStrategy.Resume && hasSequence && hasSessionId;
+  }
+  function getReconnectStrategy(code) {
+    switch (code) {
+      case GatewayCloseCodes.AuthenticationFailed:
+      case GatewayCloseCodes.InvalidIntents:
+      case GatewayCloseCodes.DisallowedIntents:
+        return ShardStrategy.Shutdown;
+      case GatewayCloseCodes.InvalidSeq:
+      case GatewayCloseCodes.SessionTimedOut:
+        return ShardStrategy.Reconnect;
+      default:
+        return ShardStrategy.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]
+      }
+    });
+  }
+  function resume() {
+    state = ShardState.Resuming, send({
+      op: GatewayOpcodes.Resume,
+      d: {
+        token: resolvedOptions.token,
+        session_id: sessionId,
+        seq: lastSequence
+      }
+    });
+  }
+  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);
+  }
+  function scheduleReconnect(delay = 1e3) {
+    reconnectTimeout || (reconnectTimeout = setTimeout(() => {
+      reconnectTimeout = void 0, state = ShardState.Idle, init();
+    }, delay));
+  }
+  function send(payload) {
+    ws?.readyState === WebSocket.OPEN && ws.send(JSON.stringify(payload));
+  }
+  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();
+      }
+    }
+  }
+  async function stop(code = 1e3) {
+    await Promise.all(shards.map((shard) => shard.disconnect(code))), state = GatewayWorkerState.Stopped, shards.clear(), readyShards.clear(), self.emit("stop");
+  }
+  function broadcast(payload) {
+    for (let shard of shards.values())
+      shard.state === ShardState.Ready && shard.send(payload);
+  }
+  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?.({ 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;
+      }
+      case "broadcast": {
+        worker.broadcast(message.payload);
+        break;
+      }
+      case "sendToShard": {
+        worker.shards.get(message.shardId)?.send(message.payload);
+        break;
+      }
+    }
+  });
+}
+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) {
+  let opts = {
+    ...DEFAULT_GATEWAY_MANAGER_OPTIONS,
+    ...options
+  }, identifyQueue, workers = new Collection(), rest = createREST(opts.rest ?? { token: options.token }), 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;
+    }
+    identifyQueue && (identifyQueue.pause(), identifyQueue = void 0), identifyQueue = createQueue({
+      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));
+    }
+  }
+  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;
+  }
+  function broadcast(payload) {
+    for (let child of workers.values())
+      child.connected && child.send({
+        type: "broadcast",
+        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;
+}
+
+export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, GatewayWorkerState, ShardState, ShardStrategy, bindWorkerToProcess, createGatewayManager, createShard, createWorker, getWorkerOptions };

package/dist/services/worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/services/worker.js

@@ -0,0 +1,6 @@
+import { createWorker, getWorkerOptions, bindWorkerToProcess } from '@bakit/gateway';
+
+// src/services/worker.ts
+var worker = createWorker(getWorkerOptions());
+bindWorkerToProcess(worker);
+await worker.start();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@bakit/gateway",
+  "version": "2.0.0-alpha.36",
+  "description": "Gateway manager for bakit framework",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/louiszn/bakit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/louiszn/bakit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/louiszn/bakit/issues"
+  },
+  "keywords": [
+    "discord-bot",
+    "bakit",
+    "framework"
+  ],
+  "author": "louiszn",
+  "license": "MIT",
+  "dependencies": {
+    "discord-api-types": "^0.38.37",
+    "type-fest": "^4.41.0",
+    "ws": "^8.18.3",
+    "@bakit/utils": "2.0.0-alpha.36",
+    "@bakit/rest": "2.0.0-alpha.36",
+    "@bakit/service": "2.0.0-alpha.36"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run --pass-with-no-tests"
+  }
+}