lunibee 0.3.3 → 0.4.0

package/dist/sharding/index.js

@@ -1,4625 +1,65 @@
 // @bun
-// packages/sharding/package.json
-var package_default = {
-  name: "@lunibee/sharding",
-  version: "0.3.3",
-  type: "module",
-  module: "./src/index.ts",
-  types: "./src/index.ts",
-  exports: {
-    ".": "./src/index.ts"
-  },
-  dependencies: {
-    "@lunibee/ws": "workspace:*"
-  }
-};
-
-// packages/sharding/src/gateway-bot.ts
-async function fetchGatewayBot(token) {
-  const response = await fetch("https://discord.com/api/v10/gateway/bot", {
-    headers: {
-      Authorization: `Bot ${token}`,
-      "User-Agent": `Lunibee/${package_default.version}`
-    }
-  });
-  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.");
-  const limit = data.session_start_limit;
-  const info = { shards: data.shards };
-  if (limit && typeof limit.total === "number" && typeof limit.remaining === "number" && typeof limit.reset_after === "number" && typeof limit.max_concurrency === "number")
-    info.sessionStartLimit = {
-      total: limit.total,
-      remaining: limit.remaining,
-      resetAfter: limit.reset_after,
-      maxConcurrency: Math.max(1, limit.max_concurrency)
-    };
-  return info;
-}
-var MAX_GUILDS_PER_SHARD = 2500;
-function assertGuildsPerShard(value) {
-  if (!Number.isInteger(value) || value < 1 || value > MAX_GUILDS_PER_SHARD)
-    throw new RangeError(`guildsPerShard must be an integer from 1 to ${MAX_GUILDS_PER_SHARD}.`);
-}
-function shardsForGuilds(guilds, guildsPerShard) {
-  assertGuildsPerShard(guildsPerShard);
-  if (!Number.isInteger(guilds) || guilds < 0)
-    throw new RangeError("guildCount must be a non-negative integer.");
-  return Math.max(1, Math.ceil(guilds / guildsPerShard));
-}
-async function fetchGuildCount(token) {
-  const response = await fetch("https://discord.com/api/v10/applications/@me", {
-    headers: {
-      Authorization: `Bot ${token}`,
-      "User-Agent": `Lunibee/${package_default.version}`
-    }
-  });
-  if (!response.ok)
-    throw new Error(`Guild count discovery failed with status ${response.status}`);
-  const data = await response.json();
-  const count = data.approximate_guild_count;
-  if (typeof count !== "number" || !Number.isInteger(count) || count < 0)
-    throw new Error("Discord did not report a guild count.");
-  return count;
-}
-async function resolveShardCount(token, info, options) {
-  if (options.guildsPerShard === undefined)
-    return info.shards;
-  return shardsForGuilds(options.guildCount ?? await fetchGuildCount(token), options.guildsPerShard);
-}
-
-// packages/ws/src/session.ts
-class GatewaySession {
-  #state = { status: "none" };
-  #sequence = null;
-  #generation = 0;
-  #lastInvalidation;
-  get lastInvalidation() {
-    return this.#lastInvalidation;
-  }
-  get generation() {
-    return this.#generation;
-  }
-  get sessionId() {
-    return this.#state.status === "established" ? this.#state.sessionId : undefined;
-  }
-  get resumeURL() {
-    return this.#state.status === "established" ? this.#state.resumeURL : undefined;
-  }
-  get sequence() {
-    return this.#sequence;
-  }
-  get canResume() {
-    return this.#state.status === "established" && this.#sequence !== null;
-  }
-  beginConnection() {
-    return ++this.#generation;
-  }
-  owns(token) {
-    return token === this.#generation;
-  }
-  recordSequence(sequence, token) {
-    if (!this.owns(token))
-      return false;
-    if (!Number.isInteger(sequence))
-      return false;
-    if (this.#sequence !== null && sequence < this.#sequence)
-      return false;
-    this.#sequence = sequence;
-    return true;
-  }
-  activate(payload, token) {
-    if (!this.owns(token))
-      return false;
-    const ready = payload;
-    if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string")
-      return false;
-    this.#state = {
-      status: "established",
-      sessionId: ready.session_id,
-      resumeURL: ready.resume_gateway_url
-    };
-    return true;
-  }
-  invalidate(token, reason = "explicit") {
-    if (!this.owns(token))
-      return false;
-    this.#lastInvalidation = reason;
-    this.#state = { status: "none" };
-    this.#sequence = null;
-    return true;
-  }
-  resumeInfo() {
-    if (this.#state.status !== "established")
-      return;
-    if (this.#sequence === null)
-      return;
-    const { sessionId, resumeURL } = this.#state;
-    return { sessionId, sequence: this.#sequence, resumeURL };
-  }
-  handshake() {
-    const resume = this.resumeInfo();
-    return resume ? { type: "resume", ...resume } : { type: "identify" };
-  }
-  connectURL(fallback) {
-    const resume = this.resumeInfo()?.resumeURL;
-    return resume !== undefined && isTrustedGatewayURL(resume, fallback) ? resume : fallback;
-  }
-}
-function isTrustedGatewayURL(url, fallback) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return false;
-  }
-  if (parsed.protocol !== "wss:" || parsed.username || parsed.password)
-    return false;
-  const host = parsed.hostname.toLowerCase();
-  if (host === "discord.gg" || host.endsWith(".discord.gg"))
-    return true;
-  try {
-    return host === new URL(fallback).hostname.toLowerCase();
-  } catch {
-    return false;
-  }
-}
-
-// packages/ws/src/heartbeat.ts
-var MAX_MONITOR_INTERVAL = 1000;
-
-class GatewayHeartbeat {
-  #options;
-  #now;
-  #interval = 0;
-  #acknowledged = true;
-  #sentAt = 0;
-  #latency = -1;
-  #lastMessageAt = 0;
-  #zombieReported = false;
-  #timer;
-  #initialTimer;
-  #ackTimer;
-  #monitorTimer;
-  constructor(options) {
-    if (options.zombieTimeout <= options.ackTimeout)
-      throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
-    this.#options = options;
-    this.#now = options.now ?? (() => Date.now());
-  }
-  get latency() {
-    return this.#latency;
-  }
-  get interval() {
-    return this.#interval;
-  }
-  get acknowledged() {
-    return this.#acknowledged;
-  }
-  get silentFor() {
-    return this.#lastMessageAt === 0 ? 0 : this.#now() - this.#lastMessageAt;
-  }
-  get stalenessDeadline() {
-    return Math.max(this.#options.zombieTimeout, this.#interval + this.#options.ackTimeout);
-  }
-  isHealthy() {
-    if (!this.#acknowledged)
-      return false;
-    if (this.#lastMessageAt === 0)
-      return true;
-    return this.silentFor < this.stalenessDeadline;
-  }
-  watch() {
-    this.#lastMessageAt = this.#now();
-    this.#zombieReported = false;
-    this.#startMonitor();
-  }
-  receivedMessage() {
-    this.#lastMessageAt = this.#now();
-    this.#zombieReported = false;
-  }
-  start(interval) {
-    this.#clearBeatTimers();
-    this.#interval = interval;
-    this.#acknowledged = true;
-    this.#initialTimer = setTimeout(() => {
-      this.#initialTimer = undefined;
-      this.sendHeartbeat();
-      this.#timer = setInterval(() => this.sendHeartbeat(), interval);
-    }, Math.random() * interval);
-  }
-  stop() {
-    this.#clearBeatTimers();
-    if (this.#monitorTimer)
-      clearInterval(this.#monitorTimer);
-    this.#monitorTimer = undefined;
-  }
-  sendHeartbeat() {
-    this.#acknowledged = false;
-    this.#sentAt = this.#now();
-    if (!this.#options.send(this.#options.sequence())) {
-      this.#options.onError(new Error("Unable to send Gateway heartbeat because the WebSocket is not open."));
-      return;
-    }
-    this.#clearAckTimer();
-    this.#ackTimer = setTimeout(() => {
-      if (this.#acknowledged)
-        return;
-      this.#options.onTimeout({
-        type: "ack",
-        elapsedMs: this.#now() - this.#sentAt
-      });
-    }, this.#options.ackTimeout);
-  }
-  acknowledge() {
-    if (this.#acknowledged)
-      return;
-    this.#acknowledged = true;
-    this.#latency = this.#now() - this.#sentAt;
-    this.#clearAckTimer();
-  }
-  #startMonitor() {
-    if (this.#monitorTimer)
-      clearInterval(this.#monitorTimer);
-    const interval = Math.max(1, Math.min(MAX_MONITOR_INTERVAL, this.#options.ackTimeout, this.#options.zombieTimeout / 2));
-    this.#monitorTimer = setInterval(() => this.#checkStaleness(), interval);
-  }
-  #checkStaleness() {
-    if (!this.#options.isConnected() || this.#lastMessageAt === 0)
-      return;
-    const silentFor = this.silentFor;
-    const deadline = this.stalenessDeadline;
-    if (silentFor < deadline || this.#zombieReported)
-      return;
-    this.#zombieReported = true;
-    this.#options.onTimeout({ type: "zombie", silentFor, deadline });
-  }
-  #clearAckTimer() {
-    if (this.#ackTimer)
-      clearTimeout(this.#ackTimer);
-    this.#ackTimer = undefined;
-  }
-  #clearBeatTimers() {
-    if (this.#timer)
-      clearInterval(this.#timer);
-    if (this.#initialTimer)
-      clearTimeout(this.#initialTimer);
-    this.#clearAckTimer();
-    this.#timer = undefined;
-    this.#initialTimer = undefined;
-  }
-}
-
-// packages/ws/src/close-codes.ts
-var GatewayCloseCodes = {
-  UnknownError: 4000,
-  UnknownOpcode: 4001,
-  DecodeError: 4002,
-  NotAuthenticated: 4003,
-  AuthenticationFailed: 4004,
-  AlreadyAuthenticated: 4005,
-  InvalidSeq: 4007,
-  RateLimited: 4008,
-  SessionTimedOut: 4009,
-  InvalidShard: 4010,
-  ShardingRequired: 4011,
-  InvalidAPIVersion: 4012,
-  InvalidIntents: 4013,
-  DisallowedIntents: 4014
-};
-
-// packages/ws/src/reconnect.ts
-var FATAL_CLOSE_CODES = [
-  GatewayCloseCodes.AuthenticationFailed,
-  GatewayCloseCodes.InvalidShard,
-  GatewayCloseCodes.ShardingRequired,
-  GatewayCloseCodes.InvalidAPIVersion,
-  GatewayCloseCodes.InvalidIntents,
-  GatewayCloseCodes.DisallowedIntents
-];
-var IDENTIFY_CLOSE_CODES = [
-  GatewayCloseCodes.InvalidSeq,
-  GatewayCloseCodes.SessionTimedOut
-];
-function classifyCloseCode(code, canResume) {
-  if (FATAL_CLOSE_CODES.includes(code))
-    return "stop";
-  if (IDENTIFY_CLOSE_CODES.includes(code))
-    return "identify";
-  return canResume ? "resume" : "identify";
-}
-
-class GatewayReconnect {
-  #options;
-  #random;
-  #attempt = 0;
-  #recent = [];
-  #timer;
-  #promise;
-  #resolve;
-  #reject;
-  constructor(options) {
-    this.#options = options;
-    this.#random = options.random ?? Math.random;
-  }
-  get enabled() {
-    return this.#options.enabled;
-  }
-  get attempts() {
-    return this.#attempt;
-  }
-  get pending() {
-    return this.#timer !== undefined;
-  }
-  get exhausted() {
-    return this.#attempt >= this.#options.maxAttempts;
-  }
-  get connecting() {
-    return this.#promise !== undefined;
-  }
-  get attemptPromise() {
-    return this.#promise;
-  }
-  classifyClose(code, canResume) {
-    return classifyCloseCode(code, canResume);
-  }
-  canReconnect() {
-    return this.#options.enabled && !this.exhausted;
-  }
-  schedule(run) {
-    if (!this.#options.enabled)
-      return { scheduled: false, reason: "disabled" };
-    if (this.#timer)
-      return { scheduled: false, reason: "pending" };
-    if (this.exhausted)
-      return { scheduled: false, reason: "exhausted" };
-    const attempt = this.#attempt;
-    const now = (this.#options.now ?? Date.now)();
-    const window = this.#options.stormWindow ?? 60000;
-    const limit = this.#options.stormLimit ?? 5;
-    while (this.#recent.length && now - this.#recent[0] >= window)
-      this.#recent.shift();
-    const over = this.#recent.length - limit;
-    this.#recent.push(now);
-    let delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
-    const unstable = over >= 0;
-    if (unstable)
-      delay = Math.min(this.#options.maxDelay, Math.max(delay, this.#options.baseDelay * 2 ** (over + 1)));
-    const jitter = this.#random() * Math.max(1, delay * 0.25);
-    const delayMs = delay + jitter;
-    this.#timer = setTimeout(() => {
-      this.#timer = undefined;
-      run();
-    }, delayMs);
-    return {
-      scheduled: true,
-      delayMs,
-      attempt,
-      ...unstable ? { unstable: { reconnects: this.#recent.length } } : {}
-    };
-  }
-  cancel() {
-    if (this.#timer)
-      clearTimeout(this.#timer);
-    this.#timer = undefined;
-  }
-  reset() {
-    this.#attempt = 0;
-  }
-  attempt(start) {
-    if (this.#promise)
-      return this.#promise;
-    this.#promise = new Promise((resolve, reject) => {
-      this.#resolve = resolve;
-      this.#reject = reject;
-      start();
-    });
-    return this.#promise;
-  }
-  settle(error) {
-    const resolve = this.#resolve;
-    const reject = this.#reject;
-    this.#resolve = undefined;
-    this.#reject = undefined;
-    this.#promise = undefined;
-    if (error)
-      reject?.(error);
-    else
-      resolve?.();
-  }
-}
-
-// packages/ws/src/decoder.ts
-import {
-  createInflate,
-  constants as zlibConstants
-} from "zlib";
-async function toBytes(data) {
-  if (data instanceof Uint8Array)
-    return data;
-  if (data instanceof ArrayBuffer)
-    return new Uint8Array(data);
-  if (typeof Blob !== "undefined" && data instanceof Blob)
-    return new Uint8Array(await data.arrayBuffer());
-  throw new TypeError("Gateway returned an unsupported compressed frame type.");
-}
-
-class PlainTextDecoder {
-  push(data) {
-    return [String(data)];
-  }
-  reset() {}
-}
-
-class ZlibStreamDecoder {
-  #create;
-  #maxFrameBytes;
-  #inflate;
-  #chunks = [];
-  #size = 0;
-  #failure;
-  #pendingReject;
-  constructor(create = () => createInflate(), maxFrameBytes = 64 * 1024 * 1024) {
-    this.#create = create;
-    this.#maxFrameBytes = maxFrameBytes;
-  }
-  push(data) {
-    if (typeof data === "string")
-      return [data];
-    return this.#inflateFrame(data);
-  }
-  async#inflateFrame(data) {
-    const chunk = await toBytes(data);
-    const inflate = this.#inflate ??= this.#open();
-    if (this.#failure)
-      throw this.#failure;
-    const complete = chunk.length >= 4 && chunk[chunk.length - 4] === 0 && chunk[chunk.length - 3] === 0 && chunk[chunk.length - 2] === 255 && chunk[chunk.length - 1] === 255;
-    await this.#awaiting((settle) => inflate.write(chunk, (error) => error ? settle(error) : settle()));
-    if (!complete)
-      return [];
-    await this.#awaiting((settle) => inflate.flush(zlibConstants.Z_SYNC_FLUSH, () => settle()));
-    const parts = this.#chunks;
-    this.#chunks = [];
-    this.#size = 0;
-    if (parts.length === 0)
-      return [];
-    const total = parts.reduce((size, part) => size + part.length, 0);
-    const merged = new Uint8Array(total);
-    let offset = 0;
-    for (const part of parts) {
-      merged.set(part, offset);
-      offset += part.length;
-    }
-    return [new TextDecoder().decode(merged)];
-  }
-  reset() {
-    const inflate = this.#inflate;
-    this.#inflate = undefined;
-    this.#chunks = [];
-    this.#size = 0;
-    this.#failure = undefined;
-    this.#pendingReject = undefined;
-    if (!inflate)
-      return;
-    inflate.removeAllListeners();
-    try {
-      inflate.close();
-    } catch {}
-  }
-  #awaiting(run) {
-    if (this.#failure)
-      return Promise.reject(this.#failure);
-    return new Promise((resolve, reject) => {
-      this.#pendingReject = reject;
-      run((error) => {
-        this.#pendingReject = undefined;
-        if (error)
-          reject(error);
-        else if (this.#failure)
-          reject(this.#failure);
-        else
-          resolve();
-      });
-    });
-  }
-  #open() {
-    const inflate = this.#create();
-    inflate.on("data", (chunk) => {
-      if (this.#failure)
-        return;
-      this.#size += chunk.length;
-      if (this.#size > this.#maxFrameBytes) {
-        this.#chunks = [];
-        inflate.emit("error", new Error(`Gateway frame inflated past ${this.#maxFrameBytes} bytes.`));
-        return;
-      }
-      this.#chunks.push(chunk);
-    });
-    inflate.on("error", (error) => {
-      this.#failure = error;
-      const reject = this.#pendingReject;
-      this.#pendingReject = undefined;
-      reject?.(error);
-    });
-    return inflate;
-  }
-}
-function createDecoder(compress) {
-  return compress ? new ZlibStreamDecoder : new PlainTextDecoder;
-}
-
-// packages/ws/src/transport.ts
-var OPEN = 1;
-
-class WebSocketTransport {
-  #handlers;
-  #decoder;
-  #createSocket;
-  #compress;
-  #socket;
-  #generation = 0;
-  #queue = Promise.resolve();
-  constructor(options) {
-    this.#handlers = options.handlers;
-    this.#compress = options.compress ?? false;
-    this.#decoder = options.decoder ?? createDecoder(options.compress);
-    this.#createSocket = options.createSocket ?? ((url) => new WebSocket(url));
-  }
-  get connected() {
-    return this.#socket?.readyState === OPEN;
-  }
-  get live() {
-    return this.#socket !== undefined && this.#socket.readyState <= OPEN;
-  }
-  get generation() {
-    return this.#generation;
-  }
-  connect(url) {
-    this.#discard(1000, "Superseded by a new connection");
-    const generation = ++this.#generation;
-    this.#decoder.reset();
-    this.#queue = Promise.resolve();
-    let socket;
-    try {
-      socket = this.#createSocket(url);
-    } catch (error) {
-      return { ok: false, error: this.#asError(error) };
-    }
-    if (this.#compress) {
-      try {
-        socket.binaryType = "arraybuffer";
-      } catch {}
-    }
-    this.#socket = socket;
-    socket.addEventListener("open", () => {
-      if (!this.#owns(generation))
-        return;
-      this.#handlers.onOpen();
-    });
-    socket.addEventListener("message", (event) => {
-      if (!this.#owns(generation))
-        return;
-      let decoded;
-      try {
-        decoded = this.#decoder.push(event.data);
-      } catch (error) {
-        this.#handlers.onError(this.#asError(error));
-        this.#failDecoding(generation);
-        return;
-      }
-      if (!(decoded instanceof Promise)) {
-        for (const frame of decoded)
-          this.#handlers.onFrame(frame);
-        return;
-      }
-      this.#queue = this.#queue.then(async () => {
-        const frames = await decoded;
-        if (!this.#owns(generation))
-          return;
-        for (const frame of frames)
-          this.#handlers.onFrame(frame);
-      }).catch((error) => {
-        if (!this.#owns(generation))
-          return;
-        this.#handlers.onError(this.#asError(error));
-        this.#failDecoding(generation);
-      });
-    });
-    socket.addEventListener("close", (event) => {
-      if (!this.#owns(generation))
-        return;
-      this.#socket = undefined;
-      this.#generation++;
-      this.#decoder.reset();
-      this.#handlers.onClose(event.code, event.reason ?? "");
-    });
-    socket.addEventListener("error", () => {
-      if (!this.#owns(generation))
-        return;
-      this.#handlers.onError(new Error("Gateway WebSocket error"));
-    });
-    return { ok: true };
-  }
-  send(data) {
-    if (!this.connected)
-      return false;
-    try {
-      this.#socket.send(data);
-      return true;
-    } catch (error) {
-      this.#handlers.onError(this.#asError(error));
-      return false;
-    }
-  }
-  #failDecoding(generation) {
-    if (this.#owns(generation))
-      this.close(4000, "decoder failure");
-  }
-  close(code = 1000, reason = "") {
-    const socket = this.#socket;
-    if (!socket)
-      return;
-    try {
-      socket.close(code, reason);
-    } catch (error) {
-      this.#handlers.onError(this.#asError(error));
-    }
-  }
-  destroy(code = 1000, reason = "") {
-    this.#discard(code, reason);
-    this.#decoder.reset();
-  }
-  #owns(generation) {
-    return generation === this.#generation;
-  }
-  #discard(code, reason) {
-    const socket = this.#socket;
-    if (!socket)
-      return;
-    this.#generation++;
-    this.#socket = undefined;
-    try {
-      socket.close(code, reason);
-    } catch (error) {
-      this.#handlers.onError(this.#asError(error));
-    }
-  }
-  #asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-  }
-}
-
-// packages/ws/src/opcodes.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
-};
-
-// packages/ws/src/protocol.ts
-function classifyFrame(raw) {
-  let payload;
-  try {
-    payload = JSON.parse(raw);
-  } catch (error) {
-    return {
-      sequence: null,
-      action: {
-        type: "invalid",
-        violation: "invalid-json",
-        message: "Gateway returned invalid JSON",
-        cause: error
-      }
-    };
-  }
-  return classifyPayload(payload);
-}
-function classifyPayload(payload) {
-  if (payload === null || typeof payload !== "object" || typeof payload.op !== "number")
-    return {
-      sequence: null,
-      action: {
-        type: "invalid",
-        violation: "invalid-payload",
-        message: "Gateway returned an invalid payload"
-      }
-    };
-  const frame = payload;
-  const sequence = typeof frame.s === "number" ? frame.s : null;
-  switch (frame.op) {
-    case GatewayOpcodes.Dispatch:
-      return {
-        sequence,
-        action: {
-          type: "dispatch",
-          event: typeof frame.t === "string" ? frame.t : null,
-          data: frame.d
-        }
-      };
-    case GatewayOpcodes.Hello: {
-      const interval = frame.d?.heartbeat_interval;
-      if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0)
-        return {
-          sequence,
-          action: {
-            type: "invalid",
-            violation: "invalid-hello",
-            message: "Gateway HELLO payload contains an invalid heartbeat interval"
-          }
-        };
-      return {
-        sequence,
-        action: { type: "hello", heartbeatInterval: interval }
-      };
-    }
-    case GatewayOpcodes.Heartbeat:
-      return { sequence, action: { type: "heartbeat" } };
-    case GatewayOpcodes.HeartbeatAck:
-      return {
-        sequence,
-        action: { type: "heartbeat-ack", data: frame.d }
-      };
-    case GatewayOpcodes.Reconnect:
-      return { sequence, action: { type: "reconnect" } };
-    case GatewayOpcodes.InvalidSession:
-      return {
-        sequence,
-        action: {
-          type: "invalid-session",
-          resumable: frame.d === true
-        }
-      };
-    default:
-      return { sequence, action: { type: "unknown", opcode: frame.op } };
-  }
-}
-function identifyPayload(options) {
-  const props = options.properties ?? {};
-  const os = props.os ?? process.platform;
-  const browser = props.browser ?? "Lunibee";
-  const device = props.device ?? "Lunibee";
-  return {
-    op: GatewayOpcodes.Identify,
-    d: {
-      token: options.token,
-      intents: options.intents,
-      properties: {
-        os,
-        browser,
-        device,
-        $os: os,
-        $browser: browser,
-        $device: device,
-        ...props
-      },
-      presence: {
-        since: options.presence?.since ?? null,
-        activities: options.presence?.activities ?? [],
-        status: options.presence?.status ?? "online",
-        afk: Boolean(options.presence?.afk)
-      },
-      shard: [options.shardId, options.shardCount]
-    },
-    s: null,
-    t: null
-  };
-}
-function resumePayload(token, resume) {
-  return {
-    op: GatewayOpcodes.Resume,
-    d: {
-      token,
-      session_id: resume.sessionId,
-      seq: resume.sequence
-    },
-    s: null,
-    t: null
-  };
-}
-function heartbeatPayload(sequence) {
-  return { op: GatewayOpcodes.Heartbeat, d: sequence, s: null, t: null };
-}
-
-// packages/types/src/channel-kind.ts
-var ChannelKinds = {
-  text: [0],
-  dm: [1],
-  voice: [2],
-  "group-dm": [3],
-  category: [4],
-  announcement: [5],
-  thread: [10, 11, 12],
-  stage: [13],
-  directory: [14],
-  forum: [15],
-  media: [16]
-};
-var KIND_OF_TYPE = new Map(Object.keys(ChannelKinds).flatMap((kind) => ChannelKinds[kind].map((type) => [type, kind])));
-// packages/types/src/gateway.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 (!Array.isArray(intents))
-    throw new TypeError("Gateway intents must be an array, e.g. [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages].");
-  return intents.reduce((acc, intent) => acc | resolveIntent(intent), 0);
-}
-function resolveIntent(intent) {
-  if (typeof intent === "number")
-    return intent;
-  const bits = {
-    ...IntentBits,
-    ...GatewayIntentBits
-  };
-  const lower = intent.charAt(0).toLowerCase() + intent.slice(1);
-  if (Object.hasOwn(bits, intent))
-    return bits[intent];
-  if (Object.hasOwn(bits, lower))
-    return bits[lower];
-  const num = Number(intent);
-  return Number.isNaN(num) ? 0 : num;
-}
-// packages/ws/src/dispatcher.ts
-class GatewayDispatcher {
-  #listeners = new Map;
-  #onFailure;
-  constructor(onFailure) {
-    this.#onFailure = onFailure;
-  }
-  on(event, listener) {
-    let listeners = this.#listeners.get(event);
-    if (!listeners)
-      this.#listeners.set(event, listeners = new Set);
-    listeners.add(listener);
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-  }
-  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.#onFailure(error);
-          });
-      } catch (error) {
-        if (event !== "error")
-          this.#onFailure(error);
-      }
-    }
-  }
-}
-// packages/ws/src/send-budget.ts
-class GatewaySendLimiter {
-  #timestamps = [];
-  #limit;
-  #windowMs;
-  constructor(limit = 115, windowMs = 60000) {
-    this.#limit = limit;
-    this.#windowMs = windowMs;
-  }
-  get used() {
-    return this.#timestamps.length;
-  }
-  allows(privileged, now = Date.now()) {
-    while (this.#timestamps.length && now - this.#timestamps[0] >= this.#windowMs)
-      this.#timestamps.shift();
-    return privileged || this.#timestamps.length < this.#limit;
-  }
-  record(now = Date.now()) {
-    this.#timestamps.push(now);
-  }
-}
-// packages/ws/src/state.ts
-class GatewayError extends Error {
-  code;
-  constructor(message, code, options) {
-    super(message, options);
-    this.name = "GatewayError";
-    this.code = code;
-  }
-}
-// packages/ws/src/index.ts
-var RESUMABLE_CLOSE_CODE = 4900;
-var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
-
-class Gateway {
-  state = "CONNECT" /* Connect */;
-  #options;
-  #transport;
-  #session = new GatewaySession;
-  #token = 0;
-  #heartbeat;
-  #closed = false;
-  #reconnect;
-  #events = new GatewayDispatcher((error) => this.#emitError(error));
-  #sendBudget = new GatewaySendLimiter;
-  #reconnects = 0;
-  ping = -1;
-  constructor(options) {
-    if (!options.token?.trim())
-      throw new TypeError("A Gateway token is required.");
-    for (const key of [
-      "reconnectBaseDelay",
-      "reconnectMaxDelay",
-      "connectTimeout"
-    ])
-      if (options[key] !== undefined && !(options[key] > 0))
-        throw new RangeError(`Gateway ${key} must be greater than 0.`);
-    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,
-      connectTimeout: 30000,
-      reconnectBaseDelay: 1000,
-      reconnectMaxDelay: 30000,
-      heartbeatAckTimeout: 1e4,
-      zombieTimeout: 30000,
-      properties: {
-        os: process.platform,
-        browser: "Lunibee",
-        device: "Lunibee"
-      },
-      presence: {
-        status: "online",
-        activities: [],
-        afk: false,
-        since: null
-      },
-      ...options,
-      intents: resolvedIntents
-    };
-    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");
-    this.#transport = new WebSocketTransport({
-      compress: this.#options.compress,
-      createSocket: options.createSocket,
-      handlers: {
-        onOpen: () => this.#onOpen(),
-        onFrame: (raw) => this.#message(raw, this.#token),
-        onClose: (code) => this.#close(code, this.#token),
-        onError: (error) => this.#emitError(error instanceof GatewayError ? error : new GatewayError(error.message, undefined, {
-          cause: error
-        }))
-      }
-    });
-    this.#reconnect = new GatewayReconnect({
-      enabled: this.#options.reconnect,
-      maxAttempts: this.#options.maxReconnectAttempts,
-      baseDelay: this.#options.reconnectBaseDelay,
-      maxDelay: this.#options.reconnectMaxDelay,
-      stormLimit: options.reconnectStormLimit,
-      stormWindow: options.reconnectStormWindow
-    });
-    this.#heartbeat = new GatewayHeartbeat({
-      ackTimeout: this.#options.heartbeatAckTimeout,
-      zombieTimeout: this.#options.zombieTimeout,
-      send: (sequence) => this.#dispatch(heartbeatPayload(sequence), true),
-      sequence: () => this.#session.sequence,
-      isConnected: () => !this.#closed && this.#transport.connected,
-      onTimeout: (timeout) => this.#onHeartbeatTimeout(timeout),
-      onError: (error) => this.#emitError(error)
-    });
-  }
-  #onHeartbeatTimeout(timeout) {
-    if (timeout.type === "zombie") {
-      this.#emit("zombie", {
-        silentFor: timeout.silentFor,
-        timeout: timeout.deadline
-      });
-      this.#emitError(new GatewayError(`Gateway connection appears stale after ${timeout.silentFor}ms without traffic.`));
-    } else {
-      this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${timeout.elapsedMs}ms.`));
-    }
-    this.#transport.close(RESUMABLE_CLOSE_CODE, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
-  }
-  connect(url = DEFAULT_GATEWAY_URL) {
-    if (this.state === "CLOSED" /* Closed */)
-      return Promise.reject(new GatewayError("Gateway has been permanently closed."));
-    const inFlight = this.#reconnect.attemptPromise;
-    if (inFlight)
-      return inFlight;
-    if (this.#transport.live)
-      return Promise.resolve();
-    this.#reconnect.cancel();
-    this.#closed = false;
-    this.#setState("CONNECT" /* Connect */);
-    const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}${url.includes("?") ? "&" : "?"}compress=zlib-stream` : url;
-    return this.#reconnect.attempt(() => this.#open(connectURL));
-  }
-  close() {
-    this.#closed = true;
-    this.#clearTimers();
-    this.#settleConnect(new GatewayError("Gateway connection closed before socket open."));
-    this.#transport.destroy(1000, "Client closed connection");
-    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.");
-    this.#events.on(event, listener);
-    return this;
-  }
-  off(event, listener) {
-    this.#events.off(event, listener);
-    return this;
-  }
-  health() {
-    return {
-      state: this.state,
-      latency: this.#heartbeat.latency,
-      silentFor: this.#heartbeat.silentFor,
-      reconnects: this.#reconnects
-    };
-  }
-  send(payload) {
-    if (!payload || !Number.isInteger(payload.op))
-      throw new TypeError("Gateway payload must contain an integer opcode.");
-    return this.#dispatch(payload, false);
-  }
-  #dispatch(payload, privileged) {
-    if (!this.#transport.connected)
-      return false;
-    const now = Date.now();
-    if (!this.#sendBudget.allows(privileged, now)) {
-      this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
-      return false;
-    }
-    if (!this.#transport.send(JSON.stringify(payload)))
-      return false;
-    this.#sendBudget.record(now);
-    return true;
-  }
-  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
-    });
-  }
-  sendVoiceState(guildId, channelId, options = {}) {
-    if (!this.ownsGuild(guildId))
-      return false;
-    return this.setVoiceState({
-      guild_id: guildId,
-      channel_id: channelId,
-      self_mute: options.selfMute ?? false,
-      self_deaf: options.selfDeaf ?? false
-    });
-  }
-  ownsGuild(guildId) {
-    const count = this.#options.shardCount;
-    if (count <= 1)
-      return true;
-    if (!/^\d{1,20}$/.test(guildId))
-      return false;
-    return Number((BigInt(guildId) >> 22n) % BigInt(count)) === this.#options.shardId;
-  }
-  requestGuildMembers(data) {
-    return this.send({
-      op: GatewayOpcodes.RequestGuildMembers,
-      d: data,
-      s: null,
-      t: null
-    });
-  }
-  #open(url) {
-    if (this.#closed)
-      return;
-    this.#token = this.#session.beginConnection();
-    const result = this.#transport.connect(url);
-    if (result.ok) {
-      const token = this.#token;
-      clearTimeout(this.#connectTimer);
-      this.#connectTimer = setTimeout(() => {
-        if (token === this.#token && !this.#closed)
-          this.#transport.close(4000, "connect timeout");
-      }, this.#options.connectTimeout);
-      this.#connectTimer.unref?.();
-      return;
-    }
-    const failure = this.#normalizeError(result.error);
-    this.#emitError(failure);
-    if (this.#options.reconnect) {
-      this.#setState("RECONNECT" /* Reconnect */);
-      this.#scheduleReconnect();
-    } else {
-      this.#settleConnect(failure);
-    }
-  }
-  #connectTimer;
-  #onOpen() {
-    clearTimeout(this.#connectTimer);
-    this.#heartbeat.watch();
-    this.#emit("open", undefined);
-    this.#settleConnect();
-  }
-  #message(raw, token) {
-    if (!this.#session.owns(token))
-      return;
-    this.#heartbeat.receivedMessage();
-    const { sequence, action } = classifyFrame(raw);
-    if (sequence !== null)
-      this.#session.recordSequence(sequence, token);
-    this.#apply(action, token);
-  }
-  #apply(action, token) {
-    switch (action.type) {
-      case "dispatch":
-        this.#setState("DISPATCH" /* Dispatch */);
-        this.#handleDispatch(action.event, action.data, token);
-        return;
-      case "hello":
-        this.#handleHello(action.heartbeatInterval);
-        return;
-      case "heartbeat":
-        this.#setState("HEARTBEAT" /* Heartbeat */);
-        this.#heartbeat.sendHeartbeat();
-        return;
-      case "heartbeat-ack":
-        this.#heartbeat.acknowledge();
-        this.ping = this.#heartbeat.latency;
-        this.#emit("heartbeatAck", action.data);
-        return;
-      case "reconnect":
-        this.#transport.close(RESUMABLE_CLOSE_CODE, "Server requested reconnect");
-        return;
-      case "invalid-session": {
-        if (!action.resumable)
-          this.#session.invalidate(token, "invalid-session");
-        this.#emit("invalidSession", action.resumable);
-        this.#transport.close(action.resumable ? GatewayCloseCodes.UnknownError : 1000, action.resumable ? "Invalid session (resumable)" : "Invalid session");
-        return;
-      }
-      case "invalid":
-        this.#emitError(new GatewayError(action.message, undefined, action.cause === undefined ? undefined : { cause: action.cause }));
-        this.#transport.close(1002, action.violation === "invalid-json" ? "Invalid JSON" : action.violation === "invalid-hello" ? "Invalid heartbeat interval" : "Invalid payload");
-        return;
-      case "unknown":
-        return;
-    }
-  }
-  #handleDispatch(event, data, token) {
-    if (event === "READY") {
-      if (!this.#session.activate(data, token)) {
-        if (this.#session.owns(token))
-          this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
-        return;
-      }
-      this.#reconnect.reset();
-      this.#setState("READY" /* Ready */);
-      this.#emit("ready", data);
-    } else if (event === "RESUMED") {
-      this.#reconnect.reset();
-      this.#setState("READY" /* Ready */);
-      this.#emit("resumed", data);
-    }
-    this.#emit("RAW", { event: event ?? "UNKNOWN", data });
-    if (this.#closed)
-      return;
-    if (event == null || /^[A-Z][A-Z0-9_]*$/.test(event))
-      this.#emit(event ?? "dispatch", data);
-  }
-  #handleHello(interval) {
-    this.#setState(this.#session.canResume ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
-    this.#heartbeat.start(interval);
-    this.#identifyOrResume();
-  }
-  #identifyOrResume() {
-    const intent = this.#session.handshake();
-    if (intent.type === "resume") {
-      this.#setState("RESUME" /* Resume */);
-      this.#dispatch(resumePayload(this.#options.token, intent), true);
-      return;
-    }
-    this.#setState("IDENTIFY" /* Identify */);
-    this.#dispatch(identifyPayload({
-      token: this.#options.token,
-      intents: this.#options.intents,
-      shardId: this.#options.shardId,
-      shardCount: this.#options.shardCount,
-      properties: this.#options.properties,
-      presence: this.#options.presence
-    }), true);
-  }
-  #close(code, token) {
-    this.#clearTimers();
-    const action = this.#reconnect.classifyClose(code, this.#session.canResume);
-    this.#emit("close", { code, action });
-    if (this.#closed || !this.#reconnect.enabled || action === "stop") {
-      if (action === "stop")
-        this.#closed = true;
-      this.#setState(this.#closed ? "CLOSED" /* Closed */ : "CONNECT" /* Connect */);
-      if (this.#reconnect.connecting)
-        this.#reconnect.settle(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
-      return;
-    }
-    if (action === "identify")
-      this.#session.invalidate(token, "session-timeout");
-    this.#setState("RECONNECT" /* Reconnect */);
-    this.#scheduleReconnect();
-  }
-  #scheduleReconnect() {
-    if (this.#closed)
-      return;
-    const result = this.#reconnect.schedule(() => this.#open(this.#session.connectURL(DEFAULT_GATEWAY_URL)));
-    if (result.scheduled) {
-      this.#reconnects++;
-      if (result.unstable)
-        this.#emit("unstable", {
-          reconnects: result.unstable.reconnects,
-          delay: result.delayMs
-        });
-      return;
-    }
-    if (result.reason !== "exhausted")
-      return;
-    this.#reconnect.settle(new GatewayError("Gateway reconnect attempts exhausted."));
-    this.#setState("CONNECT" /* Connect */);
-  }
-  #settleConnect(error) {
-    this.#reconnect.settle(error);
-  }
-  #clearTimers() {
-    clearTimeout(this.#connectTimer);
-    this.#reconnect.cancel();
-    this.#heartbeat.stop();
-  }
-  #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) {
-    this.#events.emit(event, data);
-  }
-  #setState(next) {
-    if (this.state === next)
-      return;
-    const previous = this.state;
-    this.state = next;
-    this.#emit("stateChange", { previous, next });
-  }
-}
-
-// packages/sharding/src/context.ts
-var WORKER_MARKER = "LUNIBEE_CLUSTER_WORKER";
-function isClusterWorker(env = process.env) {
-  return env[WORKER_MARKER] === "1";
-}
-function validateShardIds(shardIds, total) {
-  if (!Number.isInteger(total) || total < 1)
-    throw new RangeError("Shard count must be a positive integer.");
-  const seen = new Set;
-  for (const id of shardIds) {
-    if (!Number.isInteger(id) || id < 0 || id >= total)
-      throw new RangeError(`Shard ID ${String(id)} is outside 0-${total - 1}.`);
-    if (seen.has(id))
-      throw new RangeError(`Shard ID ${id} is listed twice.`);
-    seen.add(id);
-  }
-}
-function allocateShards(shardIds, clusterCount) {
-  if (!Number.isInteger(clusterCount) || clusterCount < 1)
-    throw new RangeError("clusterCount must be a positive integer.");
-  const chunks = Array.from({ length: clusterCount }, () => []);
-  shardIds.forEach((id, index) => chunks[index % clusterCount].push(id));
-  return chunks;
-}
-function assertCompleteAllocation(chunks, expected) {
-  const owners = new Map;
-  const duplicate = [];
-  chunks.forEach((chunk, cluster) => {
-    for (const id of chunk) {
-      if (owners.has(id))
-        duplicate.push(id);
-      owners.set(id, cluster);
-    }
-  });
-  const want = new Set(expected);
-  const missing = expected.filter((id) => !owners.has(id));
-  const extra = [...owners.keys()].filter((id) => !want.has(id));
-  if (duplicate.length || missing.length || extra.length)
-    throw new Error(`Shard allocation is not exact: duplicate [${duplicate}], missing [${missing}], unexpected [${extra}].`);
-}
-function parseInteger(name, value) {
-  if (value === undefined || !/^\d+$/.test(value))
-    throw new RangeError(`${name} must be a non-negative integer.`);
-  return Number(value);
-}
-function readClusterContext(env = process.env) {
-  if (!isClusterWorker(env))
-    return null;
-  const shardCount = parseInteger("SHARD_COUNT", env.SHARD_COUNT);
-  const shardIds = (env.SHARD_LIST ?? "").split(",").filter((part) => part !== "").map((part) => parseInteger("SHARD_LIST", part));
-  validateShardIds(shardIds, shardCount);
-  return {
-    clusterId: parseInteger("CLUSTER_ID", env.CLUSTER_ID),
-    clusterCount: parseInteger("CLUSTER_COUNT", env.CLUSTER_COUNT),
-    shardCount,
-    shardIds,
-    coordinatedIdentify: env.LUNIBEE_IDENTIFY === "coordinated"
-  };
-}
-
-// packages/sharding/src/protocol.ts
-var CLUSTER_FRAME = "__lunibeeCluster";
-var PARENT_ID = -1;
-var REQUEST_HEALTH = "__lunibee:health";
-var REQUEST_ASSIGN = "__lunibee:assign";
-var isRecord = (value) => typeof value === "object" && value !== null;
-var isShardId = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
-function parseChildFrame(value) {
-  if (!isRecord(value))
-    return null;
-  switch (value.kind) {
-    case "ready":
-      return Array.isArray(value.shardIds) && value.shardIds.every(isShardId) ? { kind: "ready", shardIds: value.shardIds } : null;
-    case "identify":
-      return typeof value.id === "number" && isShardId(value.shardId) ? { kind: "identify", id: value.id, shardId: value.shardId } : null;
-    case "identify-done":
-      return isShardId(value.shardId) ? { kind: "identify-done", shardId: value.shardId } : null;
-    case "reply":
-      return typeof value.id === "string" && (value.error === undefined || typeof value.error === "string") ? {
-        kind: "reply",
-        id: value.id,
-        ...value.error !== undefined ? { error: value.error } : { result: value.result }
-      } : null;
-    case "health":
-      return isRecord(value.report) && Array.isArray(value.report.shards) && typeof value.report.reportedAt === "number" ? { kind: "health", report: value.report } : null;
-    default:
-      return null;
-  }
-}
-function parseParentFrame(value) {
-  if (!isRecord(value))
-    return null;
-  switch (value.kind) {
-    case "identify-grant":
-      return typeof value.id === "number" ? { kind: "identify-grant", id: value.id } : null;
-    case "identify-deny":
-      return typeof value.id === "number" && typeof value.error === "string" ? { kind: "identify-deny", id: value.id, error: value.error } : null;
-    case "request":
-      return typeof value.id === "string" && typeof value.type === "string" ? {
-        kind: "request",
-        id: value.id,
-        type: value.type,
-        data: value.data
-      } : null;
-    default:
-      return null;
-  }
-}
-
-// packages/sharding/src/thread.ts
-import { EventEmitter } from "events";
+import"../chunks/index-fdvgk2sw.js";
+import"../chunks/index-gyvps8b9.js";
 import {
-  isMainThread,
-  parentPort,
-  Worker,
-  workerData
-} from "worker_threads";
-var THREAD_MARKER = "__lunibeeClusterThread";
-
-class ThreadChild extends EventEmitter {
-  pid;
-  exitCode = null;
-  signalCode = null;
-  connected = true;
-  #worker;
-  #signal;
-  constructor(worker) {
-    super();
-    this.#worker = worker;
-    this.pid = worker.threadId;
-    worker.on("message", (frame) => this.emit("message", frame));
-    worker.on("error", (error) => this.emit("error", error));
-    worker.once("exit", (code) => {
-      this.connected = false;
-      if (this.#signal) {
-        this.signalCode = this.#signal;
-        this.emit("exit", null, this.#signal);
-      } else {
-        this.exitCode = code;
-        this.emit("exit", code, null);
-      }
-    });
-  }
-  send(frame) {
-    if (!this.connected)
-      return false;
-    try {
-      this.#worker.postMessage(frame);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  kill(signal = "SIGTERM") {
-    if (!this.connected)
-      return false;
-    this.#signal ??= signal;
-    this.#worker.terminate();
-    return true;
-  }
-}
-function threadFork(options = {}) {
-  return (script, env) => {
-    const defined = {};
-    for (const [key, value] of Object.entries(env))
-      if (value !== undefined)
-        defined[key] = value;
-    const worker = new Worker(script, {
-      env: defined,
-      workerData: { [THREAD_MARKER]: true },
-      ...options.resourceLimits ? { resourceLimits: options.resourceLimits } : {}
-    });
-    return new ThreadChild(worker);
-  };
-}
-var endpoint;
-function threadEndpoint() {
-  const port = parentPort;
-  if (isMainThread || !port || !workerData?.[THREAD_MARKER])
-    return;
-  endpoint ??= portEndpoint(port);
-  return endpoint;
-}
-function portEndpoint(port) {
-  const wrapped = {
-    send: (message) => {
-      port.postMessage(message);
-      return true;
-    },
-    on: (event, listener) => {
-      if (event === "message")
-        port.on("message", listener);
-      return wrapped;
-    },
-    off: (event, listener) => {
-      if (event === "message")
-        port.off("message", listener);
-      return wrapped;
-    }
-  };
-  return wrapped;
-}
-
-// packages/sharding/src/worker.ts
-class ClusterWorker {
-  static #current;
-  static current() {
-    if (!ClusterWorker.#current) {
-      const context = readClusterContext();
-      const endpoint = typeof process.send === "function" ? process : threadEndpoint();
-      if (context && endpoint)
-        ClusterWorker.#current = new ClusterWorker(context, endpoint);
-    }
-    return ClusterWorker.#current;
-  }
-  static reset() {
-    ClusterWorker.#current?.close();
-    ClusterWorker.#current = undefined;
-  }
-  context;
-  #endpoint;
-  #handlers = new Map;
-  #waiting = new Map;
-  #onMessage;
-  #onDisconnect;
-  #counter = 0;
-  #closed = false;
-  constructor(context, endpoint = process, options = {}) {
-    if (typeof endpoint.send !== "function")
-      throw new Error("ClusterWorker needs an IPC channel: run it in a process forked by ClusterManager.");
-    this.context = context;
-    this.#endpoint = endpoint;
-    this.#onMessage = (frame) => this.#handle(frame);
-    const exitOnLoss = options.exitOnParentLoss ?? endpoint === process;
-    const exit = options.exit ?? ((code) => process.exit(code));
-    this.#onDisconnect = () => {
-      this.#failAll("The parent went away.");
-      if (exitOnLoss && !this.#closed)
-        exit(1);
-    };
-    endpoint.on("message", this.#onMessage);
-    endpoint.on("disconnect", this.#onDisconnect);
-  }
-  get identifyGate() {
-    return this.context.coordinatedIdentify ? this.#gate : undefined;
-  }
-  #gate = {
-    acquire: (shardId) => {
-      if (this.#closed)
-        return Promise.reject(new Error("The cluster worker is closed."));
-      const id = ++this.#counter;
-      return new Promise((resolve, reject) => {
-        this.#waiting.set(id, { resolve, reject });
-        this.#send({ kind: "identify", id, shardId });
-      });
-    },
-    release: (shardId) => this.#send({ kind: "identify-done", shardId })
-  };
-  ready(shardIds = this.context.shardIds) {
-    this.#send({ kind: "ready", shardIds: [...shardIds] });
-  }
-  reportHealth(report) {
-    this.#send({ kind: "health", report });
-  }
-  onRequest(type, handler) {
-    if (!type.trim() || typeof handler !== "function")
-      throw new TypeError("A request type and handler are required.");
-    this.#handlers.set(type, handler);
-    return this;
-  }
-  close() {
-    this.#closed = true;
-    this.#endpoint.off("message", this.#onMessage);
-    this.#endpoint.off("disconnect", this.#onDisconnect);
-    this.#failAll("The cluster worker closed.");
-  }
-  #send(body) {
-    try {
-      this.#endpoint.send({ [CLUSTER_FRAME]: body });
-    } catch (error) {
-      this.#failAll(error instanceof Error ? error.message : String(error));
-    }
-  }
-  #failAll(reason) {
-    for (const waiter of this.#waiting.values())
-      waiter.reject(new Error(reason));
-    this.#waiting.clear();
-  }
-  #handle(frame) {
-    if (!frame || typeof frame !== "object" || !(CLUSTER_FRAME in frame))
-      return;
-    const parsed = parseParentFrame(frame[CLUSTER_FRAME]);
-    if (!parsed)
-      return;
-    if (parsed.kind === "identify-grant" || parsed.kind === "identify-deny") {
-      const waiter = this.#waiting.get(parsed.id);
-      if (!waiter)
-        return;
-      this.#waiting.delete(parsed.id);
-      if (parsed.kind === "identify-grant")
-        waiter.resolve();
-      else
-        waiter.reject(new Error(parsed.error));
-      return;
-    }
-    const handler = this.#handlers.get(parsed.type);
-    const id = parsed.id;
-    if (!handler) {
-      this.#send({
-        kind: "reply",
-        id,
-        error: `No handler for "${parsed.type}".`
-      });
-      return;
-    }
-    (async () => {
-      try {
-        this.#send({
-          kind: "reply",
-          id,
-          result: await handler(parsed.data)
-        });
-      } catch (error) {
-        this.#send({
-          kind: "reply",
-          id,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    })();
-  }
-}
-// packages/sharding/src/transport.ts
-class BroadcastChannelTransport {
-  #channel;
-  constructor(name) {
-    this.#channel = new BroadcastChannel(name);
-  }
-  post(message) {
-    this.#channel.postMessage(message);
-  }
-  onMessage(listener) {
-    this.#channel.addEventListener("message", (event) => listener(event.data));
-  }
-  close() {
-    this.#channel.close();
-  }
-}
-var BUS_FRAME = "__lunibeeBus";
-var PEER_DOWN_FRAME = "__lunibeePeerDown";
-var LOCAL = new WeakMap;
-
-class IpcTransport {
-  #endpoint;
-  #listener;
-  #message;
-  #down;
-  constructor(endpoint = process) {
-    if (typeof endpoint.send !== "function")
-      throw new Error("IpcTransport needs an IPC channel: run the shard in a process forked by ClusterManager.");
-    this.#endpoint = endpoint;
-    this.#listener = (frame) => {
-      const record = frame;
-      if (!record || typeof record !== "object")
-        return;
-      if (BUS_FRAME in record)
-        this.#message?.(record[BUS_FRAME]);
-      else if (PEER_DOWN_FRAME in record)
-        this.#down?.(record[PEER_DOWN_FRAME]);
-    };
-    endpoint.on("message", this.#listener);
-    let local = LOCAL.get(endpoint);
-    if (!local)
-      LOCAL.set(endpoint, local = new Set);
-    local.add(this);
-  }
-  post(message) {
-    this.#endpoint.send({ [BUS_FRAME]: message });
-    for (const peer of LOCAL.get(this.#endpoint) ?? [])
-      if (peer !== this) {
-        const copy = structuredClone(message);
-        queueMicrotask(() => peer.#message?.(copy));
-      }
-  }
-  onMessage(listener) {
-    this.#message = listener;
-  }
-  onPeerDown(listener) {
-    this.#down = listener;
-  }
-  close() {
-    this.#endpoint.off("message", this.#listener);
-    LOCAL.get(this.#endpoint)?.delete(this);
-  }
-}
-function defaultTransport(name) {
-  if (process.env.LUNIBEE_SHARD_BUS === "ipc") {
-    if (typeof process.send === "function")
-      return new IpcTransport;
-    const thread = threadEndpoint();
-    if (thread)
-      return new IpcTransport(thread);
-  }
-  return new BroadcastChannelTransport(name);
-}
-
-// packages/sharding/src/bus.ts
-var REPLY_TYPE = "__lunibee:reply";
-var MAX_NAME_LENGTH = 256;
-function isShardMessage(message) {
-  if (!message || typeof message !== "object")
-    return false;
-  const m = message;
-  return typeof m.type === "string" && m.type.length > 0 && m.type.length <= MAX_NAME_LENGTH && typeof m.id === "string" && m.id.length <= MAX_NAME_LENGTH && Number.isInteger(m.source) && m.source >= -1 && (m.target === null || Number.isInteger(m.target) && m.target >= -1);
-}
-
-class ShardBus {
-  #transport;
-  #maxPending;
-  #handlers = new Map;
-  #responders = new Map;
-  #errorHandlers = new Set;
-  #shardId;
-  #namespace;
-  channelName;
-  #counter = 0;
-  #pending = new Map;
-  #closed = false;
-  constructor(shardId, channelName, options = {}) {
-    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.#maxPending = options.maxPending ?? 1e4;
-    this.#transport = options.transport ?? defaultTransport(this.channelName);
-    this.#transport.onMessage((message) => this.#dispatch(message));
-    this.#transport.onPeerDown?.((shardIds) => this.#peerDown(shardIds));
-  }
-  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) {
-    const handlers = this.#handlers.get(type);
-    handlers?.delete(handler);
-    const responder = this.#responders.get(type)?.get(handler);
-    if (responder) {
-      handlers?.delete(responder);
-      this.#responders.get(type).delete(handler);
-    }
-    return this;
-  }
-  onError(handler) {
-    if (typeof handler !== "function")
-      throw new TypeError("Shard bus error handler is required.");
-    this.#errorHandlers.add(handler);
-    return this;
-  }
-  offError(handler) {
-    this.#errorHandlers.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);
-  }
-  respond(type, handler) {
-    const wrapper = async (message) => {
-      if (!message.expectsReply)
-        return;
-      const reply = { requestId: message.id };
-      try {
-        reply.result = await handler(message.data, message);
-      } catch (error) {
-        reply.error = error instanceof Error ? error.message : String(error);
-      }
-      this.#publish(message.source, REPLY_TYPE, reply);
-    };
-    let byType = this.#responders.get(type);
-    if (!byType)
-      this.#responders.set(type, byType = new Map);
-    byType.set(handler, wrapper);
-    return this.on(type, wrapper);
-  }
-  async request(target, type, data, timeoutMs = 5000) {
-    if (!Number.isInteger(target) || target < 0)
-      throw new RangeError("Shard target must be a non-negative integer.");
-    const [reply] = await this.#collect(target, type, data, timeoutMs, 1, true);
-    if (!reply)
-      throw new Error(`Shard ${target} did not reply to "${type}" within ${timeoutMs}ms.`);
-    if (reply.error !== undefined)
-      throw new Error(reply.error);
-    return reply.result;
-  }
-  broadcastRequest(type, data, options = {}) {
-    return this.#collect(null, type, data, options.timeoutMs ?? 5000, options.expected ?? Number.POSITIVE_INFINITY);
-  }
-  #collect(target, type, data, timeoutMs, expected, rejectOnPeerDown = false) {
-    const replies = [];
-    if (this.#closed)
-      return Promise.reject(new Error("ShardBus is closed."));
-    if (this.#pending.size >= this.#maxPending)
-      return Promise.reject(new Error(`Too many shard requests waiting for a reply (${this.#maxPending}).`));
-    return new Promise((resolve, reject) => {
-      let requestId = "";
-      const finish = () => {
-        clearTimeout(timer);
-        this.#pending.delete(requestId);
-        resolve(replies);
-      };
-      const timer = setTimeout(finish, timeoutMs);
-      requestId = this.#publish(target, type, data, true);
-      const fail = (error) => {
-        if (!rejectOnPeerDown)
-          return;
-        clearTimeout(timer);
-        this.#pending.delete(requestId);
-        reject(error);
-      };
-      this.#pending.set(requestId, {
-        target,
-        seen: new Set,
-        reply: (reply) => {
-          replies.push(reply);
-          if (replies.length >= expected)
-            finish();
-        },
-        fail,
-        cancel: (error) => rejectOnPeerDown ? fail(error) : finish()
-      });
-    });
-  }
-  close() {
-    if (this.#closed)
-      return;
-    this.#closed = true;
-    for (const pending of [...this.#pending.values()])
-      pending.cancel(new Error("ShardBus is closed."));
-    this.#pending.clear();
-    this.#transport.close();
-    this.#handlers.clear();
-    this.#errorHandlers.clear();
-  }
-  #publish(target, type, data, expectsReply = false) {
-    if (!type.trim())
-      throw new TypeError("Shard message type is required.");
-    if (this.#closed)
-      throw new Error("ShardBus is closed.");
-    const id = `${this.#namespace}:${this.#shardId}:${++this.#counter}`;
-    this.#transport.post({
-      source: this.#shardId,
-      target,
-      type,
-      data,
-      id,
-      ...expectsReply ? { expectsReply } : {}
-    });
-    return id;
-  }
-  #dispatch(message) {
-    if (this.#closed || !isShardMessage(message))
-      return;
-    if (message.source === this.#shardId || message.target !== null && message.target !== this.#shardId)
-      return;
-    if (message.type === REPLY_TYPE) {
-      const reply = message.data;
-      if (!reply || typeof reply !== "object" || typeof reply.requestId !== "string")
-        return;
-      const pending = this.#pending.get(reply.requestId);
-      if (!pending || pending.seen.has(message.source) || pending.target !== null && pending.target !== message.source)
-        return;
-      pending.seen.add(message.source);
-      pending.reply({
-        shardId: message.source,
-        ...reply.error !== undefined ? { error: String(reply.error) } : { result: reply.result }
-      });
-      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((error) => this.#reportError(error, message));
-      } catch (error) {
-        this.#reportError(error, message);
-      }
-    }
-  }
-  #peerDown(shardIds) {
-    const down = new Set(shardIds);
-    for (const [id, pending] of this.#pending)
-      if (pending.target !== null && down.has(pending.target)) {
-        pending.fail(new Error(`Shard ${pending.target} went away before it replied.`));
-        this.#pending.delete(id);
-      }
-  }
-  #reportError(error, message) {
-    if (this.#errorHandlers.size === 0) {
-      process.emitWarning(error instanceof Error ? error : new Error(String(error)), { code: "LUNIBEE_SHARD_BUS_ERROR" });
-      return;
-    }
-    for (const handler of this.#errorHandlers) {
-      try {
-        handler(error, message);
-      } catch {}
-    }
-  }
-}
-// packages/sharding/src/supervisor.ts
-class ShardSupervisor {
-  #options;
-  #restarts = new Map;
-  #random;
-  constructor(options = {}, random = Math.random) {
-    this.#options = {
-      restartDelay: options.restartDelay ?? 5000,
-      backoff: options.backoff ?? 1,
-      maxDelay: options.maxDelay ?? 300000,
-      jitter: options.jitter ?? 0,
-      maxRestarts: options.maxRestarts ?? Number.POSITIVE_INFINITY,
-      window: options.window ?? 60000
-    };
-    const { restartDelay, backoff, jitter, maxDelay, window, maxRestarts } = this.#options;
-    if (!(restartDelay >= 0) || !(maxDelay >= 0) || !(window > 0))
-      throw new RangeError("restartDelay and maxDelay cannot be negative, and window must be positive.");
-    if (!(backoff >= 1))
-      throw new RangeError("backoff must be at least 1.");
-    if (!(jitter >= 0 && jitter <= 1))
-      throw new RangeError("jitter must be between 0 and 1.");
-    if (!(maxRestarts >= 0))
-      throw new RangeError("maxRestarts cannot be negative.");
-    this.#random = random;
-  }
-  next(id, now = Date.now()) {
-    const { window, maxRestarts, restartDelay, backoff, maxDelay, jitter } = this.#options;
-    const recent = (this.#restarts.get(id) ?? []).filter((at) => now - at < window);
-    if (recent.length >= maxRestarts) {
-      this.#restarts.delete(id);
-      return null;
-    }
-    recent.push(now);
-    this.#restarts.set(id, recent);
-    const base = Math.min(maxDelay, restartDelay * backoff ** (recent.length - 1));
-    return Math.min(maxDelay, Math.round(base * (1 + jitter * this.#random())));
-  }
-  reset(id) {
-    if (id === undefined)
-      this.#restarts.clear();
-    else
-      this.#restarts.delete(id);
-  }
-}
-// packages/sharding/src/cluster.ts
-import { fork } from "child_process";
-import { cpus } from "os";
-
-// packages/sharding/src/identify.ts
-var IDENTIFY_INTERVAL = 5000;
-
-class IdentifyCoordinator {
-  maxConcurrency;
-  #interval;
-  #holdTimeout;
-  #now;
-  #schedule;
-  #cancel;
-  #onBudgetWait;
-  #keys = new Map;
-  #remaining;
-  #total;
-  #resetAt = Number.POSITIVE_INFINITY;
-  #period = 24 * 60 * 60 * 1000;
-  #timer;
-  #timerAt = Number.POSITIVE_INFINITY;
-  #closed = false;
-  constructor(options = {}) {
-    const concurrency = options.maxConcurrency ?? 1;
-    if (!Number.isInteger(concurrency) || concurrency < 1)
-      throw new RangeError("maxConcurrency must be a positive integer.");
-    const interval = options.interval ?? IDENTIFY_INTERVAL;
-    const hold = options.holdTimeout ?? 60000;
-    if (!(interval >= 0) || !(hold > 0))
-      throw new RangeError("interval cannot be negative and holdTimeout must be positive.");
-    this.maxConcurrency = concurrency;
-    this.#interval = interval;
-    this.#holdTimeout = hold;
-    this.#now = options.now ?? Date.now;
-    this.#schedule = options.schedule ?? ((callback, ms) => {
-      const timer = setTimeout(callback, ms);
-      timer.unref?.();
-      return timer;
-    });
-    this.#cancel = options.cancel ?? ((handle) => clearTimeout(handle));
-    this.#onBudgetWait = options.onBudgetWait;
-    if (options.budget) {
-      this.#total = options.budget.total;
-      this.#remaining = options.budget.remaining;
-      this.#resetAt = this.#now() + options.budget.resetAfter;
-      this.#period = options.budget.period ?? this.#period;
-      if (!(this.#period > 0))
-        throw new RangeError("budget.period must be positive.");
-    }
-  }
-  get remaining() {
-    return this.#remaining;
-  }
-  get waiting() {
-    let count = 0;
-    for (const key of this.#keys.values())
-      count += key.queue.length;
-    return count;
-  }
-  get holding() {
-    let count = 0;
-    for (const key of this.#keys.values())
-      if (key.holder)
-        count++;
-    return count;
-  }
-  acquire(owner, shardId) {
-    if (this.#closed)
-      return Promise.reject(new Error("IDENTIFY coordinator is closed."));
-    const index = shardId % this.maxConcurrency;
-    let key = this.#keys.get(index);
-    if (!key)
-      this.#keys.set(index, key = { queue: [], nextAt: 0 });
-    return new Promise((grant, fail) => {
-      key.queue.push({ owner, shardId, grant, fail });
-      this.pump();
-    });
-  }
-  release(owner, shardId) {
-    const key = this.#keys.get(shardId % this.maxConcurrency);
-    const holder = key?.holder;
-    if (!key || !holder || holder.owner !== owner || holder.shardId !== shardId)
-      return;
-    this.#free(key);
-    this.pump();
-  }
-  drop(owner, reason = "The cluster went away.") {
-    for (const key of this.#keys.values()) {
-      const keep = [];
-      for (const waiter of key.queue)
-        if (waiter.owner === owner)
-          waiter.fail(new Error(reason));
-        else
-          keep.push(waiter);
-      key.queue = keep;
-      if (key.holder?.owner === owner)
-        this.#free(key);
-    }
-    this.pump();
-  }
-  close() {
-    this.#closed = true;
-    if (this.#timer !== undefined)
-      this.#cancel(this.#timer);
-    this.#timer = undefined;
-    this.#timerAt = Number.POSITIVE_INFINITY;
-    for (const key of this.#keys.values()) {
-      if (key.holder)
-        this.#cancel(key.holder.timer);
-      key.holder = undefined;
-      for (const waiter of key.queue)
-        waiter.fail(new Error("IDENTIFY coordinator is closed."));
-      key.queue = [];
-    }
-  }
-  pump() {
-    if (this.#closed)
-      return;
-    const now = this.#now();
-    if (this.#total !== undefined && now >= this.#resetAt) {
-      this.#remaining = this.#total;
-      while (now >= this.#resetAt)
-        this.#resetAt += this.#period;
-    }
-    let next = Number.POSITIVE_INFINITY;
-    for (const key of this.#keys.values()) {
-      if (key.holder || key.queue.length === 0)
-        continue;
-      if (key.nextAt > now) {
-        next = Math.min(next, key.nextAt);
-        continue;
-      }
-      if (this.#remaining !== undefined && this.#remaining <= 0) {
-        const waiter = key.queue[0];
-        this.#onBudgetWait?.({
-          shardId: waiter.shardId,
-          waitMs: this.#resetAt - now
-        });
-        next = Math.min(next, this.#resetAt);
-        continue;
-      }
-      const waiter = key.queue.shift();
-      if (this.#remaining !== undefined)
-        this.#remaining--;
-      const timer = this.#schedule(() => {
-        if (key.holder?.timer === timer) {
-          this.#free(key);
-          this.pump();
-        }
-      }, this.#holdTimeout);
-      key.holder = {
-        owner: waiter.owner,
-        shardId: waiter.shardId,
-        timer
-      };
-      waiter.grant();
-    }
-    this.#arm(next);
-  }
-  #free(key) {
-    if (key.holder)
-      this.#cancel(key.holder.timer);
-    key.holder = undefined;
-    key.nextAt = this.#now() + this.#interval;
-  }
-  #arm(at) {
-    if (at === this.#timerAt && this.#timer !== undefined)
-      return;
-    if (this.#timer !== undefined)
-      this.#cancel(this.#timer);
-    this.#timer = undefined;
-    this.#timerAt = Number.POSITIVE_INFINITY;
-    if (at === Number.POSITIVE_INFINITY)
-      return;
-    this.#timerAt = at;
-    this.#timer = this.#schedule(() => {
-      this.#timer = undefined;
-      this.#timerAt = Number.POSITIVE_INFINITY;
-      this.pump();
-    }, Math.max(0, at - this.#now()));
-  }
-}
-
-// packages/sharding/src/remote.ts
-import { EventEmitter as EventEmitter2 } from "events";
-import { randomBytes } from "crypto";
-
-// packages/sharding/src/remote-protocol.ts
-import { createHmac, timingSafeEqual } from "crypto";
-var REMOTE_PROTOCOL_VERSION = 1;
-var MAX_REMOTE_FRAME_BYTES = 8 * 1024 * 1024;
-var RemoteClose = {
-  BadRequest: 4400,
-  AuthFailed: 4401,
-  HelloTimeout: 4408,
-  DuplicateHost: 4409,
-  TooManyConnections: 4429,
-  UnknownHost: 4410,
-  VersionMismatch: 4426,
-  HostLost: 4504,
-  Shutdown: 4500
-};
-var SPAWN_ENV_KEYS = new Set([
-  "SHARD_LIST",
-  "SHARD_COUNT",
-  "CLUSTER_ID",
-  "CLUSTER_COUNT",
-  "LUNIBEE_SHARD_BUS",
-  "LUNIBEE_CLUSTER_WORKER",
-  "LUNIBEE_IDENTIFY"
-]);
-var KILL_SIGNALS = new Set([
-  "SIGTERM",
-  "SIGKILL",
-  "SIGINT"
-]);
-function isLoopbackHost(hostname) {
-  return /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\]|::1)$/i.test(hostname);
-}
-var HOST_ID = /^[A-Za-z0-9._-]{1,64}$/;
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isInt = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
-function utf8Bytes(text) {
-  return Buffer.byteLength(text, "utf8");
-}
-function parseJson(text, maxBytes) {
-  if (typeof text !== "string")
-    return null;
-  if (text.length > maxBytes)
-    return null;
-  if (text.length * 3 > maxBytes && utf8Bytes(text) > maxBytes)
-    return null;
-  try {
-    const value = JSON.parse(text);
-    return isRecord2(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function signChallenge(secret, nonce, hostId) {
-  return createHmac("sha256", secret).update(`${nonce}:${hostId}`).digest("hex");
-}
-function verifyChallenge(secret, nonce, hostId, mac) {
-  if (typeof mac !== "string")
-    return false;
-  const expected = Buffer.from(signChallenge(secret, nonce, hostId), "hex");
-  const given = Buffer.from(mac, "hex");
-  return given.length === expected.length && timingSafeEqual(given, expected);
-}
-function parseToHost(text, maxBytes = MAX_REMOTE_FRAME_BYTES) {
-  const v = parseJson(text, maxBytes);
-  if (!v)
-    return null;
-  switch (v.t) {
-    case "challenge":
-      return typeof v.nonce === "string" && isInt(v.version) ? { t: "challenge", nonce: v.nonce, version: v.version } : null;
-    case "welcome":
-      return isInt(v.leaseMs) && isInt(v.pingMs) ? { t: "welcome", leaseMs: v.leaseMs, pingMs: v.pingMs } : null;
-    case "ping":
-      return isInt(v.n) ? { t: "ping", n: v.n } : null;
-    case "spawn": {
-      if (!isInt(v.cluster) || !isInt(v.epoch) || !isRecord2(v.env))
-        return null;
-      const env = {};
-      for (const [key, value] of Object.entries(v.env)) {
-        if (!SPAWN_ENV_KEYS.has(key) || typeof value !== "string")
-          return null;
-        env[key] = value;
-      }
-      return { t: "spawn", cluster: v.cluster, epoch: v.epoch, env };
-    }
-    case "frame":
-      return isInt(v.cluster) && isInt(v.epoch) ? {
-        t: "frame",
-        cluster: v.cluster,
-        epoch: v.epoch,
-        frame: v.frame
-      } : null;
-    case "kill":
-      return isInt(v.cluster) && isInt(v.epoch) && typeof v.signal === "string" && KILL_SIGNALS.has(v.signal) ? {
-        t: "kill",
-        cluster: v.cluster,
-        epoch: v.epoch,
-        signal: v.signal
-      } : null;
-    case "bye":
-      return typeof v.reason === "string" ? { t: "bye", reason: v.reason } : null;
-    default:
-      return null;
-  }
-}
-function parseToCoordinator(text, maxBytes = MAX_REMOTE_FRAME_BYTES) {
-  const v = parseJson(text, maxBytes);
-  if (!v)
-    return null;
-  switch (v.t) {
-    case "hello":
-      return typeof v.id === "string" && typeof v.mac === "string" && isInt(v.version) ? { t: "hello", id: v.id, mac: v.mac, version: v.version } : null;
-    case "pong":
-      return isInt(v.n) ? { t: "pong", n: v.n } : null;
-    case "spawned":
-      return isInt(v.cluster) && isInt(v.epoch) && (v.pid === undefined || isInt(v.pid)) ? {
-        t: "spawned",
-        cluster: v.cluster,
-        epoch: v.epoch,
-        ...v.pid !== undefined ? { pid: v.pid } : {}
-      } : null;
-    case "frame":
-      return isInt(v.cluster) && isInt(v.epoch) ? {
-        t: "frame",
-        cluster: v.cluster,
-        epoch: v.epoch,
-        frame: v.frame
-      } : null;
-    case "exit":
-      return isInt(v.cluster) && isInt(v.epoch) && (v.code === null || typeof v.code === "number") && (v.signal === null || typeof v.signal === "string") ? {
-        t: "exit",
-        cluster: v.cluster,
-        epoch: v.epoch,
-        code: v.code,
-        signal: v.signal
-      } : null;
-    case "error":
-      return isInt(v.cluster) && isInt(v.epoch) && typeof v.message === "string" ? {
-        t: "error",
-        cluster: v.cluster,
-        epoch: v.epoch,
-        message: v.message
-      } : null;
-    default:
-      return null;
-  }
-}
-
-// packages/sharding/src/remote.ts
-class RemoteChild extends EventEmitter2 {
-  host;
-  cluster;
-  epoch;
-  pid;
-  exitCode = null;
-  signalCode = null;
-  connected = true;
-  #send;
-  #kill;
-  constructor(host, cluster, epoch, send, kill) {
-    super();
-    this.host = host;
-    this.cluster = cluster;
-    this.epoch = epoch;
-    this.#send = send;
-    this.#kill = kill;
-  }
-  send(frame) {
-    return this.connected && this.exitCode === null && this.signalCode === null ? this.#send(frame) : false;
-  }
-  kill(signal = "SIGTERM") {
-    if (this.exitCode !== null || this.signalCode !== null)
-      return false;
-    return this.#kill(signal);
-  }
-  spawned(pid) {
-    this.pid = pid;
-  }
-  deliver(frame) {
-    if (this.exitCode === null && this.signalCode === null)
-      this.emit("message", frame);
-  }
-  finish(code, signal) {
-    if (this.exitCode !== null || this.signalCode !== null)
-      return;
-    this.connected = false;
-    this.exitCode = code ?? (signal === null ? 1 : null);
-    this.signalCode = signal ?? null;
-    this.emit("exit", code, signal);
-  }
-}
-
-class RemoteHosts {
-  #options;
-  #links = new Map;
-  #droppedAt = new Map;
-  #waiters = new Set;
-  #hooks;
-  #server;
-  #watchdog;
-  #epoch = 0;
-  #ping = 0;
-  #pending = new Set;
-  #pendingByAddress = new Map;
-  #rates = new Map;
-  constructor(options, hooks) {
-    if (typeof options.secret !== "string" || options.secret.length < 16)
-      throw new RangeError("remote.secret must be a string of at least 16 characters.");
-    if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535)
-      throw new RangeError("remote.port must be an integer from 0 to 65535.");
-    if (options.tls && (typeof options.tls.cert !== "string" || typeof options.tls.key !== "string" || !options.tls.cert || !options.tls.key))
-      throw new TypeError("remote.tls needs a non-empty cert and key.");
-    if (!options.tls && !options.allowInsecure && !isLoopbackHost(options.hostname ?? "127.0.0.1"))
-      throw new RangeError("remote listens on a network address without TLS: set remote.tls, bind 127.0.0.1 behind a TLS proxy, or set remote.allowInsecure for a network you fully trust.");
-    const lease = options.lease ?? 15000;
-    if (!Number.isFinite(lease) || lease < 30)
-      throw new RangeError("remote.lease must be at least 30 milliseconds.");
-    for (const id of options.hosts ?? [])
-      if (!HOST_ID.test(id))
-        throw new RangeError(`"${id}" is not a valid host ID.`);
-    if (options.hosts && (options.hosts.length === 0 || new Set(options.hosts).size !== options.hosts.length))
-      throw new RangeError("remote.hosts must be unique and not empty.");
-    if (options.minHosts !== undefined && (!Number.isInteger(options.minHosts) || options.minHosts < 1))
-      throw new RangeError("remote.minHosts must be a positive integer.");
-    this.#options = { ...options, lease };
-    this.#hooks = hooks;
-  }
-  get port() {
-    return this.#server?.port;
-  }
-  connected() {
-    return [...this.#links.keys()].sort();
-  }
-  isConnected(hostId) {
-    return this.#links.has(hostId);
-  }
-  fencedAt(hostId) {
-    const dropped = this.#droppedAt.get(hostId);
-    return dropped === undefined || this.#links.has(hostId) ? 0 : dropped + this.#options.lease * 2;
-  }
-  start() {
-    if (this.#server)
-      return;
-    const { port, hostname, tls, lease } = this.#options;
-    this.#server = Bun.serve({
-      port,
-      hostname: hostname ?? "127.0.0.1",
-      ...tls ? { tls } : {},
-      fetch: (request, server) => {
-        const peer = server.requestIP(request)?.address;
-        const address = this.#options.clientAddress?.(request, peer) ?? peer ?? "unknown";
-        if (!this.#allowConnection(address))
-          return new Response("Too many connections.", {
-            status: 429
-          });
-        if (server.upgrade(request, {
-          data: {
-            nonce: randomBytes(16).toString("hex"),
-            address
-          }
-        }))
-          return;
-        return new Response("Lunibee cluster coordinator", {
-          status: 426
-        });
-      },
-      websocket: {
-        maxPayloadLength: MAX_REMOTE_FRAME_BYTES,
-        idleTimeout: 0,
-        open: (ws) => this.#open(ws),
-        message: (ws, raw) => this.#message(ws, raw),
-        close: (ws, _code, reason) => this.#closed(ws, reason)
-      }
-    });
-    const pingMs = Math.max(10, Math.floor(lease / 3));
-    this.#watchdog = setInterval(() => this.#tick(), pingMs);
-    this.#watchdog.unref?.();
-  }
-  stop() {
-    if (this.#watchdog)
-      clearInterval(this.#watchdog);
-    this.#watchdog = undefined;
-    for (const link of [...this.#links.values()]) {
-      this.#post(link, { t: "bye", reason: "The coordinator stopped." });
-      this.#drop(link, "The coordinator stopped.", RemoteClose.Shutdown);
-    }
-    this.#server?.stop(true);
-    this.#server = undefined;
-    this.abortWaits();
-  }
-  waitFor(hosts, count, timeoutMs) {
-    const done = () => hosts ? hosts.every((id) => this.#links.has(id)) : this.#links.size >= count;
-    if (done())
-      return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        check: () => {
-          if (!done())
-            return;
-          clearTimeout(timer);
-          this.#waiters.delete(waiter);
-          resolve();
-        },
-        abort: (error) => {
-          clearTimeout(timer);
-          this.#waiters.delete(waiter);
-          reject(error);
-        }
-      };
-      const timer = setTimeout(() => {
-        const missing = hosts?.filter((id) => !this.#links.has(id));
-        waiter.abort(new Error(hosts ? `Hosts did not join within ${timeoutMs}ms: [${missing}].` : `Only ${this.#links.size} of ${count} hosts joined within ${timeoutMs}ms.`));
-      }, timeoutMs);
-      this.#waiters.add(waiter);
-    });
-  }
-  abortWaits() {
-    for (const waiter of [...this.#waiters])
-      waiter.abort(new Error("The coordinator stopped."));
-  }
-  status(declared = []) {
-    const ids = new Set([...declared, ...this.#links.keys()]);
-    return [...ids].sort().map((id) => {
-      const link = this.#links.get(id);
-      return {
-        id,
-        connected: link !== undefined,
-        lastSeen: link?.lastSeen ?? 0,
-        clusters: link ? [...link.children.keys()].sort((a, b) => a - b) : []
-      };
-    });
-  }
-  createChild(hostId, cluster, env) {
-    const epoch = ++this.#epoch;
-    const link = this.#links.get(hostId);
-    const child = new RemoteChild(hostId, cluster, epoch, (frame) => link !== undefined && this.#post(link, { t: "frame", cluster, epoch, frame }), (signal) => link !== undefined && this.#post(link, { t: "kill", cluster, epoch, signal }));
-    if (!link) {
-      queueMicrotask(() => child.finish(null, "SIGHUP"));
-      return child;
-    }
-    link.children.get(cluster)?.finish(null, "SIGKILL");
-    link.children.set(cluster, child);
-    if (!this.#post(link, { t: "spawn", cluster, epoch, env }))
-      queueMicrotask(() => child.finish(null, "SIGHUP"));
-    return child;
-  }
-  #post(link, message) {
-    try {
-      return link.ws.send(JSON.stringify(message)) > 0;
-    } catch {
-      return false;
-    }
-  }
-  #allowConnection(address) {
-    const rate = this.#options.connectionsPerSecond ?? 10;
-    const now = Date.now();
-    let bucket = this.#rates.get(address);
-    if (!bucket) {
-      bucket = { tokens: rate, at: now };
-      this.#rates.set(address, bucket);
-      if (this.#rates.size > 1e4)
-        this.#rates.delete(this.#rates.keys().next().value);
-    }
-    bucket.tokens = Math.min(rate, bucket.tokens + (now - bucket.at) / 1000 * rate);
-    bucket.at = now;
-    if (bucket.tokens < 1)
-      return false;
-    bucket.tokens--;
-    return true;
-  }
-  #evict(victim) {
-    this.#uncount(victim);
-    clearTimeout(victim.data.helloTimer);
-    victim.close(RemoteClose.TooManyConnections, "Too many connections.");
-  }
-  #open(ws) {
-    const address = ws.data.address;
-    if ((this.#pendingByAddress.get(address) ?? 0) >= (this.#options.maxUnauthenticatedPerAddress ?? 4)) {
-      for (const other of this.#pending)
-        if (other.data.address === address) {
-          this.#evict(other);
-          break;
-        }
-    }
-    if (this.#pending.size >= (this.#options.maxUnauthenticated ?? 16)) {
-      const oldest = this.#pending.values().next().value;
-      if (oldest)
-        this.#evict(oldest);
-    }
-    this.#pending.add(ws);
-    this.#pendingByAddress.set(address, (this.#pendingByAddress.get(address) ?? 0) + 1);
-    ws.data.counted = true;
-    ws.data.helloTimer = setTimeout(() => ws.close(RemoteClose.HelloTimeout, "No hello."), this.#options.helloTimeout ?? 3000);
-    ws.send(JSON.stringify({
-      t: "challenge",
-      nonce: ws.data.nonce,
-      version: REMOTE_PROTOCOL_VERSION
-    }));
-  }
-  #message(ws, raw) {
-    if (typeof raw !== "string") {
-      ws.close(RemoteClose.BadRequest, "Text frames only.");
-      return;
-    }
-    const message = parseToCoordinator(raw);
-    if (!message) {
-      ws.close(RemoteClose.BadRequest, "Malformed frame.");
-      return;
-    }
-    if (ws.data.id === undefined) {
-      this.#hello(ws, message);
-      return;
-    }
-    const link = this.#links.get(ws.data.id);
-    if (!link || link.ws !== ws)
-      return;
-    link.lastSeen = Date.now();
-    if (message.t === "pong" || message.t === "hello")
-      return;
-    const child = link.children.get(message.cluster);
-    if (!child || child.epoch !== message.epoch)
-      return;
-    switch (message.t) {
-      case "spawned":
-        child.spawned(message.pid);
-        break;
-      case "frame":
-        child.deliver(message.frame);
-        break;
-      case "exit":
-        link.children.delete(message.cluster);
-        child.finish(message.code, message.signal);
-        break;
-      case "error":
-        this.#hooks.error(new Error(`Host ${link.id} could not run cluster ${message.cluster}: ${message.message}`));
-        link.children.delete(message.cluster);
-        child.finish(1, null);
-        break;
-    }
-  }
-  #hello(ws, message) {
-    if (message?.t !== "hello") {
-      ws.close(RemoteClose.BadRequest, "Expected hello.");
-      return;
-    }
-    const { id } = message;
-    if (message.version !== REMOTE_PROTOCOL_VERSION) {
-      ws.close(RemoteClose.VersionMismatch, "Protocol version mismatch.");
-      return;
-    }
-    if (!HOST_ID.test(id) || !verifyChallenge(this.#options.secret, ws.data.nonce, id, message.mac)) {
-      ws.close(RemoteClose.AuthFailed, "Authentication failed.");
-      return;
-    }
-    if (this.#options.hosts && !this.#options.hosts.includes(id)) {
-      ws.close(RemoteClose.UnknownHost, "Host is not part of this deployment.");
-      return;
-    }
-    if (this.#links.has(id)) {
-      ws.close(RemoteClose.DuplicateHost, "A host with this ID is connected.");
-      return;
-    }
-    clearTimeout(ws.data.helloTimer);
-    this.#uncount(ws);
-    ws.data.id = id;
-    const link = {
-      id,
-      ws,
-      lastSeen: Date.now(),
-      children: new Map
-    };
-    this.#links.set(id, link);
-    this.#droppedAt.delete(id);
-    const lease = this.#options.lease;
-    this.#post(link, {
-      t: "welcome",
-      leaseMs: lease,
-      pingMs: Math.max(10, Math.floor(lease / 3))
-    });
-    this.#hooks.join(id);
-    for (const waiter of [...this.#waiters])
-      waiter.check();
-  }
-  #uncount(ws) {
-    if (!ws.data.counted)
-      return;
-    ws.data.counted = false;
-    this.#pending.delete(ws);
-    const left = (this.#pendingByAddress.get(ws.data.address) ?? 1) - 1;
-    if (left > 0)
-      this.#pendingByAddress.set(ws.data.address, left);
-    else
-      this.#pendingByAddress.delete(ws.data.address);
-  }
-  #closed(ws, reason) {
-    clearTimeout(ws.data.helloTimer);
-    this.#uncount(ws);
-    const link = ws.data.id ? this.#links.get(ws.data.id) : undefined;
-    if (link && link.ws === ws)
-      this.#drop(link, reason || "The connection closed.");
-  }
-  #drop(link, reason, code) {
-    if (this.#links.get(link.id) !== link)
-      return;
-    this.#links.delete(link.id);
-    this.#droppedAt.set(link.id, Date.now());
-    if (this.#droppedAt.size > 1000)
-      this.#droppedAt.delete(this.#droppedAt.keys().next().value);
-    if (code !== undefined)
-      try {
-        link.ws.close(code, reason.slice(0, 100));
-      } catch {}
-    for (const child of [...link.children.values()])
-      child.finish(null, "SIGHUP");
-    link.children.clear();
-    this.#hooks.leave(link.id, reason);
-  }
-  #tick() {
-    const now = Date.now();
-    for (const link of [...this.#links.values()]) {
-      if (now - link.lastSeen > this.#options.lease * 2) {
-        this.#drop(link, "The host stopped answering.", RemoteClose.HostLost);
-        continue;
-      }
-      this.#post(link, { t: "ping", n: ++this.#ping });
-    }
-  }
-}
-
-// packages/sharding/src/requests.ts
-class RequestTracker {
-  #pending = new Map;
-  #maxPending;
-  #prefix;
-  #counter = 0;
-  constructor(prefix = "parent", maxPending = 1e4) {
-    if (!Number.isInteger(maxPending) || maxPending < 1)
-      throw new RangeError("maxPending must be a positive integer.");
-    this.#prefix = prefix;
-    this.#maxPending = maxPending;
-  }
-  get size() {
-    return this.#pending.size;
-  }
-  begin(options) {
-    if (this.#pending.size >= this.#maxPending)
-      throw new Error(`Too many requests waiting for a reply (${this.#maxPending}).`);
-    const id = `${this.#prefix}:${++this.#counter}`;
-    const done = new Promise((resolve) => {
-      const finish = () => {
-        const entry = this.#pending.get(id);
-        if (!entry)
-          return;
-        this.#pending.delete(id);
-        clearTimeout(entry.timer);
-        entry.cleanup?.();
-        resolve({
-          replies: entry.replies,
-          missing: [...entry.keys.keys()].filter((key) => !entry.answered.has(key))
-        });
-      };
-      const entry = {
-        keys: new Map(options.keys),
-        replies: [],
-        answered: new Set,
-        finish,
-        timer: setTimeout(finish, options.timeoutMs)
-      };
-      if (options.signal) {
-        const signal = options.signal;
-        if (signal.aborted)
-          queueMicrotask(finish);
-        else {
-          signal.addEventListener("abort", finish, { once: true });
-          entry.cleanup = () => signal.removeEventListener("abort", finish);
-        }
-      }
-      this.#pending.set(id, entry);
-      if (entry.keys.size === 0)
-        queueMicrotask(finish);
-    });
-    return { id, done };
-  }
-  answer(id, key, from, value) {
-    const entry = this.#pending.get(id);
-    if (!entry || entry.keys.get(key) !== from)
-      return false;
-    if (entry.answered.has(key))
-      return false;
-    entry.answered.add(key);
-    entry.replies.push({ key, ...value });
-    if (entry.replies.length >= entry.keys.size)
-      entry.finish();
-    return true;
-  }
-  failOwner(owner, error) {
-    for (const entry of [...this.#pending.values()]) {
-      for (const [key, keyOwner] of entry.keys)
-        if (keyOwner === owner && !entry.answered.has(key)) {
-          entry.answered.add(key);
-          entry.replies.push({ key, error });
-        }
-      if (entry.replies.length >= entry.keys.size)
-        entry.finish();
-    }
-  }
-  close() {
-    for (const entry of [...this.#pending.values()])
-      entry.finish();
-  }
-}
-
-// packages/sharding/src/cluster.ts
-var DEFAULT_MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
-function payloadSize(value) {
-  if (value === undefined || value === null)
-    return 0;
-  if (typeof value === "string")
-    return Buffer.byteLength(value, "utf8");
-  if (typeof value !== "object")
-    return String(value).length;
-  try {
-    const text = JSON.stringify(value);
-    return text === undefined ? 0 : Buffer.byteLength(text, "utf8");
-  } catch {
-    return Number.POSITIVE_INFINITY;
-  }
-}
-var isLive = (state) => state === "starting" || state === "ready";
-
-class ClusterManager {
-  clusters = new Map;
-  shardCount = 0;
-  #options;
-  #auto;
-  #autoScaleTimer;
-  #infos = new Map;
-  #owner = new Map;
-  #startPromise;
-  #stopPromise;
-  #wasStarted = false;
-  #stopping = false;
-  #generation = 0;
-  #leading = false;
-  #renewTimer;
-  #lastRenew = 0;
-  #renewing = false;
-  #restartTimers = new Set;
-  #fencing = new Map;
-  #startTimers = new Map;
-  #pauses = new Set;
-  #readyWaiters = new Set;
-  #supervisor;
-  #tracker;
-  #coordinator;
-  #allReady = false;
-  #clusterCount = 0;
-  #identifyWaiting = new Map;
-  #remote;
-  #hostOf = new Map;
-  #lastWait = "";
-  #listeners = new Map;
-  constructor(options) {
-    if (!options.token?.trim())
-      throw new TypeError("A Discord bot token is required.");
-    if (!options.script?.trim())
-      throw new TypeError("A script path is required for clustering.");
-    if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000)) {
-      throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
-    }
-    if (options.clusterCount !== undefined && options.shardsPerCluster !== undefined)
-      throw new RangeError("Set either clusterCount or shardsPerCluster, not both.");
-    for (const [name, value] of [
-      ["clusterCount", options.clusterCount],
-      ["shardsPerCluster", options.shardsPerCluster],
-      ["maxConcurrency", options.maxConcurrency]
-    ])
-      if (value !== undefined && (!Number.isInteger(value) || value < 1))
-        throw new RangeError(`${name} must be a positive integer.`);
-    if (options.maxMessageBytes !== undefined && (!Number.isInteger(options.maxMessageBytes) || options.maxMessageBytes < 1))
-      throw new RangeError("maxMessageBytes must be a positive integer.");
-    for (const [name, value] of [
-      ["spawnInterval", options.spawnInterval],
-      ["startTimeout", options.startTimeout],
-      ["requestTimeout", options.requestTimeout]
-    ])
-      if (value !== undefined && !(value >= 0))
-        throw new RangeError(`${name} cannot be negative.`);
-    if (options.guildsPerShard !== undefined) {
-      assertGuildsPerShard(options.guildsPerShard);
-      if (typeof options.shardCount === "number")
-        throw new RangeError('guildsPerShard needs shardCount: "auto".');
-    }
-    if (options.shardIds && typeof options.shardCount === "number")
-      validateShardIds(options.shardIds, options.shardCount);
-    this.#auto = options.shardCount === "auto";
-    const ttl = options.leader?.ttl;
-    if (options.leader && (typeof options.leader.lock?.acquire !== "function" || typeof options.leader.lock.release !== "function"))
-      throw new TypeError("leader.lock must have acquire() and release().");
-    if (ttl !== undefined && (!Number.isInteger(ttl) || ttl < 100))
-      throw new RangeError("leader.ttl must be an integer of at least 100.");
-    this.#options = { ...options };
-    this.#supervisor = new ShardSupervisor({
-      restartDelay: options.restartDelay,
-      ...options.supervisor
-    });
-    this.#tracker = new RequestTracker("parent", options.maxPendingRequests);
-    if (options.remote)
-      this.#remote = new RemoteHosts(options.remote, {
-        join: (id) => this.#hostJoined(id),
-        leave: (id, reason) => this.#emit("hostLeave", id, reason),
-        error: (error) => this.#emit("error", error)
-      });
-  }
-  on(event, listener) {
-    let set = this.#listeners.get(event);
-    if (!set)
-      this.#listeners.set(event, set = new Set);
-    set.add(listener);
-    return this;
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-    return this;
-  }
-  #emit(event, ...args) {
-    for (const listener of this.#listeners.get(event) ?? [])
-      try {
-        listener(...args);
-      } catch {}
-  }
-  async fetchRecommendedShardCount() {
-    return resolveShardCount(this.#options.token, await fetchGatewayBot(this.#options.token), this.#options);
-  }
-  clusterForShard(shardId) {
-    const id = this.#owner.get(shardId);
-    return id === undefined ? undefined : this.#infos.get(id);
-  }
-  assignments() {
-    return new Map(this.#owner);
-  }
-  spawn() {
-    if (isClusterWorker())
-      return Promise.reject(new Error("A cluster worker cannot start a ClusterManager: it would fork the whole fleet again."));
-    if (this.#stopPromise)
-      return this.#stopPromise.then(() => this.spawn());
-    if (!this.#startPromise) {
-      const attempt = this.#start();
-      this.#startPromise = attempt;
-      attempt.catch(() => {
-        if (this.#startPromise === attempt)
-          this.#startPromise = undefined;
-      });
-    }
-    return this.#startPromise;
-  }
-  async#resolveGateway() {
-    const { shardCount, maxConcurrency, fetchLimits } = this.#options;
-    let info;
-    let count;
-    if (shardCount === "auto" || shardCount === undefined) {
-      info = await fetchGatewayBot(this.#options.token);
-      count = await resolveShardCount(this.#options.token, info, this.#options);
-    } else if (fetchLimits)
-      try {
-        info = await fetchGatewayBot(this.#options.token);
-      } catch (error) {
-        this.#emit("error", error instanceof Error ? error : new Error(String(error)));
-      }
-    const limit = info?.sessionStartLimit;
-    return {
-      count: count ?? shardCount,
-      maxConcurrency: Math.min(maxConcurrency ?? limit?.maxConcurrency ?? 1, limit?.maxConcurrency ?? Number.POSITIVE_INFINITY),
-      ...limit ? {
-        budget: {
-          total: limit.total,
-          remaining: limit.remaining,
-          resetAfter: limit.resetAfter
-        }
-      } : {}
-    };
-  }
-  async#start() {
-    const generation = this.#generation;
-    const stale = () => this.#stopping || generation !== this.#generation;
-    if (this.#options.leader && !this.#leading) {
-      await this.#lead();
-      if (stale())
-        return;
-    }
-    const { count, maxConcurrency, budget } = await this.#resolveGateway();
-    if (stale())
-      return;
-    const ids = this.#options.shardIds ?? Array.from({ length: count }, (_, i) => i);
-    validateShardIds(ids, count);
-    const clusterCount = this.#options.clusterCount ?? (this.#options.shardsPerCluster ? Math.ceil(ids.length / this.#options.shardsPerCluster) : cpus().length);
-    const chunks = allocateShards(ids, clusterCount);
-    assertCompleteAllocation(chunks, ids);
-    const placement = await this.#placeHosts().catch((error) => {
-      if (stale())
-        return;
-      throw error;
-    });
-    if (!placement || stale())
-      return;
-    this.shardCount = count;
-    this.#wasStarted = true;
-    this.#owner.clear();
-    this.#infos.clear();
-    const identify = this.#options.identify;
-    this.#coordinator = identify?.coordinate === false ? undefined : new IdentifyCoordinator({
-      maxConcurrency,
-      interval: identify?.interval,
-      holdTimeout: identify?.holdTimeout,
-      budget,
-      onBudgetWait: (wait) => {
-        const key = `${wait.shardId}:${Math.round(wait.waitMs / 1000)}`;
-        if (key === this.#lastWait)
-          return;
-        this.#lastWait = key;
-        this.#emit("identifyWait", wait);
-      }
-    });
-    const active = chunks.map((shards, id) => ({ id, shards })).filter((chunk) => chunk.shards.length > 0);
-    this.#clusterCount = active.length;
-    this.#hostOf.clear();
-    for (const chunk of active)
-      this.#hostOf.set(chunk.id, placement[chunk.id % placement.length]);
-    for (const [index, chunk] of active.entries()) {
-      if (stale())
-        return;
-      for (const shard of chunk.shards)
-        this.#owner.set(shard, chunk.id);
-      this.#launch(chunk.id, chunk.shards);
-      const gap = this.#options.spawnInterval ?? 500;
-      if (index < active.length - 1 && gap > 0)
-        await this.#pause(gap);
-    }
-    if (stale())
-      return;
-    if (this.#options.waitForReady)
-      await this.ready();
-    if (this.#options.autoScaleInterval && this.#options.autoScaleInterval > 0) {
-      this.#autoScaleTimer = setInterval(() => {
-        this.checkAutoScale();
-      }, this.#options.autoScaleInterval);
-    }
-  }
-  get isLeader() {
-    return !this.#options.leader || this.#leading;
-  }
-  async#lead() {
-    const { lock, ttl = 1e4 } = this.#options.leader;
-    const generation = this.#generation;
-    while (!this.#stopping && generation === this.#generation) {
-      const started = Date.now();
-      let held = false;
-      try {
-        held = await withTimeout(lock.acquire(ttl), ttl / 2);
-      } catch (error) {
-        this.#emit("error", asError(error));
-      }
-      if (this.#stopping || generation !== this.#generation) {
-        if (held)
-          lock.release().catch(() => {
-            return;
-          });
-        return;
-      }
-      if (held) {
-        this.#leading = true;
-        this.#lastRenew = started;
-        this.#startRenewing(ttl);
-        this.#emit("leaderAcquired");
-        const lease = this.#options.remote ? this.#options.remote.lease ?? 15000 : 0;
-        if (lease > 0)
-          await this.#pause(lease * 2);
-        return;
-      }
-      await this.#pause(Math.floor(ttl / 2));
-    }
-  }
-  #startRenewing(ttl) {
-    this.#stopRenewing();
-    const lock = this.#options.leader.lock;
-    this.#renewTimer = setInterval(() => {
-      if (Date.now() - this.#lastRenew > ttl / 2) {
-        this.#standDown("The leader lock could not be renewed.");
-        return;
-      }
-      if (this.#renewing)
-        return;
-      this.#renewing = true;
-      const started = Date.now();
-      lock.acquire(ttl).then((held) => {
-        this.#renewing = false;
-        if (!this.#leading)
-          return;
-        if (held)
-          this.#lastRenew = started;
-        else
-          this.#standDown("Another coordinator holds the leader lock.");
-      }, (error) => {
-        this.#renewing = false;
-        this.#emit("error", asError(error));
-      });
-    }, Math.max(10, Math.floor(ttl / 4)));
-    this.#renewTimer.unref?.();
-  }
-  #stopRenewing() {
-    if (this.#renewTimer)
-      clearInterval(this.#renewTimer);
-    this.#renewTimer = undefined;
-  }
-  async#resign() {
-    this.#stopRenewing();
-    if (!this.#leading)
-      return;
-    this.#leading = false;
-    const { lock, ttl = 1e4 } = this.#options.leader;
-    try {
-      await withTimeout(lock.release(), ttl / 2);
-    } catch (error) {
-      this.#emit("error", asError(error));
-    }
-  }
-  #standDown(reason) {
-    if (!this.#leading)
-      return;
-    this.#stopRenewing();
-    this.#leading = false;
-    this.#stopping = true;
-    this.#halt();
-    for (const cluster of this.#infos.values()) {
-      cluster.state = "stopped";
-      try {
-        cluster.process.kill("SIGKILL");
-      } catch {}
-    }
-    this.clusters.clear();
-    this.#startPromise = undefined;
-    this.#remote?.stop();
-    this.#stopping = false;
-    this.#emit("leaderLost", reason);
-    this.spawn().catch((error) => this.#emit("error", asError(error)));
-  }
-  async#placeHosts() {
-    const remote = this.#remote;
-    const options = this.#options.remote;
-    if (!remote || !options)
-      return ["local"];
-    remote.start();
-    try {
-      await remote.waitFor(options.hosts, options.minHosts ?? 1, options.joinTimeout ?? 60000);
-    } catch (error) {
-      remote.stop();
-      throw error;
-    }
-    const ids = options.hosts ?? remote.connected();
-    return options.local ? ["local", ...ids] : ids;
-  }
-  get remotePort() {
-    return this.#remote?.port;
-  }
-  hosts() {
-    return this.#remote?.status(this.#options.remote?.hosts) ?? [];
-  }
-  #pause(ms) {
-    return new Promise((resolve) => {
-      const wake = () => {
-        clearTimeout(timer);
-        this.#pauses.delete(wake);
-        resolve();
-      };
-      const timer = setTimeout(wake, ms);
-      this.#pauses.add(wake);
-    });
-  }
-  #launch(id, shards) {
-    const contract = {
-      SHARD_LIST: shards.join(","),
-      SHARD_COUNT: this.shardCount.toString(),
-      CLUSTER_ID: id.toString(),
-      CLUSTER_COUNT: this.#clusterCount.toString(),
-      LUNIBEE_SHARD_BUS: "ipc",
-      [WORKER_MARKER]: "1",
-      LUNIBEE_IDENTIFY: this.#coordinator ? "coordinated" : "local"
-    };
-    const host = this.#hostOf.get(id) ?? "local";
-    const env = {
-      ...process.env,
-      ...contract
-    };
-    const child = host !== "local" && this.#remote ? this.#remote.createChild(host, id, contract) : this.#options.fork ? this.#options.fork(this.#options.script, env) : fork(this.#options.script, [], {
-      env
-    });
-    const known = this.#infos.get(id);
-    const info = known ?? {
-      id,
-      host,
-      process: child,
-      shards,
-      state: "starting",
-      restarts: 0,
-      startedAt: Date.now()
-    };
-    info.process = child;
-    info.state = "starting";
-    info.startedAt = Date.now();
-    info.readyAt = undefined;
-    this.#infos.set(id, info);
-    this.clusters.set(id, info);
-    this.#allReady = false;
-    child.on("error", (error) => this.#emit("error", new Error(`Cluster ${id} process error: ${error.message}`, {
-      cause: error
-    })));
-    child.on("message", (frame) => this.#onFrame(info, child, frame));
-    child.once("exit", (code, signal) => this.#onExit(info, child, code, signal));
-    const timeout = this.#options.startTimeout;
-    if (timeout) {
-      const timer = setTimeout(() => {
-        this.#startTimers.delete(id);
-        if (info.process !== child || info.state !== "starting")
-          return;
-        this.#emit("clusterStartTimeout", info);
-        try {
-          child.kill("SIGKILL");
-        } catch {}
-      }, timeout);
-      timer.unref?.();
-      this.#startTimers.set(id, timer);
-    }
-    this.#emit("clusterSpawn", info);
-    return info;
-  }
-  #onExit(info, child, code, signal) {
-    if (info.process !== child)
-      return;
-    child.removeAllListeners("message");
-    this.#clearStartTimer(info.id);
-    this.#coordinator?.drop(info.id, `Cluster ${info.id} exited.`);
-    this.#identifyWaiting.delete(info.id);
-    this.#tracker.failOwner(info.id, `Cluster ${info.id} exited.`);
-    this.clusters.delete(info.id);
-    this.#allReady = false;
-    try {
-      this.#options.onClusterExit?.(info, code, signal);
-    } catch {}
-    const expected = this.#stopping || info.state === "stopping" || info.state === "stopped";
-    this.#emit("clusterExit", info, code, signal, expected);
-    if (expected) {
-      info.state = "stopped";
-      return;
-    }
-    this.#announceDown(info.id, info.shards);
-    if (this.#options.restartOnExit === false) {
-      info.state = "failed";
-      this.#rejectReady(info, "restartOnExit is false");
-      return;
-    }
-    const delay = this.#supervisor.next(info.id);
-    if (delay === null) {
-      info.state = "failed";
-      try {
-        this.#options.onGiveUp?.(info);
-      } catch {}
-      this.#emit("clusterGiveUp", info);
-      if (this.#options.reassignOnGiveUp)
-        this.#reassign(info);
-      else
-        this.#rejectReady(info, "restarts exhausted");
-      return;
-    }
-    info.state = "restarting";
-    info.restarts++;
-    this.#emit("clusterRestart", info, { delay, attempt: info.restarts });
-    if (info.restarts >= 3)
-      this.#emit("clusterUnstable", info, {
-        attempt: info.restarts,
-        delay
-      });
-    this.#restartLater(info, delay);
-  }
-  #restartLater(info, delay) {
-    const timer = setTimeout(() => {
-      this.#restartTimers.delete(timer);
-      this.#fencing.delete(info.id);
-      if (this.#stopping || info.state !== "restarting")
-        return;
-      const wait = this.#relocate(info);
-      if (wait > 0)
-        this.#fencing.set(info.id, this.#restartLater(info, wait));
-      else
-        this.#launch(info.id, info.shards);
-    }, delay);
-    timer.unref?.();
-    this.#restartTimers.add(timer);
-    return timer;
-  }
-  #hostJoined(hostId) {
-    this.#emit("hostJoin", hostId);
-    for (const [id, timer] of [...this.#fencing]) {
-      const info = this.#infos.get(id);
-      if (this.#hostOf.get(id) !== hostId || !info)
-        continue;
-      clearTimeout(timer);
-      this.#restartTimers.delete(timer);
-      this.#fencing.delete(id);
-      if (!this.#stopping && info.state === "restarting")
-        this.#launch(info.id, info.shards);
-    }
-  }
-  #relocate(info) {
-    const remote = this.#remote;
-    const host = this.#hostOf.get(info.id) ?? "local";
-    if (!remote || this.#options.remote?.moveClusters === false || host === "local" || remote.isConnected(host))
-      return 0;
-    const wait = remote.fencedAt(host) - Date.now();
-    if (wait > 0)
-      return wait;
-    const places = this.#options.remote?.local ? ["local", ...remote.connected()] : remote.connected();
-    if (places.length === 0)
-      return 0;
-    const load = new Map(places.map((place) => [place, 0]));
-    for (const [cluster, place] of this.#hostOf) {
-      const state = this.#infos.get(cluster)?.state;
-      if (load.has(place) && state !== "failed" && state !== "stopped")
-        load.set(place, load.get(place) + 1);
-    }
-    const target = places.reduce((best, place) => load.get(place) < load.get(best) ? place : best);
-    this.#hostOf.set(info.id, target);
-    info.host = target;
-    this.#emit("clusterMoved", info, { from: host, to: target });
-    return 0;
-  }
-  async#reassign(failed) {
-    const shardIds = [...failed.shards];
-    const target = [...this.#infos.values()].filter((cluster) => cluster.state === "ready").sort((a, b) => a.shards.length - b.shards.length)[0];
-    if (!target) {
-      this.#emit("error", new Error(`No ready cluster can take over shards [${shardIds}] of cluster ${failed.id}.`));
-      this.#rejectReady(failed, "no ready cluster to take them");
-      return;
-    }
-    try {
-      await this.requestCluster(target.id, REQUEST_ASSIGN, { shardIds }, { timeoutMs: this.#options.startTimeout ?? 120000 });
-    } catch (error) {
-      this.#emit("error", new Error(`Cluster ${target.id} could not take over shards [${shardIds}]: ${error instanceof Error ? error.message : String(error)}`));
-      this.#rejectReady(failed, "reassignment failed");
-      return;
-    }
-    if (this.#stopping || failed.state !== "failed")
-      return;
-    for (const shard of shardIds)
-      this.#owner.set(shard, target.id);
-    target.shards.push(...shardIds);
-    failed.shards = [];
-    this.#emit("shardsReassigned", {
-      shardIds,
-      from: failed.id,
-      to: target.id
-    });
-    this.#checkReady();
-  }
-  #clearStartTimer(id) {
-    const timer = this.#startTimers.get(id);
-    if (timer)
-      clearTimeout(timer);
-    this.#startTimers.delete(id);
-  }
-  #sendFrame(cluster, frame) {
-    const child = cluster.process;
-    if (!isLive(cluster.state) || typeof child.send !== "function" || !child.connected)
-      return false;
-    try {
-      child.send(frame);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  #announceDown(exited, shards) {
-    for (const [id, cluster] of this.clusters)
-      if (id !== exited)
-        this.#sendFrame(cluster, { [PEER_DOWN_FRAME]: shards });
-  }
-  #onFrame(info, child, frame) {
-    if (info.process !== child)
-      return;
-    if (!frame || typeof frame !== "object")
-      return;
-    if (BUS_FRAME in frame) {
-      this.#onBus(info, frame[BUS_FRAME]);
-      return;
-    }
-    if (CLUSTER_FRAME in frame) {
-      const body = parseChildFrame(frame[CLUSTER_FRAME]);
-      if (body)
-        this.#onControl(info, child, body);
-      else
-        this.#emit("error", new Error(`Cluster ${info.id} sent a malformed control frame.`));
-    }
-  }
-  #onControl(info, child, frame) {
-    switch (frame.kind) {
-      case "ready": {
-        if (!frame.shardIds.every((id) => info.shards.includes(id))) {
-          this.#emit("error", new Error(`Cluster ${info.id} reported shards it does not own: [${frame.shardIds}].`));
-          return;
-        }
-        this.#clearStartTimer(info.id);
-        info.state = "ready";
-        info.readyAt = info.lastReadyAt = Date.now();
-        this.#emit("clusterReady", info);
-        this.#checkReady();
-        return;
-      }
-      case "identify": {
-        const reply = (body) => {
-          if (info.process === child)
-            this.#sendFrame(info, { [CLUSTER_FRAME]: body });
-        };
-        if (!this.#coordinator) {
-          reply({
-            kind: "identify-deny",
-            id: frame.id,
-            error: "IDENTIFY coordination is off."
-          });
-          return;
-        }
-        if (!info.shards.includes(frame.shardId)) {
-          reply({
-            kind: "identify-deny",
-            id: frame.id,
-            error: `Shard ${frame.shardId} does not belong to cluster ${info.id}.`
-          });
-          return;
-        }
-        let waiting = this.#identifyWaiting.get(info.id);
-        if (!waiting)
-          this.#identifyWaiting.set(info.id, waiting = new Set);
-        if (waiting.has(frame.shardId)) {
-          reply({
-            kind: "identify-deny",
-            id: frame.id,
-            error: `Shard ${frame.shardId} is already waiting for a slot.`
-          });
-          return;
-        }
-        waiting.add(frame.shardId);
-        const settled = () => {
-          waiting.delete(frame.shardId);
-        };
-        this.#coordinator.acquire(info.id, frame.shardId).then(() => {
-          settled();
-          reply({ kind: "identify-grant", id: frame.id });
-        }, (error) => {
-          settled();
-          reply({
-            kind: "identify-deny",
-            id: frame.id,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        });
-        return;
-      }
-      case "identify-done":
-        this.#coordinator?.release(info.id, frame.shardId);
-        return;
-      case "reply": {
-        const tooBig = frame.error === undefined && this.#tooBig(frame.result);
-        this.#tracker.answer(frame.id, `c:${info.id}`, info.id, {
-          ...frame.error !== undefined ? { error: frame.error } : tooBig ? {
-            error: `Cluster ${info.id} answered with more than ${this.#maxBytes} bytes.`
-          } : { result: frame.result }
-        });
-        return;
-      }
-      case "health":
-        if (this.#tooBig(frame.report)) {
-          this.#emit("error", new Error(`Cluster ${info.id} sent a health report of more than ${this.#maxBytes} bytes.`));
-          return;
-        }
-        info.report = frame.report;
-        return;
-    }
-  }
-  get #maxBytes() {
-    return this.#options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
-  }
-  #tooBig(value) {
-    return payloadSize(value) > this.#maxBytes;
-  }
-  #assertSize(data, what) {
-    if (this.#tooBig(data))
-      throw new RangeError(`${what} is larger than maxMessageBytes (${this.#maxBytes}).`);
-  }
-  #onBus(from, raw) {
-    let message = raw;
-    if (!message || typeof message !== "object" || typeof message.type !== "string" || message.type.length === 0 || message.type.length > 256 || message.id === undefined || typeof message.id !== "string" || message.id.length > 256 || !Number.isInteger(message.source) || message.target !== null && !Number.isInteger(message.target))
-      return;
-    if (!from.shards.includes(message.source))
-      return;
-    const { type, id, source, target, data, expectsReply } = message;
-    message = {
-      type,
-      id,
-      source,
-      target,
-      data,
-      ...expectsReply === undefined ? {} : { expectsReply }
-    };
-    if (this.#tooBig(message.data)) {
-      this.#emit("error", new Error(`Cluster ${from.id} sent a shard-bus message of more than ${this.#maxBytes} bytes; it was not relayed.`));
-      return;
-    }
-    const frame = { [BUS_FRAME]: message };
-    if (message.target === PARENT_ID) {
-      const reply = message.data;
-      if (message.type === REPLY_TYPE && reply && typeof reply.requestId === "string")
-        this.#tracker.answer(reply.requestId, `s:${message.source}`, from.id, reply.error !== undefined ? { error: String(reply.error) } : { result: reply.result });
-      return;
-    }
-    if (message.target === null) {
-      for (const [id, cluster] of this.clusters)
-        if (id !== from.id)
-          this.#sendFrame(cluster, frame);
-      return;
-    }
-    const owner = this.clusterForShard(message.target);
-    if (!owner || owner.id === from.id)
-      return;
-    if (!this.#sendFrame(owner, frame))
-      this.#sendFrame(from, {
-        [PEER_DOWN_FRAME]: [message.target]
-      });
-  }
-  async request(shardId, type, data, options = {}) {
-    this.#assertSize(data, "The request data");
-    const owner = this.clusterForShard(shardId);
-    if (!owner)
-      throw new RangeError(`Shard ${shardId} is not part of this deployment.`);
-    const { id, done } = this.#tracker.begin({
-      keys: new Map([[`s:${shardId}`, owner.id]]),
-      timeoutMs: options.timeoutMs ?? this.#options.requestTimeout ?? 5000,
-      signal: options.signal
-    });
-    const sent = this.#sendFrame(owner, {
-      [BUS_FRAME]: {
-        source: PARENT_ID,
-        target: shardId,
-        type,
-        data,
-        id,
-        expectsReply: true
-      }
-    });
-    if (!sent) {
-      this.#tracker.failOwner(owner.id, `Shard ${shardId} is down: cluster ${owner.id} is ${owner.state}.`);
-    }
-    const { replies } = await done;
-    const reply = replies[0];
-    if (!reply)
-      throw new Error(`Shard ${shardId} did not reply to "${type}" in time.`);
-    if (reply.error !== undefined)
-      throw new Error(reply.error);
-    return reply.result;
-  }
-  async broadcast(type, data, options = {}) {
-    this.#assertSize(data, "The request data");
-    const keys = new Map;
-    const down = [];
-    for (const [shard, clusterId] of this.#owner) {
-      const cluster = this.#infos.get(clusterId);
-      if (cluster && isLive(cluster.state))
-        keys.set(`s:${shard}`, clusterId);
-      else
-        down.push(shard);
-    }
-    const { id, done } = this.#tracker.begin({
-      keys,
-      timeoutMs: options.timeoutMs ?? this.#options.requestTimeout ?? 5000,
-      signal: options.signal
-    });
-    const frame = {
-      [BUS_FRAME]: {
-        source: PARENT_ID,
-        target: null,
-        type,
-        data,
-        id,
-        expectsReply: true
-      }
-    };
-    for (const cluster of this.clusters.values())
-      if (!this.#sendFrame(cluster, frame))
-        this.#tracker.failOwner(cluster.id, `Cluster ${cluster.id} is ${cluster.state}.`);
-    const { replies, missing } = await done;
-    return {
-      replies: replies.map((reply) => ({
-        shardId: Number(reply.key.slice(2)),
-        ...reply.error !== undefined ? { error: reply.error } : { result: reply.result }
-      })),
-      missing: [
-        ...down,
-        ...missing.map((key) => Number(key.slice(2)))
-      ].sort((a, b) => a - b)
-    };
-  }
-  async requestCluster(clusterId, type, data, options = {}) {
-    this.#assertSize(data, "The request data");
-    const cluster = this.#infos.get(clusterId);
-    if (!cluster)
-      throw new RangeError(`Cluster ${clusterId} does not exist.`);
-    const { id, done } = this.#tracker.begin({
-      keys: new Map([[`c:${clusterId}`, clusterId]]),
-      timeoutMs: options.timeoutMs ?? this.#options.requestTimeout ?? 5000,
-      signal: options.signal
-    });
-    if (!this.#sendFrame(cluster, {
-      [CLUSTER_FRAME]: { kind: "request", id, type, data }
-    }))
-      this.#tracker.failOwner(clusterId, `Cluster ${clusterId} is ${cluster.state}.`);
-    const { replies } = await done;
-    const reply = replies[0];
-    if (!reply)
-      throw new Error(`Cluster ${clusterId} did not reply to "${type}" in time.`);
-    if (reply.error !== undefined)
-      throw new Error(reply.error);
-    return reply.result;
-  }
-  ready(timeoutMs) {
-    if (this.#isReady())
-      return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        resolve: () => {
-          if (waiter.timer)
-            clearTimeout(waiter.timer);
-          this.#readyWaiters.delete(waiter);
-          resolve();
-        },
-        reject: (error) => {
-          if (waiter.timer)
-            clearTimeout(waiter.timer);
-          this.#readyWaiters.delete(waiter);
-          reject(error);
-        }
-      };
-      if (timeoutMs !== undefined)
-        waiter.timer = setTimeout(() => waiter.reject(new Error(`Clusters were not all ready within ${timeoutMs}ms.`)), timeoutMs);
-      this.#readyWaiters.add(waiter);
-    });
-  }
-  #isReady() {
-    let ready = 0;
-    for (const cluster of this.#infos.values()) {
-      if (cluster.state === "ready")
-        ready++;
-      else if (!(cluster.state === "failed" && cluster.shards.length === 0))
-        return false;
-    }
-    return ready > 0;
-  }
-  #rejectReady(failed, why) {
-    if (failed.shards.length === 0)
-      return;
-    const error = new Error(`Cluster ${failed.id} failed and shards [${failed.shards}] have no owner (${why}).`);
-    for (const waiter of [...this.#readyWaiters])
-      waiter.reject(error);
-  }
-  #checkReady() {
-    if (!this.#isReady())
-      return;
-    for (const waiter of [...this.#readyWaiters])
-      waiter.resolve();
-    if (!this.#allReady) {
-      this.#allReady = true;
-      this.#emit("ready");
-    }
-  }
-  health() {
-    const now = Date.now();
-    const clusters = [...this.#infos.values()].sort((a, b) => a.id - b.id).map((cluster) => ({
-      id: cluster.id,
-      state: cluster.state,
-      ...cluster.process.pid !== undefined && isLive(cluster.state) ? { pid: cluster.process.pid } : {},
-      host: cluster.host,
-      shardIds: [...cluster.shards],
-      uptimeMs: isLive(cluster.state) ? now - cluster.startedAt : 0,
-      restarts: cluster.restarts,
-      startedAt: cluster.startedAt,
-      ...cluster.readyAt !== undefined ? { readyAt: cluster.readyAt } : {},
-      ...cluster.lastReadyAt !== undefined ? { lastReadyAt: cluster.lastReadyAt } : {},
-      shards: cluster.report?.shards ?? [],
-      ...cluster.report?.metrics ? { metrics: cluster.report.metrics } : {},
-      ...cluster.report ? { reportedAt: cluster.report.reportedAt } : {}
-    }));
-    const missingShards = [...this.#owner].filter(([, id]) => this.#infos.get(id)?.state !== "ready").map(([shard]) => shard).sort((a, b) => a - b);
-    const states = clusters.map((cluster) => cluster.state);
-    const state = this.#stopping ? "stopping" : clusters.length === 0 ? this.#wasStarted ? "stopped" : "idle" : states.every((s) => s === "stopped") ? "stopped" : states.every((s) => s === "ready") ? "ready" : states.some((s) => s === "restarting" || s === "failed") ? "degraded" : "starting";
-    return {
-      state,
-      totalShards: this.shardCount,
-      clusters,
-      readyClusters: states.filter((s) => s === "ready").length,
-      missingShards
-    };
-  }
-  async refreshHealth(options = {}) {
-    await Promise.all([...this.clusters.values()].map(async (cluster) => {
-      try {
-        cluster.report = await this.requestCluster(cluster.id, REQUEST_HEALTH, { metrics: options.metrics === true }, { timeoutMs: options.timeoutMs ?? 2000 });
-      } catch {}
-    }));
-    return this.health();
-  }
-  async checkAutoScale() {
-    if (!this.#auto)
-      return;
-    try {
-      const recommended = await this.fetchRecommendedShardCount();
-      if (recommended !== this.shardCount) {
-        await this.respawn(recommended);
-      }
-    } catch (error) {
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      this.#options.onAutoScaleError?.(normalized);
-    }
-  }
-  async respawn(newShardCount) {
-    this.#options.shardCount = newShardCount;
-    await this.#stop(this.#options.shutdownTimeout ?? 5000, true);
-    this.#supervisor.reset();
-    await this.spawn();
-  }
-  shutdownAll(timeoutMs = this.#options.shutdownTimeout ?? 5000) {
-    return this.#stop(timeoutMs, false);
-  }
-  #stop(timeoutMs, keepRemote) {
-    this.#stopPromise ??= this.#shutdown(timeoutMs, keepRemote).finally(() => {
-      this.#stopPromise = undefined;
-    });
-    return this.#stopPromise;
-  }
-  async#shutdown(timeoutMs, keepRemote) {
-    this.#stopping = true;
-    this.#halt();
-    await this.#startPromise?.catch(() => {
-      return;
-    });
-    await Promise.all([...this.clusters.values()].map((cluster) => this.#shutdownCluster(cluster, timeoutMs)));
-    for (const cluster of this.#infos.values())
-      cluster.state = "stopped";
-    this.clusters.clear();
-    this.#startPromise = undefined;
-    if (!keepRemote) {
-      this.#remote?.stop();
-      await this.#resign();
-    }
-    this.#stopping = false;
-  }
-  #halt() {
-    this.#generation++;
-    for (const timer of this.#restartTimers)
-      clearTimeout(timer);
-    this.#restartTimers.clear();
-    this.#fencing.clear();
-    for (const id of [...this.#startTimers.keys()])
-      this.#clearStartTimer(id);
-    for (const wake of [...this.#pauses])
-      wake();
-    if (this.#autoScaleTimer) {
-      clearInterval(this.#autoScaleTimer);
-      this.#autoScaleTimer = undefined;
-    }
-    this.#coordinator?.close();
-    this.#coordinator = undefined;
-    this.#remote?.abortWaits();
-    this.#tracker.close();
-    for (const waiter of [...this.#readyWaiters])
-      waiter.reject(new Error("The cluster manager is stopping."));
-  }
-  async#shutdownCluster(cluster, timeoutMs) {
-    const child = cluster.process;
-    cluster.state = "stopping";
-    if (child.exitCode !== null || child.signalCode !== null)
-      return;
-    await new Promise((resolve) => {
-      let timer;
-      const finish = () => {
-        if (timer)
-          clearTimeout(timer);
-        resolve();
-      };
-      child.once("exit", finish);
-      try {
-        child.kill("SIGTERM");
-      } catch {
-        child.off("exit", finish);
-        finish();
-        return;
-      }
-      timer = setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {}
-      }, timeoutMs);
-    });
-  }
-  killAll() {
-    this.#stopping = true;
-    this.#halt();
-    for (const cluster of this.#infos.values()) {
-      cluster.state = "stopped";
-      try {
-        cluster.process.kill();
-      } catch {}
-    }
-    this.clusters.clear();
-    this.#startPromise = undefined;
-    this.#remote?.stop();
-    this.#resign();
-    this.#stopping = false;
-  }
-}
-function withTimeout(promise, ms) {
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`The leader lock did not answer within ${ms} ms.`)), ms);
-  });
-  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
-function asError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-// packages/sharding/src/host.ts
-import { fork as fork2 } from "child_process";
-class ClusterHost {
-  #options;
-  #running = new Map;
-  #listeners = new Map;
-  #socket;
-  #urls;
-  #urlIndex = 0;
-  #unreachable = 0;
-  #accepted = false;
-  #lease = 15000;
-  #lastRx = 0;
-  #watchdog;
-  #retry;
-  #delay;
-  #busyAttempts = 0;
-  #closed = true;
-  #connected = false;
-  #firstConnect;
-  constructor(options) {
-    if (!HOST_ID.test(options.id))
-      throw new RangeError("id must be 1-64 letters, digits, '.', '_' or '-'.");
-    if (!options.secret || options.secret.length < 16)
-      throw new RangeError("secret must be at least 16 characters.");
-    if (!options.script?.trim())
-      throw new TypeError("A worker script path is required.");
-    const urls = Array.isArray(options.url) ? [...options.url] : [options.url];
-    if (urls.length === 0 || urls.length > 16)
-      throw new TypeError("url must list 1 to 16 coordinators.");
-    for (const raw of urls) {
-      let url;
-      try {
-        url = new URL(raw);
-      } catch {
-        throw new TypeError("url must be an absolute ws:// or wss:// URL.");
-      }
-      if (url.protocol !== "ws:" && url.protocol !== "wss:")
-        throw new TypeError("url must start with ws:// or wss://.");
-      if (url.username || url.password)
-        throw new TypeError("url must not contain credentials.");
-      if (url.protocol === "ws:" && !options.allowInsecure && !isLoopbackHost(url.hostname))
-        throw new TypeError("url must use wss:// to reach another machine (allowInsecure: true overrides this for a network you fully trust).");
-    }
-    this.#urls = urls;
-    this.#options = options;
-    this.#delay = options.reconnectDelay ?? 1000;
-  }
-  get connected() {
-    return this.#connected;
-  }
-  clusters() {
-    return [...this.#running.keys()].sort((a, b) => a - b);
-  }
-  on(event, listener) {
-    let set = this.#listeners.get(event);
-    if (!set)
-      this.#listeners.set(event, set = new Set);
-    set.add(listener);
-    return this;
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-    return this;
-  }
-  #emit(event, ...args) {
-    for (const listener of this.#listeners.get(event) ?? [])
-      try {
-        listener(...args);
-      } catch {}
-  }
-  connect() {
-    if (!this.#closed)
-      return Promise.resolve();
-    this.#closed = false;
-    this.#busyAttempts = 0;
-    this.#unreachable = 0;
-    return new Promise((resolve, reject) => {
-      this.#firstConnect = { resolve, reject };
-      this.#open();
-    });
-  }
-  close() {
-    this.#closed = true;
-    if (this.#retry)
-      clearTimeout(this.#retry);
-    this.#retry = undefined;
-    this.#fence();
-    if (this.#watchdog)
-      clearInterval(this.#watchdog);
-    this.#watchdog = undefined;
-    this.#connected = false;
-    const socket = this.#socket;
-    this.#socket = undefined;
-    this.#firstConnect?.reject(new Error("The host was closed."));
-    this.#firstConnect = undefined;
-    if (!socket || socket.readyState === WebSocket.CLOSED)
-      return Promise.resolve();
-    return new Promise((resolve) => {
-      socket.addEventListener("close", () => resolve(), { once: true });
-      try {
-        socket.close(1000, "Host closed.");
-      } catch {
-        resolve();
-      }
-    });
-  }
-  #open() {
-    this.#accepted = false;
-    const socket = new WebSocket(this.#urls[this.#urlIndex]);
-    this.#socket = socket;
-    socket.addEventListener("message", (event) => this.#message(socket, event.data));
-    socket.addEventListener("error", () => {});
-    socket.addEventListener("close", (event) => {
-      if (this.#socket === socket)
-        this.#lost(event.code, event.reason);
-    });
-  }
-  #send(socket, message) {
-    if (socket.readyState !== WebSocket.OPEN)
-      return false;
-    try {
-      socket.send(JSON.stringify(message));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  #refuseSpawn(socket, data) {
-    if (typeof data !== "string" || data.length > 65536)
-      return;
-    let frame;
-    try {
-      frame = JSON.parse(data);
-    } catch {
-      return;
-    }
-    if (frame?.t !== "spawn" || !Number.isInteger(frame.cluster) || !Number.isInteger(frame.epoch))
-      return;
-    this.#send(socket, {
-      t: "error",
-      cluster: frame.cluster,
-      epoch: frame.epoch,
-      message: "This host refused the spawn request (malformed or not allowed)."
-    });
-  }
-  #message(socket, data) {
-    if (this.#socket !== socket)
-      return;
-    const message = parseToHost(data);
-    if (!message) {
-      this.#emit("error", new Error("The coordinator sent a malformed frame."));
-      this.#refuseSpawn(socket, data);
-      return;
-    }
-    this.#lastRx = Date.now();
-    switch (message.t) {
-      case "challenge":
-        if (message.version !== REMOTE_PROTOCOL_VERSION) {
-          socket.close(RemoteClose.VersionMismatch, "Protocol version mismatch.");
-          return;
-        }
-        this.#send(socket, {
-          t: "hello",
-          id: this.#options.id,
-          mac: signChallenge(this.#options.secret, message.nonce, this.#options.id),
-          version: REMOTE_PROTOCOL_VERSION
-        });
-        return;
-      case "welcome":
-        this.#lease = message.leaseMs;
-        this.#accepted = true;
-        this.#connected = true;
-        this.#delay = this.#options.reconnectDelay ?? 1000;
-        this.#startWatchdog();
-        this.#firstConnect?.resolve();
-        this.#firstConnect = undefined;
-        this.#emit("connected");
-        return;
-      case "ping":
-        this.#send(socket, { t: "pong", n: message.n });
-        return;
-      case "bye":
-        this.#fence();
-        return;
-      case "spawn":
-        this.#spawn(socket, message.cluster, message.epoch, message.env);
-        return;
-      case "frame": {
-        const run = this.#running.get(message.cluster);
-        if (run?.epoch === message.epoch && run.child.connected)
-          try {
-            run.child.send(message.frame);
-          } catch {}
-        return;
-      }
-      case "kill": {
-        const run = this.#running.get(message.cluster);
-        if (run?.epoch === message.epoch && KILL_SIGNALS.has(message.signal))
-          try {
-            run.child.kill(message.signal);
-          } catch {}
-        return;
-      }
-    }
-  }
-  #spawn(socket, cluster, epoch, env) {
-    const reply = (message) => {
-      if (this.#socket === socket)
-        this.#send(socket, message);
-    };
-    if (this.#running.has(cluster)) {
-      reply({
-        t: "error",
-        cluster,
-        epoch,
-        message: `Cluster ${cluster} is already running here.`
-      });
-      return;
-    }
-    let child;
-    try {
-      const forkWorker = this.#options.fork ?? defaultFork;
-      child = forkWorker(this.#options.script, {
-        ...process.env,
-        ...env
-      });
-    } catch (error) {
-      reply({
-        t: "error",
-        cluster,
-        epoch,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return;
-    }
-    this.#running.set(cluster, { epoch, child });
-    child.on("message", (frame) => reply({ t: "frame", cluster, epoch, frame }));
-    child.once("exit", (code, signal) => {
-      if (this.#running.get(cluster)?.child === child)
-        this.#running.delete(cluster);
-      this.#emit("clusterExit", cluster, code, signal);
-      reply({ t: "exit", cluster, epoch, code, signal });
-    });
-    child.on("error", (error) => this.#emit("error", error instanceof Error ? error : new Error(String(error))));
-    reply({
-      t: "spawned",
-      cluster,
-      epoch,
-      ...child.pid ? { pid: child.pid } : {}
-    });
-    this.#emit("clusterSpawn", cluster);
-  }
-  #fence() {
-    for (const { child } of [...this.#running.values()])
-      try {
-        child.kill("SIGKILL");
-      } catch {}
-  }
-  #startWatchdog() {
-    if (this.#watchdog)
-      clearInterval(this.#watchdog);
-    this.#lastRx = Date.now();
-    this.#watchdog = setInterval(() => {
-      if (Date.now() - this.#lastRx > this.#lease) {
-        this.#fence();
-        this.#socket?.close(RemoteClose.HostLost, "Coordinator silent.");
-      }
-    }, Math.max(10, Math.floor(this.#lease / 3)));
-    this.#watchdog.unref?.();
-  }
-  #lost(code, reason) {
-    if (this.#watchdog)
-      clearInterval(this.#watchdog);
-    this.#watchdog = undefined;
-    this.#socket = undefined;
-    const wasConnected = this.#connected;
-    this.#connected = false;
-    this.#fence();
-    if (wasConnected)
-      this.#emit("disconnected", { code, reason });
-    if (this.#closed)
-      return;
-    const refused = code === RemoteClose.AuthFailed || code === RemoteClose.UnknownHost || code === RemoteClose.DuplicateHost || code === RemoteClose.VersionMismatch;
-    const first = this.#firstConnect;
-    const busy = code === RemoteClose.TooManyConnections || code === RemoteClose.HelloTimeout;
-    const accepted = this.#accepted;
-    if (this.#urls.length > 1)
-      this.#urlIndex = (this.#urlIndex + 1) % this.#urls.length;
-    if (first && !refused && !busy && !accepted && ++this.#unreachable < this.#urls.length) {
-      this.#open();
-      return;
-    }
-    if (first && busy && ++this.#busyAttempts < (this.#options.connectAttempts ?? 10)) {
-      this.#retryLater();
-      return;
-    }
-    if (first) {
-      this.#firstConnect = undefined;
-      this.#closed = true;
-      first.reject(new Error(`The coordinator refused this host (${code}${reason ? `: ${reason}` : ""}).`));
-      return;
-    }
-    if (refused)
-      this.#emit("error", new Error(`The coordinator refused this host (${code}: ${reason}).`));
-    this.#retryLater();
-  }
-  #retryLater() {
-    const wait = Math.round(this.#delay * (1 + Math.random() * 0.2));
-    this.#delay = Math.min(this.#options.maxReconnectDelay ?? 30000, this.#delay * 2);
-    this.#retry = setTimeout(() => {
-      this.#retry = undefined;
-      if (!this.#closed)
-        this.#open();
-    }, wait);
-  }
-}
-function defaultFork(script, env) {
-  return fork2(script, [], { env });
-}
-// packages/sharding/src/leader.ts
-var ACQUIRE = `local v = redis.call('GET', KEYS[1])
-if v == ARGV[1] then redis.call('PEXPIRE', KEYS[1], ARGV[2]) return 1 end
-if not v then redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2]) return 1 end
-return 0`;
-var RELEASE = `if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) end
-return 0`;
-
-class RedisLeaderLock {
-  #client;
-  #key;
-  #token;
-  constructor(options) {
-    if (typeof options?.client?.send !== "function")
-      throw new TypeError("RedisLeaderLock needs a client with send().");
-    this.#client = options.client;
-    this.#key = options.key ?? "lunibee:cluster:leader";
-    this.#token = options.token ?? crypto.randomUUID();
-    if (!this.#key || !this.#token)
-      throw new TypeError("key and token must not be empty.");
-  }
-  async acquire(ttlMs) {
-    if (!Number.isInteger(ttlMs) || ttlMs < 1)
-      throw new RangeError("ttlMs must be a positive integer.");
-    const reply = await this.#client.send("EVAL", [
-      ACQUIRE,
-      "1",
-      this.#key,
-      this.#token,
-      String(ttlMs)
-    ]);
-    return Number(reply) === 1;
-  }
-  async release() {
-    await this.#client.send("EVAL", [RELEASE, "1", this.#key, this.#token]);
-  }
-}
-
-// packages/sharding/src/index.ts
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function needsConnection(gateway) {
-  return gateway.state === "CONNECT" /* Connect */ || gateway.state === "RECONNECT" /* Reconnect */ || gateway.state === "CLOSED" /* Closed */;
-}
-var HANDSHAKE_SENT = new Set([
-  "IDENTIFY" /* Identify */,
-  "RESUME" /* Resume */,
-  "READY" /* Ready */,
-  "DISPATCH" /* Dispatch */,
-  "HEARTBEAT" /* Heartbeat */,
-  "CLOSED" /* Closed */
-]);
-function handshakeSent(gateway, timeout) {
-  if (HANDSHAKE_SENT.has(gateway.state))
-    return Promise.resolve();
-  return new Promise((resolve) => {
-    const done = () => {
-      clearTimeout(timer);
-      gateway.off("stateChange", onState);
-      resolve();
-    };
-    const onState = (change) => {
-      if (HANDSHAKE_SENT.has(change.next))
-        done();
-    };
-    const timer = setTimeout(done, timeout);
-    gateway.on("stateChange", onState);
-  });
-}
-
-class ShardManager {
-  static IDENTIFY_INTERVAL = 5000;
-  shards = new Map;
-  get shardCount() {
-    return this.#resolved ? this.#total : 0;
-  }
-  get shardIds() {
-    return [...this.shards.keys()].sort((a, b) => a - b);
-  }
-  #options;
-  #ids;
-  #gate;
-  #worker;
-  #lifecycle = new Map;
-  #announced = false;
-  #resolved = false;
-  #destroyed = false;
-  #auto;
-  #fixedCount;
-  #autoScaleTimer;
-  #total;
-  #listeners = new Map;
-  #gatewayInfo;
-  constructor(options) {
-    if (!options.token?.trim())
-      throw new TypeError("A Discord bot token is required.");
-    if (!Array.isArray(options.intents))
-      throw new TypeError("Gateway intents must be an array, e.g. [GatewayIntentBits.Guilds].");
-    const context = options.cluster === false ? null : options.cluster ?? readClusterContext();
-    if (context) {
-      if (options.shardCount === "auto")
-        throw new RangeError(`shardCount "auto" is the ClusterManager's decision inside a cluster worker.`);
-      if (options.shardCount !== undefined && options.shardCount !== context.shardCount)
-        throw new RangeError(`shardCount ${options.shardCount} differs from the cluster's ${context.shardCount}.`);
-      if (options.autoScaleInterval !== undefined)
-        throw new TypeError("autoScaleInterval belongs to ClusterManager inside a cluster worker.");
-      if (options.shardIds && !options.shardIds.every((id) => context.shardIds.includes(id)))
-        throw new RangeError("shardIds must be a subset of the cluster's own shards.");
-    }
-    const count = context ? context.shardCount : 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.");
-    if (options.guildsPerShard !== undefined) {
-      assertGuildsPerShard(options.guildsPerShard);
-      if (options.shardCount !== "auto")
-        throw new RangeError('guildsPerShard needs shardCount: "auto".');
-    }
-    this.#ids = options.shardIds ?? context?.shardIds;
-    if (this.#ids && options.shardCount !== "auto")
-      validateShardIds(this.#ids, count);
-    this.#worker = options.worker === false ? undefined : options.worker ?? (context && options.cluster === undefined ? ClusterWorker.current() : undefined);
-    this.#gate = options.identify === false ? undefined : options.identify ?? (context?.coordinatedIdentify ? this.#worker?.identifyGate : undefined);
-    if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000))
-      throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
-    if (options.spawnDelay !== undefined && (!Number.isFinite(options.spawnDelay) || options.spawnDelay < 0))
-      throw new RangeError("spawnDelay must be a non-negative finite number of milliseconds.");
-    if (options.maxConcurrency !== undefined && (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency < 1))
-      throw new RangeError("maxConcurrency must be a positive integer.");
-    if (options.handshakeTimeout !== undefined && (!Number.isFinite(options.handshakeTimeout) || options.handshakeTimeout < 0))
-      throw new RangeError("handshakeTimeout must be a non-negative number of milliseconds.");
-    this.#total = count;
-    this.#fixedCount = count;
-    this.#auto = options.shardCount === "auto";
-    this.#options = {
-      spawnDelay: ShardManager.IDENTIFY_INTERVAL,
-      ...options
-    };
-    this.#worker?.onRequest(REQUEST_HEALTH, (data) => this.report(data?.metrics === true));
-    this.#worker?.onRequest(REQUEST_ASSIGN, async (data) => {
-      const ids = data?.shardIds;
-      if (!Array.isArray(ids))
-        throw new TypeError("shardIds must be an array.");
-      await this.addShards(ids);
-      return { shardIds: ids };
-    });
-    if (options.shardCount !== "auto")
-      this.#initialize(count);
-  }
-  async fetchRecommendedShardCount() {
-    return resolveShardCount(this.#options.token, await this.fetchGatewayInfo(), this.#options);
-  }
-  async fetchGatewayInfo() {
-    const info = await fetchGatewayBot(this.#options.token);
-    this.#gatewayInfo = info;
-    return info;
-  }
-  async connect() {
-    if (this.#autoScaleTimer) {
-      clearInterval(this.#autoScaleTimer);
-      this.#autoScaleTimer = undefined;
-    }
-    await this.#ensureInitialized();
-    await this.#start([...this.shards].filter(([, gateway]) => needsConnection(gateway)).map(([id]) => id));
-    if (this.#options.autoScaleInterval && this.#auto && !this.#autoScaleTimer) {
-      this.#autoScaleTimer = setInterval(() => {
-        this.checkAutoScale();
-      }, this.#options.autoScaleInterval);
-    }
-  }
-  async addShards(shardIds) {
-    await this.#ensureInitialized();
-    validateShardIds(shardIds, this.#total);
-    for (const id of shardIds)
-      if (this.shards.has(id))
-        throw new RangeError(`Shard ${id} is already owned.`);
-    for (const id of shardIds)
-      this.shards.set(id, this.#createShard(id, this.#total));
-    if (this.#ids)
-      this.#ids = [...this.#ids, ...shardIds];
-    this.#announced = false;
-    try {
-      await this.#start([...shardIds], false);
-    } catch (error) {
-      for (const id of shardIds) {
-        this.shards.get(id)?.close();
-        this.shards.delete(id);
-        this.#lifecycle.delete(id);
-      }
-      if (this.#ids)
-        this.#ids = this.#ids.filter((id) => !shardIds.includes(id));
-      throw error;
-    }
-  }
-  async#start(ids, destroyOnFailure = true) {
-    const gate = this.#gate;
-    if (gate) {
-      const timeout = this.#options.handshakeTimeout ?? 15000;
-      const results = await Promise.allSettled(ids.map(async (id) => {
-        const gateway = this.shards.get(id);
-        this.#setStatus(id, "connecting");
-        await gate.acquire(id);
-        try {
-          await gateway.connect();
-          await handshakeSent(gateway, timeout);
-        } finally {
-          gate.release(id);
-        }
-      }));
-      const failed = results.findIndex((result) => result.status === "rejected");
-      if (failed !== -1) {
-        if (destroyOnFailure)
-          this.destroy();
-        throw new Error(`Failed to connect shard ${ids[failed]}.`, {
-          cause: results[failed].reason
-        });
-      }
-      return;
-    }
-    const limit = this.#gatewayInfo?.sessionStartLimit;
-    if (limit && limit.remaining < ids.length)
-      throw new Error(`Session start limit exhausted: ${limit.remaining} of ${limit.total} IDENTIFYs left for ${ids.length} shards; resets in ${Math.ceil(limit.resetAfter / 1000)}s.`);
-    const concurrency = Math.min(this.#options.maxConcurrency ?? limit?.maxConcurrency ?? 1, limit?.maxConcurrency ?? Infinity);
-    const buckets = new Map;
-    for (const id of ids) {
-      const key = id % concurrency;
-      const bucket = buckets.get(key);
-      if (bucket)
-        bucket.push(id);
-      else
-        buckets.set(key, [id]);
-    }
-    const rounds = Math.max(0, ...[...buckets.values()].map((bucket) => bucket.length));
-    for (let index = 0;index < rounds; index++) {
-      const round = [...buckets.values()].map((bucket) => bucket[index]).filter((id) => id !== undefined);
-      for (const id of round)
-        this.#setStatus(id, "connecting");
-      const results = await Promise.allSettled(round.map((id) => this.shards.get(id).connect()));
-      const failed = results.findIndex((result) => result.status === "rejected");
-      if (limit)
-        limit.remaining = Math.max(0, limit.remaining - results.filter((r) => r.status === "fulfilled").length);
-      if (failed !== -1) {
-        if (destroyOnFailure)
-          this.destroy();
-        throw new Error(`Failed to connect shard ${round[failed]}.`, {
-          cause: results[failed].reason
-        });
-      }
-      if (index + 1 < rounds && this.#options.spawnDelay && this.#options.spawnDelay > 0) {
-        await Promise.all(round.map((id) => handshakeSent(this.shards.get(id), this.#options.handshakeTimeout ?? 15000)));
-        await sleep(this.#options.spawnDelay);
-      }
-    }
-  }
-  async checkAutoScale() {
-    if (!this.#auto)
-      return;
-    try {
-      const recommended = await this.fetchRecommendedShardCount();
-      if (recommended !== this.shardCount) {
-        await this.reshard(recommended);
-      }
-    } catch (error) {
-      this.#options.onAutoScaleError?.(error);
-    }
-  }
-  async reshard(count) {
-    this.#options.shardCount = count;
-    this.destroy();
-    await this.connect();
-  }
-  destroy() {
-    for (const shard of this.shards.values())
-      shard.close();
-    for (const id of this.shards.keys())
-      this.#setStatus(id, "destroyed");
-    this.shards.clear();
-    this.#lifecycle.clear();
-    this.#announced = false;
-    this.#resolved = false;
-    this.#destroyed = true;
-    if (this.#autoScaleTimer) {
-      clearInterval(this.#autoScaleTimer);
-      this.#autoScaleTimer = undefined;
-    }
-  }
-  on(event, listener) {
-    let set = this.#listeners.get(event);
-    if (!set)
-      this.#listeners.set(event, set = new Set);
-    set.add(listener);
-    return this;
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-    return this;
-  }
-  #emit(event, ...args) {
-    for (const listener of this.#listeners.get(event) ?? [])
-      try {
-        listener(...args);
-      } catch {}
-  }
-  getShardIdForGuild(guildId) {
-    const id = BigInt(guildId);
-    return Number((id >> 22n) % BigInt(this.#total));
-  }
-  sendVoiceState(guildId, channelId, options = {}) {
-    return this.shards.get(this.getShardIdForGuild(guildId))?.sendVoiceState(guildId, channelId, options) ?? false;
-  }
-  get(id) {
-    return this.shards.get(id);
-  }
-  health() {
-    return [...this.shards].map(([id, gateway]) => {
-      const life = this.#lifecycle.get(id);
-      return {
-        id,
-        state: gateway.state,
-        ping: gateway.ping,
-        status: life?.status ?? "idle",
-        ...life?.readyAt !== undefined ? { readyAt: life.readyAt } : {},
-        ...life?.disconnectedAt !== undefined ? { disconnectedAt: life.disconnectedAt } : {}
-      };
-    });
-  }
-  report(metrics = false) {
-    let numbers;
-    if (metrics) {
-      const memory = process.memoryUsage();
-      const cpu = process.cpuUsage();
-      numbers = {
-        rssBytes: memory.rss,
-        heapUsedBytes: memory.heapUsed,
-        cpuUserMicros: cpu.user,
-        cpuSystemMicros: cpu.system
-      };
-    }
-    return {
-      shards: this.health(),
-      ...numbers ? { metrics: numbers } : {},
-      reportedAt: Date.now()
-    };
-  }
-  #setStatus(id, status) {
-    const life = this.#lifecycle.get(id) ?? { status };
-    life.status = status;
-    const now = Date.now();
-    if (status === "ready")
-      life.readyAt = now;
-    if (status === "disconnected")
-      life.disconnectedAt = now;
-    this.#lifecycle.set(id, life);
-    if (status !== "ready")
-      this.#announced = false;
-    else
-      this.#maybeAnnounce();
-  }
-  #maybeAnnounce() {
-    if (this.#announced || this.shards.size === 0)
-      return;
-    for (const id of this.shards.keys())
-      if (this.#lifecycle.get(id)?.status !== "ready")
-        return;
-    this.#announced = true;
-    this.#emit("ready");
-    this.#worker?.ready(this.shardIds);
-    this.#worker?.reportHealth(this.report());
-  }
-  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.#fixedCount;
-    this.#initialize(count);
-  }
-  #initialize(count) {
-    if (this.#resolved)
-      return;
-    this.#total = count;
-    const ids = this.#ids ?? Array.from({ length: count }, (_, i) => i);
-    validateShardIds(ids, count);
-    for (const id of ids)
-      this.shards.set(id, this.#createShard(id, count));
-    this.#resolved = true;
-  }
-  #createShard(id, count) {
-    const gateway = new Gateway({
-      token: this.#options.token,
-      intents: this.#options.intents,
-      shardId: id,
-      shardCount: count,
-      reconnect: this.#options.reconnect ?? true
-    });
-    gateway.on("ready", () => {
-      this.#setStatus(id, "ready");
-      this.#emit("shardReady", id);
-    });
-    gateway.on("resumed", () => {
-      this.#setStatus(id, "ready");
-      this.#emit("shardResume", id);
-    });
-    gateway.on("close", (close) => {
-      this.#setStatus(id, "disconnected");
-      this.#emit("shardDisconnect", id, close);
-    });
-    gateway.on("error", (error) => this.#emit("shardError", id, error));
-    gateway.on("unstable", (info) => {
-      this.#setStatus(id, "unstable");
-      this.#emit("shardUnstable", id, info);
-    });
-    this.#emit("shardCreate", id, gateway);
-    return gateway;
-  }
-}
+  fetchGatewayBot2,
+  MAX_GUILDS_PER_SHARD2,
+  shardsForGuilds2,
+  fetchGuildCount2,
+  isClusterWorker2,
+  validateShardIds2,
+  allocateShards2,
+  planClusters2,
+  assertCompleteAllocation2,
+  readClusterContext2,
+  threadFork2,
+  threadEndpoint2,
+  ClusterWorker2,
+  BroadcastChannelTransport2,
+  IpcTransport2,
+  ShardBus2,
+  ShardSupervisor2,
+  IDENTIFY_INTERVAL2,
+  IdentifyCoordinator2,
+  REMOTE_PROTOCOL_VERSION2,
+  RemoteClose2,
+  RequestTracker2,
+  ClusterManager2,
+  ClusterHost2,
+  RedisLeaderLock2,
+  SEQUENTIAL_READY_TIMEOUT2,
+  connectInQueue2,
+  ShardManager2
+} from "../chunks/index-mgw2yvrm.js";
 export {
-  BroadcastChannelTransport,
-  ClusterHost,
-  ClusterManager,
-  ClusterWorker,
-  IDENTIFY_INTERVAL,
-  IdentifyCoordinator,
-  IpcTransport,
-  MAX_GUILDS_PER_SHARD,
-  REMOTE_PROTOCOL_VERSION,
-  RedisLeaderLock,
-  RemoteClose,
-  RequestTracker,
-  ShardBus,
-  ShardManager,
-  ShardSupervisor,
-  ShardManager as ShardingManager,
-  allocateShards,
-  assertCompleteAllocation,
-  fetchGatewayBot,
-  fetchGuildCount,
-  isClusterWorker,
-  readClusterContext,
-  shardsForGuilds,
-  threadEndpoint,
-  threadFork,
-  validateShardIds
+  BroadcastChannelTransport2 as BroadcastChannelTransport,
+  ClusterHost2 as ClusterHost,
+  ClusterManager2 as ClusterManager,
+  ClusterWorker2 as ClusterWorker,
+  IDENTIFY_INTERVAL2 as IDENTIFY_INTERVAL,
+  IdentifyCoordinator2 as IdentifyCoordinator,
+  IpcTransport2 as IpcTransport,
+  MAX_GUILDS_PER_SHARD2 as MAX_GUILDS_PER_SHARD,
+  REMOTE_PROTOCOL_VERSION2 as REMOTE_PROTOCOL_VERSION,
+  RedisLeaderLock2 as RedisLeaderLock,
+  RemoteClose2 as RemoteClose,
+  RequestTracker2 as RequestTracker,
+  SEQUENTIAL_READY_TIMEOUT2 as SEQUENTIAL_READY_TIMEOUT,
+  ShardBus2 as ShardBus,
+  ShardManager2 as ShardManager,
+  ShardSupervisor2 as ShardSupervisor,
+  allocateShards2 as allocateShards,
+  assertCompleteAllocation2 as assertCompleteAllocation,
+  connectInQueue2 as connectInQueue,
+  fetchGatewayBot2 as fetchGatewayBot,
+  fetchGuildCount2 as fetchGuildCount,
+  isClusterWorker2 as isClusterWorker,
+  planClusters2 as planClusters,
+  readClusterContext2 as readClusterContext,
+  shardsForGuilds2 as shardsForGuilds,
+  threadEndpoint2 as threadEndpoint,
+  threadFork2 as threadFork,
+  validateShardIds2 as validateShardIds
 };
 
-//# debugId=D3CF0E421E8E307864756E2164756E21
+//# debugId=EA867F8F0564ED9364756E2164756E21