lunibee 0.1.0 → 0.1.2

package/dist/sharding/index.js

@@ -0,0 +1,732 @@
+// @bun
+// packages/types/src/index.ts
+var GatewayIntentBits = {
+  Guilds: 1 << 0,
+  GuildMembers: 1 << 1,
+  GuildModeration: 1 << 2,
+  GuildExpressions: 1 << 3,
+  GuildIntegrations: 1 << 4,
+  GuildWebhooks: 1 << 5,
+  GuildInvites: 1 << 6,
+  GuildVoiceStates: 1 << 7,
+  GuildPresences: 1 << 8,
+  GuildMessages: 1 << 9,
+  GuildMessageReactions: 1 << 10,
+  GuildMessageTyping: 1 << 11,
+  DirectMessages: 1 << 12,
+  DirectMessageReactions: 1 << 13,
+  DirectMessageTyping: 1 << 14,
+  MessageContent: 1 << 15,
+  GuildScheduledEvents: 1 << 16,
+  AutoModerationConfiguration: 1 << 20,
+  AutoModerationExecution: 1 << 21,
+  GuildMessagePolls: 1 << 24,
+  DirectMessagePolls: 1 << 25
+};
+var IntentBits = {
+  guild: 1 << 0,
+  guilds: 1 << 0,
+  guildMembers: 1 << 1,
+  guildModeration: 1 << 2,
+  guildBans: 1 << 2,
+  guildExpressions: 1 << 3,
+  guildEmojis: 1 << 3,
+  guildEmojisAndStickers: 1 << 3,
+  guildIntegrations: 1 << 4,
+  guildWebhooks: 1 << 5,
+  guildInvites: 1 << 6,
+  guildVoiceStates: 1 << 7,
+  guildPresences: 1 << 8,
+  guildMessages: 1 << 9,
+  guildMessage: 1 << 9,
+  guildMessageReactions: 1 << 10,
+  guildMessageTyping: 1 << 11,
+  directMessages: 1 << 12,
+  directMessageReactions: 1 << 13,
+  directMessageTyping: 1 << 14,
+  messageContent: 1 << 15,
+  guildScheduledEvents: 1 << 16,
+  autoModerationConfiguration: 1 << 20,
+  autoModerationExecution: 1 << 21,
+  guildMessagePolls: 1 << 24,
+  directMessagePolls: 1 << 25
+};
+function resolveGatewayIntents(intents) {
+  if (typeof intents === "number")
+    return intents;
+  if (Array.isArray(intents)) {
+    return intents.reduce((acc, intent) => {
+      return acc | resolveGatewayIntents(intent);
+    }, 0);
+  }
+  if (typeof intents === "string") {
+    if (intents in GatewayIntentBits)
+      return GatewayIntentBits[intents];
+    if (intents in IntentBits)
+      return IntentBits[intents];
+    const lower = intents.charAt(0).toLowerCase() + intents.slice(1);
+    if (lower in IntentBits)
+      return IntentBits[lower];
+    const num = Number(intents);
+    if (!Number.isNaN(num))
+      return num;
+  }
+  return 0;
+}
+
+// packages/ws/src/index.ts
+var GatewayOpcodes = {
+  Dispatch: 0,
+  Heartbeat: 1,
+  Identify: 2,
+  PresenceUpdate: 3,
+  VoiceStateUpdate: 4,
+  Resume: 6,
+  Reconnect: 7,
+  RequestGuildMembers: 8,
+  InvalidSession: 9,
+  Hello: 10,
+  HeartbeatAck: 11
+};
+class GatewayError extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = "GatewayError";
+    this.code = code;
+  }
+}
+
+class Gateway {
+  state = "CONNECT" /* Connect */;
+  #options;
+  #ws;
+  #sequence = null;
+  #sessionId;
+  #resumeURL;
+  #heartbeatTimer;
+  #initialHeartbeat;
+  #heartbeatAckTimer;
+  #heartbeatACK = true;
+  #heartbeatInterval = 0;
+  #heartbeatSentAt = 0;
+  #lastMessageAt = 0;
+  #zombieTimer;
+  #zombieReported = false;
+  #closed = false;
+  #attempt = 0;
+  #reconnectTimer;
+  #connectPromise;
+  #resolveConnect;
+  #rejectConnect;
+  #listeners = new Map;
+  #sendTimestamps = [];
+  constructor(options) {
+    if (!options.token?.trim())
+      throw new TypeError("A Gateway token is required.");
+    const resolvedIntents = resolveGatewayIntents(options.intents);
+    if (!Number.isInteger(resolvedIntents) || resolvedIntents < 0)
+      throw new TypeError("Gateway intents must be a non-negative integer.");
+    this.#options = {
+      shardId: 0,
+      shardCount: 1,
+      reconnect: true,
+      maxReconnectAttempts: Infinity,
+      reconnectBaseDelay: 1000,
+      reconnectMaxDelay: 30000,
+      heartbeatAckTimeout: 1e4,
+      zombieTimeout: 30000,
+      properties: {
+        os: "Android",
+        browser: "Discord Android",
+        device: "Discord Android"
+      },
+      presence: { status: "online", activities: [], afk: false, since: null },
+      ...options
+    };
+    if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
+      throw new RangeError("Gateway shardId must be within the configured shard count.");
+    if (this.#options.zombieTimeout <= this.#options.heartbeatAckTimeout)
+      throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
+  }
+  connect(url = "wss://gateway.discord.gg/?v=10&encoding=json") {
+    if (this.state === "CLOSED" /* Closed */)
+      throw new GatewayError("Gateway has been permanently closed.");
+    if (this.#connectPromise)
+      return this.#connectPromise;
+    this.#closed = false;
+    this.#setState("CONNECT" /* Connect */);
+    this.#connectPromise = new Promise((resolve, reject) => {
+      this.#resolveConnect = resolve;
+      this.#rejectConnect = reject;
+      this.#open(url);
+    });
+    return this.#connectPromise;
+  }
+  close() {
+    this.#closed = true;
+    this.#clearTimers();
+    this.#settleConnect(new GatewayError("Gateway connection closed before socket open."));
+    const ws = this.#ws;
+    this.#ws = undefined;
+    try {
+      ws?.close(1000, "Client closed connection");
+    } catch (error) {
+      this.#emitError(error);
+    }
+    this.#setState("CLOSED" /* Closed */);
+  }
+  emit(event, data) {
+    this.#emit(event, data);
+  }
+  on(event, listener) {
+    if (!event || typeof listener !== "function")
+      throw new TypeError("Gateway event and listener are required.");
+    let listeners = this.#listeners.get(event);
+    if (!listeners)
+      this.#listeners.set(event, listeners = new Set);
+    listeners.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  send(payload) {
+    if (!payload || !Number.isInteger(payload.op))
+      throw new TypeError("Gateway payload must contain an integer opcode.");
+    if (this.#ws?.readyState !== WebSocket.OPEN)
+      return false;
+    const now = Date.now();
+    while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
+      this.#sendTimestamps.shift();
+    if (this.#sendTimestamps.length >= 115) {
+      this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
+      return false;
+    }
+    try {
+      this.#ws.send(JSON.stringify(payload));
+      this.#sendTimestamps.push(now);
+      return true;
+    } catch (error) {
+      this.#emitError(error);
+      return false;
+    }
+  }
+  setPresence(data) {
+    this.#options.presence = { ...this.#options.presence, ...data };
+    const payload = {
+      since: this.#options.presence.since ?? null,
+      activities: this.#options.presence.activities ?? [],
+      status: this.#options.presence.status ?? "online",
+      afk: Boolean(this.#options.presence.afk)
+    };
+    return this.send({
+      op: GatewayOpcodes.PresenceUpdate,
+      d: payload,
+      s: null,
+      t: null
+    });
+  }
+  setVoiceState(data) {
+    return this.send({
+      op: GatewayOpcodes.VoiceStateUpdate,
+      d: data,
+      s: null,
+      t: null
+    });
+  }
+  requestGuildMembers(data) {
+    return this.send({
+      op: GatewayOpcodes.RequestGuildMembers,
+      d: data,
+      s: null,
+      t: null
+    });
+  }
+  #open(url) {
+    if (this.#closed)
+      return;
+    let ws;
+    try {
+      ws = new WebSocket(url);
+    } catch (error) {
+      const failure = this.#normalizeError(error);
+      this.#emitError(failure);
+      if (this.#options.reconnect) {
+        this.#setState("RECONNECT" /* Reconnect */);
+        this.#scheduleReconnect();
+      } else
+        this.#settleConnect(failure);
+      return;
+    }
+    this.#ws = ws;
+    ws.addEventListener("open", () => {
+      this.#lastMessageAt = Date.now();
+      this.#zombieReported = false;
+      this.#startZombieDetection();
+      this.#emit("open", undefined);
+      this.#settleConnect();
+    });
+    ws.addEventListener("message", (event) => {
+      this.#lastMessageAt = Date.now();
+      this.#zombieReported = false;
+      this.#message(ws, String(event.data));
+    });
+    ws.addEventListener("close", (event) => this.#close(ws, event.code));
+    ws.addEventListener("error", () => this.#emitError(new GatewayError("Gateway WebSocket error")));
+  }
+  #startZombieDetection() {
+    if (this.#zombieTimer)
+      clearInterval(this.#zombieTimer);
+    const interval = Math.max(1, Math.min(250, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
+    this.#zombieTimer = setInterval(() => {
+      if (this.#closed || this.#ws?.readyState !== WebSocket.OPEN || this.#lastMessageAt === 0)
+        return;
+      const silentFor = Date.now() - this.#lastMessageAt;
+      const deadline = Math.max(this.#options.zombieTimeout, this.#heartbeatInterval + this.#options.heartbeatAckTimeout);
+      if (silentFor < deadline || this.#zombieReported)
+        return;
+      this.#zombieReported = true;
+      const error = new GatewayError(`Gateway connection appears stale after ${silentFor}ms without traffic.`);
+      this.#emit("zombie", { silentFor, timeout: deadline });
+      this.#emitError(error);
+      try {
+        this.#ws.close(1001, "Zombie Gateway connection");
+      } catch (closeError) {
+        this.#emitError(closeError);
+      }
+    }, interval);
+  }
+  #message(ws, raw) {
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch (error) {
+      this.#emitError(new GatewayError("Gateway returned invalid JSON", undefined, {
+        cause: error
+      }));
+      ws.close(1002, "Invalid JSON");
+      return;
+    }
+    if (!payload || typeof payload.op !== "number") {
+      this.#emitError(new GatewayError("Gateway returned an invalid payload"));
+      ws.close(1002, "Invalid payload");
+      return;
+    }
+    if (typeof payload.s === "number")
+      this.#sequence = payload.s;
+    switch (payload.op) {
+      case GatewayOpcodes.Dispatch:
+        this.#setState("DISPATCH" /* Dispatch */);
+        this.#handleDispatch(payload.t, payload.d);
+        break;
+      case GatewayOpcodes.Hello:
+        this.#handleHello(payload.d);
+        break;
+      case GatewayOpcodes.Heartbeat:
+        this.#setState("HEARTBEAT" /* Heartbeat */);
+        this.#sendHeartbeat();
+        break;
+      case GatewayOpcodes.HeartbeatAck:
+        this.#heartbeatACK = true;
+        this.#clearHeartbeatAckTimer();
+        this.#emit("heartbeatAck", payload.d);
+        break;
+      case GatewayOpcodes.Reconnect:
+        ws.close(1001, "Server requested reconnect");
+        break;
+      case GatewayOpcodes.InvalidSession:
+        this.#sessionId = undefined;
+        this.#sequence = null;
+        this.#emit("invalidSession", payload.d);
+        ws.close(1000, "Invalid session");
+        break;
+    }
+  }
+  #handleDispatch(event, data) {
+    if (event === "READY") {
+      const ready = data;
+      if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string") {
+        this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
+        return;
+      }
+      this.#sessionId = ready.session_id;
+      this.#resumeURL = ready.resume_gateway_url;
+      this.#attempt = 0;
+      this.#setState("READY" /* Ready */);
+      this.#emit("ready", data);
+    }
+    this.#emit(event ?? "dispatch", data);
+  }
+  #handleHello(data) {
+    const interval = data?.heartbeat_interval;
+    if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0) {
+      this.#emitError(new GatewayError("Gateway HELLO payload contains an invalid heartbeat interval"));
+      this.#ws?.close(1002, "Invalid heartbeat interval");
+      return;
+    }
+    this.#heartbeatInterval = interval;
+    this.#setState(this.#sessionId && this.#sequence !== null && this.#resumeURL ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
+    this.#startHeartbeat(interval);
+    this.#identifyOrResume();
+  }
+  #identifyOrResume() {
+    if (this.#sessionId && this.#sequence !== null && this.#resumeURL) {
+      this.#setState("RESUME" /* Resume */);
+      this.send({
+        op: GatewayOpcodes.Resume,
+        d: {
+          token: this.#options.token,
+          session_id: this.#sessionId,
+          seq: this.#sequence
+        },
+        s: null,
+        t: null
+      });
+      return;
+    }
+    this.#setState("IDENTIFY" /* Identify */);
+    const props = this.#options.properties ?? {
+      os: "Android",
+      browser: "Discord Android",
+      device: "Discord Android"
+    };
+    const os = props.os ?? "Android";
+    const browser = props.browser ?? "Discord Android";
+    const device = props.device ?? "Discord Android";
+    this.send({
+      op: GatewayOpcodes.Identify,
+      d: {
+        token: this.#options.token,
+        intents: this.#options.intents,
+        properties: {
+          os,
+          browser,
+          device,
+          $os: os,
+          $browser: browser,
+          $device: device,
+          ...props
+        },
+        presence: {
+          since: this.#options.presence?.since ?? null,
+          activities: this.#options.presence?.activities ?? [],
+          status: this.#options.presence?.status ?? "online",
+          afk: Boolean(this.#options.presence?.afk)
+        },
+        shard: [this.#options.shardId, this.#options.shardCount]
+      },
+      s: null,
+      t: null
+    });
+  }
+  #startHeartbeat(interval) {
+    this.#clearHeartbeatTimers();
+    this.#heartbeatACK = true;
+    this.#initialHeartbeat = setTimeout(() => this.#sendHeartbeat(), Math.random() * interval);
+    this.#heartbeatTimer = setInterval(() => this.#sendHeartbeat(), interval);
+  }
+  #sendHeartbeat() {
+    this.#heartbeatACK = false;
+    this.#heartbeatSentAt = Date.now();
+    if (!this.send({
+      op: GatewayOpcodes.Heartbeat,
+      d: this.#sequence,
+      s: null,
+      t: null
+    })) {
+      this.#emitError(new GatewayError("Unable to send Gateway heartbeat because the WebSocket is not open."));
+      return;
+    }
+    this.#clearHeartbeatAckTimer();
+    this.#heartbeatAckTimer = setTimeout(() => {
+      if (!this.#heartbeatACK) {
+        const elapsed = Date.now() - this.#heartbeatSentAt;
+        this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${elapsed}ms.`));
+        try {
+          this.#ws?.close(1001, "Heartbeat timeout");
+        } catch (error) {
+          this.#emitError(error);
+        }
+      }
+    }, this.#options.heartbeatAckTimeout);
+  }
+  #close(ws, code) {
+    if (this.#ws !== ws)
+      return;
+    this.#ws = undefined;
+    this.#clearTimers();
+    const action = this.#closeAction(code);
+    this.#emit("close", { code, action });
+    if (this.#closed || !this.#options.reconnect || action === "stop") {
+      this.#setState(this.#closed ? "CLOSED" /* Closed */ : "CONNECT" /* Connect */);
+      if (this.#connectPromise)
+        this.#settleConnect(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
+      return;
+    }
+    if (action === "identify") {
+      this.#sequence = null;
+      this.#sessionId = undefined;
+    }
+    this.#setState("RECONNECT" /* Reconnect */);
+    this.#scheduleReconnect();
+  }
+  #closeAction(code) {
+    if ([4004, 4010, 4011, 4012, 4013, 4014].includes(code))
+      return "stop";
+    if ([4007, 4009].includes(code))
+      return "identify";
+    return this.#sessionId && this.#sequence !== null ? "resume" : "identify";
+  }
+  #scheduleReconnect() {
+    if (this.#closed || !this.#options.reconnect || this.#reconnectTimer)
+      return;
+    if (this.#attempt >= this.#options.maxReconnectAttempts) {
+      this.#settleConnect(new GatewayError("Gateway reconnect attempts exhausted."));
+      this.#setState("CONNECT" /* Connect */);
+      return;
+    }
+    const delay = Math.min(this.#options.reconnectMaxDelay, this.#options.reconnectBaseDelay * 2 ** this.#attempt++);
+    const jitter = Math.random() * Math.min(250, Math.max(1, delay * 0.25));
+    this.#reconnectTimer = setTimeout(() => {
+      this.#reconnectTimer = undefined;
+      this.#open(this.#resumeURL ?? "wss://gateway.discord.gg/?v=10&encoding=json");
+    }, delay + jitter);
+  }
+  #settleConnect(error) {
+    const resolve = this.#resolveConnect;
+    const reject = this.#rejectConnect;
+    this.#resolveConnect = undefined;
+    this.#rejectConnect = undefined;
+    this.#connectPromise = undefined;
+    if (error)
+      reject?.(error);
+    else
+      resolve?.();
+  }
+  #clearHeartbeatAckTimer() {
+    if (this.#heartbeatAckTimer)
+      clearTimeout(this.#heartbeatAckTimer);
+    this.#heartbeatAckTimer = undefined;
+  }
+  #clearHeartbeatTimers() {
+    if (this.#heartbeatTimer)
+      clearInterval(this.#heartbeatTimer);
+    if (this.#initialHeartbeat)
+      clearTimeout(this.#initialHeartbeat);
+    this.#clearHeartbeatAckTimer();
+    this.#heartbeatTimer = undefined;
+    this.#initialHeartbeat = undefined;
+  }
+  #clearTimers() {
+    if (this.#reconnectTimer)
+      clearTimeout(this.#reconnectTimer);
+    if (this.#zombieTimer)
+      clearInterval(this.#zombieTimer);
+    this.#reconnectTimer = undefined;
+    this.#zombieTimer = undefined;
+    this.#clearHeartbeatTimers();
+  }
+  #normalizeError(error) {
+    return error instanceof GatewayError ? error : new GatewayError("Gateway connection failed.", undefined, {
+      cause: error
+    });
+  }
+  #emitError(error) {
+    this.#emit("error", error instanceof Error ? error : new GatewayError(String(error)));
+  }
+  #emit(event, data) {
+    for (const listener of this.#listeners.get(event) ?? []) {
+      try {
+        const result = listener(data);
+        if (result && typeof result.then === "function")
+          Promise.resolve(result).catch((error) => {
+            if (event !== "error")
+              this.#emitError(error);
+          });
+      } catch (error) {
+        if (event !== "error")
+          this.#emitError(error);
+      }
+    }
+  }
+  #setState(next) {
+    if (this.state === next)
+      return;
+    const previous = this.state;
+    this.state = next;
+    this.#emit("stateChange", { previous, next });
+  }
+}
+
+// packages/sharding/src/bus.ts
+class ShardBus {
+  #channel;
+  #handlers = new Map;
+  #shardId;
+  #namespace;
+  channelName;
+  #counter = 0;
+  constructor(shardId, channelName) {
+    if (!Number.isInteger(shardId) || shardId < 0)
+      throw new RangeError("Shard ID must be a non-negative integer.");
+    if (!channelName?.trim())
+      throw new TypeError("An application-specific shard channel name is required.");
+    this.#shardId = shardId;
+    this.#namespace = channelName.trim();
+    this.channelName = this.#namespace;
+    this.#channel = new BroadcastChannel(this.channelName);
+    this.#channel.addEventListener("message", (event) => this.#dispatch(event.data));
+  }
+  on(type, handler) {
+    if (!type.trim() || typeof handler !== "function")
+      throw new TypeError("Shard message type and handler are required.");
+    let handlers = this.#handlers.get(type);
+    if (!handlers)
+      this.#handlers.set(type, handlers = new Set);
+    handlers.add(handler);
+    return this;
+  }
+  off(type, handler) {
+    this.#handlers.get(type)?.delete(handler);
+    return this;
+  }
+  send(target, type, data) {
+    if (!Number.isInteger(target) || target < 0)
+      throw new RangeError("Shard target must be a non-negative integer.");
+    return this.#publish(target, type, data);
+  }
+  broadcast(type, data) {
+    return this.#publish(null, type, data);
+  }
+  close() {
+    this.#channel.close();
+    this.#handlers.clear();
+  }
+  #publish(target, type, data) {
+    if (!type.trim())
+      throw new TypeError("Shard message type is required.");
+    const id = `${this.#namespace}:${this.#shardId}:${++this.#counter}`;
+    this.#channel.postMessage({
+      source: this.#shardId,
+      target,
+      type,
+      data,
+      id
+    });
+    return id;
+  }
+  #dispatch(message) {
+    if (!message || typeof message !== "object" || typeof message.type !== "string")
+      return;
+    if (message.source === this.#shardId || message.target !== null && message.target !== this.#shardId)
+      return;
+    for (const handler of this.#handlers.get(message.type) ?? []) {
+      try {
+        const result = handler(message);
+        if (result && typeof result.then === "function")
+          Promise.resolve(result).catch(() => {
+            return;
+          });
+      } catch {}
+    }
+  }
+}
+
+// packages/sharding/src/index.ts
+class ShardManager {
+  shards = new Map;
+  get shardCount() {
+    return this.shards.size;
+  }
+  #options;
+  #resolved = false;
+  #destroyed = false;
+  constructor(options) {
+    if (!options.token?.trim())
+      throw new TypeError("A Discord bot token is required.");
+    if (!Number.isInteger(options.intents) || options.intents < 0)
+      throw new TypeError("Gateway intents must be a non-negative integer.");
+    const count = options.shardCount === "auto" || options.shardCount === undefined ? 1 : options.shardCount;
+    if (!Number.isInteger(count) || count < 1)
+      throw new RangeError("Shard count must be a positive integer.");
+    this.#options = { ...options };
+    if (options.shardCount !== "auto")
+      this.#initialize(count);
+  }
+  async fetchRecommendedShardCount() {
+    const response = await fetch("https://discord.com/api/v10/gateway/bot", {
+      headers: {
+        Authorization: `Bot ${this.#options.token}`,
+        "User-Agent": "Lunibee/0.1.0"
+      }
+    });
+    if (!response.ok)
+      throw new Error(`Gateway discovery failed with status ${response.status}`);
+    const data = await response.json();
+    if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1)
+      throw new Error("Gateway discovery returned an invalid shard count.");
+    return data.shards;
+  }
+  async connect() {
+    await this.#ensureInitialized();
+    for (const [id, shard] of this.shards) {
+      try {
+        await shard.connect();
+      } catch (error) {
+        this.destroy();
+        throw new Error(`Failed to connect shard ${id}.`, { cause: error });
+      }
+      if (id + 1 < this.shardCount && this.#options.spawnDelay && this.#options.spawnDelay > 0)
+        await Bun.sleep(this.#options.spawnDelay);
+    }
+  }
+  destroy() {
+    for (const shard of this.shards.values())
+      shard.close();
+    this.shards.clear();
+    this.#resolved = false;
+    this.#destroyed = true;
+  }
+  getShardIdForGuild(guildId) {
+    const id = BigInt(guildId);
+    return Number((id >> 22n) % BigInt(this.shardCount || 1));
+  }
+  get(id) {
+    return this.shards.get(id);
+  }
+  values() {
+    return [...this.shards].map(([id, gateway]) => ({ id, gateway }));
+  }
+  async#ensureInitialized() {
+    if (this.#resolved)
+      return;
+    if (this.#destroyed)
+      this.#destroyed = false;
+    const count = this.#options.shardCount === "auto" ? await this.fetchRecommendedShardCount() : this.#options.shardCount ?? 1;
+    this.#initialize(count);
+  }
+  #initialize(count) {
+    if (this.#resolved)
+      return;
+    for (let id = 0;id < count; id++)
+      this.shards.set(id, this.#createShard(id, count));
+    this.#resolved = true;
+  }
+  #createShard(id, count) {
+    return new Gateway({
+      token: this.#options.token,
+      intents: this.#options.intents,
+      shardId: id,
+      shardCount: count,
+      reconnect: this.#options.reconnect ?? true
+    });
+  }
+}
+export {
+  ShardBus,
+  ShardManager
+};
+
+//# debugId=3D6EA7786F9CDC6964756E2164756E21