lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-fdvgk2sw.js

@@ -0,0 +1,1310 @@
+// @bun
+import {
+  resolveGatewayIntents2
+} from "./index-gyvps8b9.js";
+
+// packages/ws/src/session.ts
+class GatewaySession2 {
+  #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 GatewayHeartbeat2 {
+  #options;
+  #now;
+  #interval = 0;
+  #acknowledged = true;
+  #sentAt = 0;
+  #latency = -1;
+  #lastMessageAt = 0;
+  #zombieReported = false;
+  #awaitingAck = 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.#awaitingAck = false;
+    this.#initialTimer = setTimeout(() => {
+      this.#initialTimer = undefined;
+      this.sendHeartbeat();
+      this.#timer = setInterval(() => this.#scheduledBeat(), interval);
+    }, Math.random() * interval);
+  }
+  #scheduledBeat() {
+    if (this.#awaitingAck) {
+      this.#clearBeatTimers();
+      this.#options.onTimeout({
+        type: "ack",
+        elapsedMs: this.#now() - this.#sentAt
+      });
+      return;
+    }
+    this.sendHeartbeat();
+  }
+  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.#awaitingAck = true;
+    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.#awaitingAck = false;
+    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 GatewayCloseCodes2 = {
+  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_CODES2 = [
+  GatewayCloseCodes2.AuthenticationFailed,
+  GatewayCloseCodes2.InvalidShard,
+  GatewayCloseCodes2.ShardingRequired,
+  GatewayCloseCodes2.InvalidAPIVersion,
+  GatewayCloseCodes2.InvalidIntents,
+  GatewayCloseCodes2.DisallowedIntents
+];
+var IDENTIFY_CLOSE_CODES2 = [
+  GatewayCloseCodes2.InvalidSeq,
+  GatewayCloseCodes2.SessionTimedOut
+];
+function classifyCloseCode2(code, canResume) {
+  if (FATAL_CLOSE_CODES2.includes(code))
+    return "stop";
+  if (IDENTIFY_CLOSE_CODES2.includes(code))
+    return "identify";
+  return canResume ? "resume" : "identify";
+}
+
+class GatewayReconnect2 {
+  #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 classifyCloseCode2(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 PlainTextDecoder2 {
+  push(data) {
+    return [String(data)];
+  }
+  reset() {}
+}
+
+class ZlibStreamDecoder2 {
+  #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 createDecoder2(compress) {
+  return compress ? new ZlibStreamDecoder2 : new PlainTextDecoder2;
+}
+
+// packages/ws/src/transport.ts
+var OPEN = 1;
+
+class WebSocketTransport2 {
+  #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 ?? createDecoder2(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 GatewayOpcodes2 = {
+  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 classifyFrame2(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 classifyPayload2(payload);
+}
+function classifyPayload2(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 GatewayOpcodes2.Dispatch:
+      return {
+        sequence,
+        action: {
+          type: "dispatch",
+          event: typeof frame.t === "string" ? frame.t : null,
+          data: frame.d
+        }
+      };
+    case GatewayOpcodes2.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 GatewayOpcodes2.Heartbeat:
+      return { sequence, action: { type: "heartbeat" } };
+    case GatewayOpcodes2.HeartbeatAck:
+      return {
+        sequence,
+        action: { type: "heartbeat-ack", data: frame.d }
+      };
+    case GatewayOpcodes2.Reconnect:
+      return { sequence, action: { type: "reconnect" } };
+    case GatewayOpcodes2.InvalidSession:
+      return {
+        sequence,
+        action: {
+          type: "invalid-session",
+          resumable: frame.d === true
+        }
+      };
+    default:
+      return { sequence, action: { type: "unknown", opcode: frame.op } };
+  }
+}
+function identifyPayload2(options) {
+  const props = options.properties ?? {};
+  const os = props.os ?? process.platform;
+  const browser = props.browser ?? "Lunibee";
+  const device = props.device ?? "Lunibee";
+  return {
+    op: GatewayOpcodes2.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 resumePayload2(token, resume) {
+  return {
+    op: GatewayOpcodes2.Resume,
+    d: {
+      token,
+      session_id: resume.sessionId,
+      seq: resume.sequence
+    },
+    s: null,
+    t: null
+  };
+}
+function heartbeatPayload2(sequence) {
+  return { op: GatewayOpcodes2.Heartbeat, d: sequence, s: null, t: null };
+}
+// packages/ws/src/dispatcher.ts
+class GatewayDispatcher2 {
+  #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 GatewaySendLimiter2 {
+  #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
+var GatewayState2;
+((GatewayState) => {
+  GatewayState["Connect"] = "CONNECT";
+  GatewayState["Hello"] = "HELLO";
+  GatewayState["Identify"] = "IDENTIFY";
+  GatewayState["Resume"] = "RESUME";
+  GatewayState["Ready"] = "READY";
+  GatewayState["Dispatch"] = "DISPATCH";
+  GatewayState["Heartbeat"] = "HEARTBEAT";
+  GatewayState["Reconnect"] = "RECONNECT";
+  GatewayState["Closed"] = "CLOSED";
+})(GatewayState2 ||= {});
+
+class GatewayError2 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 Gateway2 {
+  state = "CONNECT" /* Connect */;
+  #options;
+  #transport;
+  #session = new GatewaySession2;
+  #token = 0;
+  #heartbeat;
+  #closed = false;
+  #paced = false;
+  #connectURL = DEFAULT_GATEWAY_URL;
+  #arming = false;
+  #reconnect;
+  #events = new GatewayDispatcher2((error) => this.#emitError(error));
+  #sendBudget = new GatewaySendLimiter2;
+  #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 = resolveGatewayIntents2(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.#connectURL = this.#withCompression(DEFAULT_GATEWAY_URL);
+    this.#transport = new WebSocketTransport2({
+      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 GatewayError2 ? error : new GatewayError2(error.message, undefined, {
+          cause: error
+        }))
+      }
+    });
+    this.#reconnect = new GatewayReconnect2({
+      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 GatewayHeartbeat2({
+      ackTimeout: this.#options.heartbeatAckTimeout,
+      zombieTimeout: this.#options.zombieTimeout,
+      send: (sequence) => this.#dispatch(heartbeatPayload2(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 GatewayError2(`Gateway connection appears stale after ${timeout.silentFor}ms without traffic.`));
+    } else {
+      this.#emitError(new GatewayError2(`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) {
+    if (this.state === "CLOSED" /* Closed */)
+      return Promise.reject(new GatewayError2("Gateway has been permanently closed."));
+    const inFlight = this.#reconnect.attemptPromise;
+    if (inFlight)
+      return inFlight;
+    if (this.#transport.live)
+      return Promise.resolve();
+    if (url !== undefined)
+      this.#connectURL = this.#withCompression(url);
+    if (this.#reconnect.pending || this.#arming)
+      return this.#reconnect.attempt(() => {});
+    this.#closed = false;
+    this.#paced = true;
+    this.#setState("CONNECT" /* Connect */);
+    const connectURL = this.#connectURL;
+    return this.#reconnect.attempt(() => this.#open(connectURL));
+  }
+  #withCompression(url) {
+    if (!this.#options.compress || url.includes("compress="))
+      return url;
+    return `${url}${url.includes("?") ? "&" : "?"}compress=zlib-stream`;
+  }
+  #reconnectURL() {
+    const base = this.#connectURL;
+    const target = this.#session.connectURL(base);
+    if (target === base)
+      return base;
+    try {
+      const from = new URL(base);
+      if (!from.search)
+        return target;
+      const to = new URL(target);
+      for (const [key, value] of from.searchParams)
+        if (!to.searchParams.has(key))
+          to.searchParams.set(key, value);
+      return to.toString();
+    } catch {
+      return target;
+    }
+  }
+  close() {
+    this.#closed = true;
+    this.#clearTimers();
+    this.#settleConnect(new GatewayError2("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 GatewayError2("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: GatewayOpcodes2.PresenceUpdate,
+      d: payload,
+      s: null,
+      t: null
+    });
+  }
+  setVoiceState(data) {
+    return this.send({
+      op: GatewayOpcodes2.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: GatewayOpcodes2.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 } = classifyFrame2(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 ? GatewayCloseCodes2.UnknownError : 1000, action.resumable ? "Invalid session (resumable)" : "Invalid session");
+        return;
+      }
+      case "invalid":
+        this.#emitError(new GatewayError2(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 GatewayError2("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(resumePayload2(this.#options.token, intent), true);
+      return;
+    }
+    this.#setState("IDENTIFY" /* Identify */);
+    const gate = this.#options.identifyGate;
+    if (gate && !this.#paced) {
+      this.#gatedIdentify(gate);
+      return;
+    }
+    this.#paced = false;
+    this.#sendIdentify();
+  }
+  #gatedIdentify(gate) {
+    const token = this.#token;
+    const current = () => token === this.#token && !this.#closed && this.#session.owns(token);
+    gate.acquire().then(() => {
+      try {
+        if (current())
+          this.#sendIdentify();
+      } finally {
+        gate.release();
+      }
+    }, (error) => {
+      if (!current())
+        return;
+      this.#emitError(new GatewayError2(`No IDENTIFY slot: ${error instanceof Error ? error.message : String(error)}`));
+      this.#transport.close(RESUMABLE_CLOSE_CODE, "No IDENTIFY slot");
+    });
+  }
+  #sendIdentify() {
+    this.#dispatch(identifyPayload2({
+      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.#arming = !this.#closed && this.#reconnect.enabled && action !== "stop";
+    try {
+      this.#emit("close", { code, action });
+    } finally {
+      this.#arming = false;
+    }
+    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 GatewayError2(`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.#reconnectURL()));
+    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 GatewayError2("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 GatewayError2 ? error : new GatewayError2("Gateway connection failed.", undefined, {
+      cause: error
+    });
+  }
+  #emitError(error) {
+    this.#emit("error", error instanceof Error ? error : new GatewayError2(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 });
+  }
+}
+
+export { GatewaySession2, GatewayHeartbeat2, GatewayCloseCodes2, FATAL_CLOSE_CODES2, IDENTIFY_CLOSE_CODES2, classifyCloseCode2, GatewayReconnect2, PlainTextDecoder2, ZlibStreamDecoder2, createDecoder2, WebSocketTransport2, GatewayOpcodes2, classifyFrame2, classifyPayload2, identifyPayload2, resumePayload2, heartbeatPayload2, GatewayDispatcher2, GatewaySendLimiter2, GatewayState2, GatewayError2, Gateway2 };
+
+//# debugId=E9524FD19E93B4E464756E2164756E21