@fluxerjs/voice 1.0.3

package/dist/index.mjs

@@ -0,0 +1,892 @@
+// src/VoiceManager.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import { Events } from "@fluxerjs/core";
+import { GatewayOpcodes } from "@fluxerjs/types";
+
+// src/VoiceConnection.ts
+import { EventEmitter } from "events";
+import * as nacl from "tweetnacl";
+import * as dgram from "dgram";
+var VOICE_WS_OPCODES = { Identify: 0, SelectProtocol: 1, Ready: 2, Heartbeat: 3, SessionDescription: 4, Speaking: 5 };
+var VOICE_VERSION = 4;
+var CHANNELS = 2;
+var OPUS_FRAME_TICKS = 960 * (CHANNELS === 2 ? 2 : 1);
+var AUDIO_FRAME_INTERVAL_MS = 20;
+async function logFullResponse(url) {
+  try {
+    const fetchUrl = url.replace(/^wss:\/\//i, "https://").replace(/^ws:\/\//i, "http://");
+    const res = await fetch(fetchUrl, { method: "GET" });
+    const body = await res.text();
+    const headers = {};
+    res.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+    console.error("[voice] Full response from", url, {
+      status: res.status,
+      statusText: res.statusText,
+      headers,
+      body: body.slice(0, 2e3) + (body.length > 2e3 ? "..." : "")
+    });
+  } catch (e) {
+    console.error("[voice] Could not fetch URL for logging:", e);
+  }
+}
+var VoiceConnection = class extends EventEmitter {
+  client;
+  channel;
+  guildId;
+  _sessionId = null;
+  _token = null;
+  _endpoint = null;
+  _userId;
+  voiceWs = null;
+  udpSocket = null;
+  ssrc = 0;
+  secretKey = null;
+  heartbeatInterval = null;
+  sequence = 0;
+  timestamp = 0;
+  _playing = false;
+  _destroyed = false;
+  currentStream = null;
+  remoteUdpAddress = "";
+  remoteUdpPort = 0;
+  audioPacketQueue = [];
+  pacingInterval = null;
+  constructor(client, channel, userId) {
+    super();
+    this.client = client;
+    this.channel = channel;
+    this.guildId = channel.guildId;
+    this._userId = userId;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get playing() {
+    return this._playing;
+  }
+  /** Called when we have both server update and state update. */
+  async connect(server, state) {
+    this._token = server.token;
+    const raw = (server.endpoint ?? "").trim();
+    this._sessionId = state.session_id;
+    if (!raw || !this._token || !this._sessionId) {
+      this.emit("error", new Error("Missing voice server or session data"));
+      return;
+    }
+    let wsUrl;
+    if (raw.includes("?")) {
+      wsUrl = /^wss?:\/\//i.test(raw) ? raw : raw.replace(/^https?:\/\//i, "wss://");
+      if (!/^wss?:\/\//i.test(wsUrl)) wsUrl = `wss://${wsUrl}`;
+    } else {
+      const normalized = raw.replace(/^(wss|ws|https?):\/\//i, "").replace(/^\/+/, "") || raw;
+      wsUrl = `wss://${normalized}?v=${VOICE_VERSION}`;
+    }
+    const hostPart = raw.replace(/^(wss|ws|https?):\/\//i, "").replace(/^\/+/, "").split("/")[0] ?? "";
+    this._endpoint = hostPart.split("?")[0] || hostPart;
+    const WS = await this.getWebSocketConstructor();
+    this.voiceWs = new WS(wsUrl);
+    return new Promise((resolve, reject) => {
+      const resolveReady = () => {
+        cleanup();
+        resolve();
+        this.emit("ready");
+      };
+      const onOpen = () => {
+        this.voiceWs.off("error", onError);
+        this.sendVoiceOp(VOICE_WS_OPCODES.Identify, {
+          server_id: this.guildId,
+          user_id: this._userId,
+          session_id: this._sessionId,
+          token: this._token
+        });
+      };
+      const onError = (err) => {
+        if (err instanceof Error && /Unexpected server response/i.test(err.message)) {
+          logFullResponse(wsUrl).catch(() => {
+          });
+        }
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      const onMessage = (data) => {
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        const payload = JSON.parse(buf.toString());
+        const op = payload.op;
+        const d = payload.d;
+        if (op === VOICE_WS_OPCODES.Ready) {
+          this.ssrc = d.ssrc;
+          const port = d.port;
+          const address = d.address ?? this._endpoint.split(":")[0];
+          this.remoteUdpAddress = address;
+          this.remoteUdpPort = port;
+          this.setupUDP(address, port, () => {
+          });
+        } else if (op === VOICE_WS_OPCODES.SessionDescription) {
+          this.secretKey = new Uint8Array(d.secret_key);
+          if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+          }
+          this.heartbeatInterval = setInterval(() => {
+            this.sendVoiceOp(VOICE_WS_OPCODES.Heartbeat, Date.now());
+          }, d.heartbeat_interval ?? 5e3);
+          resolveReady();
+        } else if (op === VOICE_WS_OPCODES.Heartbeat) {
+        }
+      };
+      const cleanup = () => {
+        if (this.voiceWs) {
+          this.voiceWs.removeAllListeners();
+        }
+      };
+      const ws = this.voiceWs;
+      ws.on("open", onOpen);
+      ws.on("error", onError);
+      ws.on("message", (data) => onMessage(data));
+      ws.once("close", () => {
+        cleanup();
+        if (!this._destroyed) reject(new Error("Voice WebSocket closed"));
+      });
+    });
+  }
+  async getWebSocketConstructor() {
+    try {
+      const ws = await import("ws");
+      return ws.default;
+    } catch {
+      throw new Error('Install "ws" for voice support: pnpm add ws');
+    }
+  }
+  sendVoiceOp(op, d) {
+    if (!this.voiceWs || this.voiceWs.readyState !== 1) return;
+    this.voiceWs.send(JSON.stringify({ op, d }));
+  }
+  setupUDP(remoteAddress, remotePort, onReady) {
+    const socket = dgram.createSocket("udp4");
+    this.udpSocket = socket;
+    const discovery = Buffer.alloc(70);
+    discovery.writeUInt32BE(1, 0);
+    discovery.writeUInt16BE(70, 4);
+    discovery.writeUInt32BE(this.ssrc, 6);
+    socket.send(discovery, 0, discovery.length, remotePort, remoteAddress, () => {
+      socket.once("message", (msg) => {
+        const len = msg.readUInt16BE(4);
+        let ourIp = "";
+        let i = 10;
+        while (i < Math.min(70, len + 8) && msg[i] !== 0) {
+          ourIp += String.fromCharCode(msg[i]);
+          i++;
+        }
+        const ourPort = msg.readUInt16BE(68);
+        this.sendVoiceOp(VOICE_WS_OPCODES.SelectProtocol, {
+          protocol: "udp",
+          data: {
+            address: ourIp,
+            port: ourPort,
+            mode: "xsalsa20_poly1305"
+          }
+        });
+        onReady();
+      });
+    });
+  }
+  /**
+   * Play a stream of raw Opus packets
+   * Uses the same queue and 20ms pacing as play(). Use this for local files (MP3 → PCM → Opus) or other Opus sources.
+   */
+  playOpus(stream) {
+    this.stop();
+    this._playing = true;
+    this.currentStream = stream;
+    this.audioPacketQueue = [];
+    this.sendVoiceOp(VOICE_WS_OPCODES.Speaking, { speaking: 1, delay: 0 });
+    const stopPacing = () => {
+      if (this.pacingInterval) {
+        clearInterval(this.pacingInterval);
+        this.pacingInterval = null;
+      }
+    };
+    this.pacingInterval = setInterval(() => {
+      const packet = this.audioPacketQueue.shift();
+      if (packet && this.secretKey && this.udpSocket) this.sendAudioFrame(packet);
+      if (this.audioPacketQueue.length === 0 && !this._playing) stopPacing();
+    }, AUDIO_FRAME_INTERVAL_MS);
+    stream.on("data", (chunk) => {
+      if (!this._playing) return;
+      if (Buffer.isBuffer(chunk) && chunk.length > 0) this.audioPacketQueue.push(chunk);
+    });
+    stream.on("error", (err) => {
+      this._playing = false;
+      this.currentStream = null;
+      stopPacing();
+      this.emit("error", err);
+    });
+    stream.on("end", () => {
+      this._playing = false;
+      this.currentStream = null;
+      if (this.audioPacketQueue.length === 0) stopPacing();
+    });
+  }
+  /**
+   * Play a direct WebM/Opus URL or stream. Fetches the URL (if string), demuxes with prism-media WebmDemuxer,
+   * and sends Opus packets to the voice connection. No FFmpeg or encoding; input must be WebM with Opus.
+   */
+  async play(urlOrStream) {
+    this.stop();
+    const { opus: prismOpus } = await import("prism-media");
+    const { Readable } = await import("stream");
+    let inputStream;
+    if (typeof urlOrStream === "string") {
+      try {
+        const response = await fetch(urlOrStream);
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        if (!response.body) throw new Error("No response body");
+        inputStream = Readable.fromWeb(response.body);
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        this.emit("error", err);
+        return;
+      }
+    } else {
+      inputStream = urlOrStream;
+    }
+    const demuxer = new prismOpus.WebmDemuxer();
+    inputStream.pipe(demuxer);
+    this._playing = true;
+    this.currentStream = demuxer;
+    this.audioPacketQueue = [];
+    this.sendVoiceOp(VOICE_WS_OPCODES.Speaking, { speaking: 1, delay: 0 });
+    const stopPacing = () => {
+      if (this.pacingInterval) {
+        clearInterval(this.pacingInterval);
+        this.pacingInterval = null;
+      }
+    };
+    this.pacingInterval = setInterval(() => {
+      const packet = this.audioPacketQueue.shift();
+      if (packet && this.secretKey && this.udpSocket) this.sendAudioFrame(packet);
+      if (this.audioPacketQueue.length === 0 && !this._playing) stopPacing();
+    }, AUDIO_FRAME_INTERVAL_MS);
+    demuxer.on("data", (chunk) => {
+      if (!this._playing) return;
+      if (Buffer.isBuffer(chunk) && chunk.length > 0) this.audioPacketQueue.push(chunk);
+    });
+    demuxer.on("error", (err) => {
+      this._playing = false;
+      this.currentStream = null;
+      stopPacing();
+      this.emit("error", err);
+    });
+    demuxer.on("end", () => {
+      this._playing = false;
+      this.currentStream = null;
+      if (this.audioPacketQueue.length === 0) stopPacing();
+    });
+  }
+  sendAudioFrame(opusPayload) {
+    if (!this.udpSocket || !this.secretKey) return;
+    const rtpHeader = Buffer.alloc(12);
+    rtpHeader[0] = 128;
+    rtpHeader[1] = 120;
+    rtpHeader.writeUInt16BE(this.sequence++, 2);
+    rtpHeader.writeUInt32BE(this.timestamp, 4);
+    rtpHeader.writeUInt32BE(this.ssrc, 8);
+    this.timestamp += OPUS_FRAME_TICKS;
+    const nonce = Buffer.alloc(24);
+    rtpHeader.copy(nonce, 0, 0, 12);
+    const encrypted = nacl.secretbox(opusPayload, new Uint8Array(nonce), this.secretKey);
+    const packet = Buffer.concat([rtpHeader, Buffer.from(encrypted)]);
+    if (this.remoteUdpPort && this.remoteUdpAddress && this.udpSocket) {
+      this.udpSocket.send(packet, 0, packet.length, this.remoteUdpPort, this.remoteUdpAddress);
+    }
+  }
+  stop() {
+    this._playing = false;
+    this.audioPacketQueue = [];
+    if (this.pacingInterval) {
+      clearInterval(this.pacingInterval);
+      this.pacingInterval = null;
+    }
+    if (this.currentStream) {
+      if (typeof this.currentStream.destroy === "function") this.currentStream.destroy();
+      this.currentStream = null;
+    }
+  }
+  disconnect() {
+    this._destroyed = true;
+    this.stop();
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.voiceWs) {
+      this.voiceWs.close();
+      this.voiceWs = null;
+    }
+    if (this.udpSocket) {
+      this.udpSocket.close();
+      this.udpSocket = null;
+    }
+    this.emit("disconnect");
+  }
+  destroy() {
+    this.disconnect();
+    this.removeAllListeners();
+  }
+};
+
+// src/LiveKitRtcConnection.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import {
+  Room,
+  RoomEvent,
+  AudioSource,
+  AudioFrame,
+  LocalAudioTrack,
+  TrackPublishOptions,
+  TrackSource
+} from "@livekit/rtc-node";
+
+// src/livekit.ts
+function isLiveKitEndpoint(endpoint, token) {
+  if (!endpoint || typeof endpoint !== "string") return false;
+  const s = endpoint.trim();
+  if (s.includes("access_token=") || s.includes("/rtc") && s.includes("?"))
+    return true;
+  if (token && !s.includes("?")) return true;
+  return false;
+}
+function buildLiveKitUrlForRtcSdk(endpoint) {
+  const base = endpoint.replace(/^(wss|ws|https?):\/\//i, "").replace(/^\/+/, "").split("/")[0] ?? endpoint;
+  const scheme = /^wss?:\/\//i.test(endpoint) ? endpoint.startsWith("wss") ? "wss" : "ws" : "wss";
+  return `${scheme}://${base.replace(/\/+$/, "")}`;
+}
+
+// src/opusUtils.ts
+function parseOpusPacketBoundaries(buffer) {
+  if (buffer.length < 1) return null;
+  const toc = buffer[0];
+  const c = toc & 3;
+  const tocSingle = toc & 252 | 0;
+  if (c === 0) {
+    return { frames: [buffer.slice()], consumed: buffer.length };
+  }
+  if (c === 1) {
+    if (buffer.length < 2) return null;
+    const L1 = buffer[1] + 1;
+    if (buffer.length < 2 + L1) return null;
+    const L2 = buffer.length - 2 - L1;
+    const frame0 = new Uint8Array(1 + L1);
+    frame0[0] = tocSingle;
+    frame0.set(buffer.subarray(2, 2 + L1), 1);
+    const frame1 = new Uint8Array(1 + L2);
+    frame1[0] = tocSingle;
+    frame1.set(buffer.subarray(2 + L1), 1);
+    return { frames: [frame0, frame1], consumed: buffer.length };
+  }
+  if (c === 2) {
+    if (buffer.length < 3) return null;
+    const frameLen = Math.floor((buffer.length - 2) / 2);
+    if (frameLen < 1) return null;
+    const frame0 = new Uint8Array(1 + frameLen);
+    frame0[0] = tocSingle;
+    frame0.set(buffer.subarray(2, 2 + frameLen), 1);
+    const frame1 = new Uint8Array(1 + frameLen);
+    frame1[0] = tocSingle;
+    frame1.set(buffer.subarray(2 + frameLen, 2 + 2 * frameLen), 1);
+    return { frames: [frame0, frame1], consumed: 2 + 2 * frameLen };
+  }
+  if (c === 3) {
+    if (buffer.length < 2) return null;
+    const N = buffer[1];
+    if (N < 1 || N > 255) return null;
+    const numLengthBytes = N - 1;
+    if (buffer.length < 2 + numLengthBytes) return null;
+    const lengths = [];
+    for (let i = 0; i < numLengthBytes; i++) {
+      lengths.push(buffer[2 + i] + 1);
+    }
+    const headerLen = 2 + numLengthBytes;
+    let offset = headerLen;
+    const sumKnown = lengths.reduce((a, b) => a + b, 0);
+    const lastLen = buffer.length - headerLen - sumKnown;
+    if (lastLen < 0) return null;
+    lengths.push(lastLen);
+    const frames = [];
+    for (let i = 0; i < lengths.length; i++) {
+      const L = lengths[i];
+      if (offset + L > buffer.length) return null;
+      const frame = new Uint8Array(1 + L);
+      frame[0] = tocSingle;
+      frame.set(buffer.subarray(offset, offset + L), 1);
+      frames.push(frame);
+      offset += L;
+    }
+    return { frames, consumed: offset };
+  }
+  return null;
+}
+function concatUint8Arrays(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a);
+  out.set(b, a.length);
+  return out;
+}
+
+// src/LiveKitRtcConnection.ts
+var SAMPLE_RATE = 48e3;
+var CHANNELS2 = 1;
+var FRAME_SAMPLES = 480;
+var VOICE_DEBUG = process.env.VOICE_DEBUG === "1" || process.env.VOICE_DEBUG === "true";
+var LiveKitRtcConnection = class extends EventEmitter2 {
+  client;
+  channel;
+  guildId;
+  _playing = false;
+  _destroyed = false;
+  room = null;
+  audioSource = null;
+  audioTrack = null;
+  currentStream = null;
+  lastServerEndpoint = null;
+  lastServerToken = null;
+  _disconnectEmitted = false;
+  constructor(client, channel, _userId) {
+    super();
+    this.client = client;
+    this.channel = channel;
+    this.guildId = channel.guildId;
+  }
+  get playing() {
+    return this._playing;
+  }
+  debug(msg, data) {
+    console.error("[voice LiveKitRtc]", msg, data ?? "");
+  }
+  audioDebug(msg, data) {
+    if (VOICE_DEBUG) {
+      console.error("[voice LiveKitRtc audio]", msg, data ?? "");
+    }
+  }
+  emitDisconnect(source) {
+    if (this._disconnectEmitted) return;
+    this._disconnectEmitted = true;
+    this.debug("emitting disconnect", { source });
+    this.emit("disconnect");
+  }
+  /** Returns true if the LiveKit room is connected and not destroyed. */
+  isConnected() {
+    return !this._destroyed && this.room != null && this.room.isConnected;
+  }
+  /** Returns true if we're already connected to the given server (skip migration). */
+  isSameServer(endpoint, token) {
+    const ep = (endpoint ?? "").trim();
+    return ep === (this.lastServerEndpoint ?? "") && token === (this.lastServerToken ?? "");
+  }
+  playOpus(_stream) {
+    this.emit("error", new Error("LiveKit: playOpus not supported; use play(url) with a WebM/Opus URL"));
+  }
+  async connect(server, _state) {
+    const raw = (server.endpoint ?? "").trim();
+    const token = server.token;
+    if (!raw || !token) {
+      this.emit("error", new Error("Missing voice server endpoint or token"));
+      return;
+    }
+    const url = buildLiveKitUrlForRtcSdk(raw);
+    this._disconnectEmitted = false;
+    try {
+      const room = new Room();
+      this.room = room;
+      room.on(RoomEvent.Disconnected, () => {
+        this.debug("Room disconnected");
+        this.lastServerEndpoint = null;
+        this.lastServerToken = null;
+        setImmediate(() => this.emit("serverLeave"));
+        this.emitDisconnect("room_disconnected");
+      });
+      room.on(RoomEvent.Reconnecting, () => {
+        this.debug("Room reconnecting");
+      });
+      room.on(RoomEvent.Reconnected, () => {
+        this.debug("Room reconnected");
+      });
+      await room.connect(url, token, { autoSubscribe: false, dynacast: false });
+      this.lastServerEndpoint = raw;
+      this.lastServerToken = token;
+      this.debug("connected to room");
+      this.emit("ready");
+    } catch (e) {
+      this.room = null;
+      const err = e instanceof Error ? e : new Error(String(e));
+      this.emit("error", err);
+      throw err;
+    }
+  }
+  async play(urlOrStream) {
+    this.stop();
+    if (!this.room || !this.room.isConnected) {
+      this.emit("error", new Error("LiveKit: not connected"));
+      return;
+    }
+    const { opus: prismOpus } = await import("prism-media");
+    const { Readable } = await import("stream");
+    const { OpusDecoder } = await import("opus-decoder");
+    let inputStream;
+    if (typeof urlOrStream === "string") {
+      try {
+        const response = await fetch(urlOrStream);
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        if (!response.body) throw new Error("No response body");
+        inputStream = Readable.fromWeb(response.body);
+      } catch (e) {
+        this.emit("error", e instanceof Error ? e : new Error(String(e)));
+        return;
+      }
+    } else {
+      inputStream = urlOrStream;
+    }
+    const source = new AudioSource(SAMPLE_RATE, CHANNELS2);
+    this.audioSource = source;
+    const track = LocalAudioTrack.createAudioTrack("audio", source);
+    this.audioTrack = track;
+    const options = new TrackPublishOptions();
+    options.source = TrackSource.SOURCE_MICROPHONE;
+    await this.room.localParticipant.publishTrack(track, options);
+    const demuxer = new prismOpus.WebmDemuxer();
+    inputStream.pipe(demuxer);
+    this.currentStream = demuxer;
+    const decoder = new OpusDecoder({ sampleRate: SAMPLE_RATE, channels: CHANNELS2 });
+    await decoder.ready;
+    this._playing = true;
+    function floatToInt16(float32) {
+      const int16 = new Int16Array(float32.length);
+      for (let i = 0; i < float32.length; i++) {
+        let s = float32[i];
+        if (!Number.isFinite(s)) {
+          int16[i] = 0;
+          continue;
+        }
+        s = Math.max(-1, Math.min(1, s));
+        const scale = s < 0 ? 32768 : 32767;
+        const dither = (Math.random() + Math.random() - 1) * 0.5;
+        const scaled = Math.round(s * scale + dither);
+        int16[i] = Math.max(-32768, Math.min(32767, scaled));
+      }
+      return int16;
+    }
+    let sampleBuffer = new Int16Array(0);
+    let opusBuffer = new Uint8Array(0);
+    let streamEnded = false;
+    let framesCaptured = 0;
+    const processOneOpusFrame = async (frame) => {
+      if (frame.length < 2) return;
+      try {
+        const result = decoder.decodeFrame(frame);
+        if (!result?.channelData?.[0]?.length) return;
+        const int16 = floatToInt16(result.channelData[0]);
+        const newBuffer = new Int16Array(sampleBuffer.length + int16.length);
+        newBuffer.set(sampleBuffer);
+        newBuffer.set(int16, sampleBuffer.length);
+        sampleBuffer = newBuffer;
+        while (sampleBuffer.length >= FRAME_SAMPLES && this._playing && source) {
+          const outSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
+          sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
+          const audioFrame = new AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
+          if (source.queuedDuration > 500) {
+            await source.waitForPlayout();
+          }
+          await source.captureFrame(audioFrame);
+          framesCaptured++;
+        }
+      } catch (err) {
+        if (VOICE_DEBUG) this.audioDebug("decode error", { error: String(err) });
+      }
+    };
+    let firstChunk = true;
+    let processing = false;
+    const opusFrameQueue = [];
+    const drainOpusQueue = async () => {
+      if (processing || opusFrameQueue.length === 0) return;
+      processing = true;
+      while (opusFrameQueue.length > 0 && this._playing && source) {
+        const frame = opusFrameQueue.shift();
+        await processOneOpusFrame(frame);
+      }
+      processing = false;
+    };
+    demuxer.on("data", (chunk) => {
+      if (!this._playing) return;
+      if (firstChunk) {
+        this.audioDebug("first audio chunk received", { size: chunk.length });
+        firstChunk = false;
+      }
+      opusBuffer = concatUint8Arrays(opusBuffer, new Uint8Array(chunk));
+      while (opusBuffer.length > 0) {
+        const parsed = parseOpusPacketBoundaries(opusBuffer);
+        if (!parsed) break;
+        opusBuffer = opusBuffer.slice(parsed.consumed);
+        for (const frame of parsed.frames) {
+          opusFrameQueue.push(frame);
+        }
+      }
+      drainOpusQueue().catch((e) => this.audioDebug("drainOpusQueue error", { error: String(e) }));
+    });
+    demuxer.on("error", (err) => {
+      this.audioDebug("demuxer error", { error: err.message });
+      this._playing = false;
+      this.currentStream = null;
+      this.emit("error", err);
+    });
+    demuxer.on("end", async () => {
+      streamEnded = true;
+      this.audioDebug("stream ended", { framesCaptured });
+      while (processing || opusFrameQueue.length > 0) {
+        await drainOpusQueue();
+        await new Promise((r) => setImmediate(r));
+      }
+      while (sampleBuffer.length >= FRAME_SAMPLES && this._playing && source) {
+        const outSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
+        sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
+        const audioFrame = new AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
+        await source.captureFrame(audioFrame);
+        framesCaptured++;
+      }
+      if (sampleBuffer.length > 0 && this._playing && source) {
+        const padded = new Int16Array(FRAME_SAMPLES);
+        padded.set(sampleBuffer);
+        const audioFrame = new AudioFrame(padded, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
+        await source.captureFrame(audioFrame);
+        framesCaptured++;
+      }
+      this.audioDebug("playback complete", { framesCaptured });
+      this._playing = false;
+      this.currentStream = null;
+      if (this.audioTrack) {
+        await this.audioTrack.close();
+        this.audioTrack = null;
+      }
+      if (this.audioSource) {
+        await this.audioSource.close();
+        this.audioSource = null;
+      }
+    });
+  }
+  stop() {
+    this._playing = false;
+    if (this.currentStream?.destroy) this.currentStream.destroy();
+    this.currentStream = null;
+    if (this.audioTrack) {
+      this.audioTrack.close().catch(() => {
+      });
+      this.audioTrack = null;
+    }
+    if (this.audioSource) {
+      this.audioSource.close().catch(() => {
+      });
+      this.audioSource = null;
+    }
+  }
+  disconnect() {
+    this._destroyed = true;
+    this.stop();
+    if (this.room) {
+      this.room.disconnect().catch(() => {
+      });
+      this.room = null;
+    }
+    this.lastServerEndpoint = null;
+    this.lastServerToken = null;
+    this.emit("disconnect");
+  }
+  destroy() {
+    this.disconnect();
+    this.removeAllListeners();
+  }
+};
+
+// src/VoiceManager.ts
+import { Collection } from "@fluxerjs/collection";
+var VoiceManager = class extends EventEmitter3 {
+  client;
+  connections = new Collection();
+  /** guild_id -> user_id -> channel_id */
+  voiceStates = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  shardId;
+  constructor(client, options = {}) {
+    super();
+    this.client = client;
+    this.shardId = options.shardId ?? 0;
+    this.client.on(Events.VoiceStateUpdate, (data) => this.handleVoiceStateUpdate(data));
+    this.client.on(Events.VoiceServerUpdate, (data) => this.handleVoiceServerUpdate(data));
+    this.client.on(Events.VoiceStatesSync, (data) => this.handleVoiceStatesSync(data));
+  }
+  handleVoiceStatesSync(data) {
+    let guildMap = this.voiceStates.get(data.guildId);
+    if (!guildMap) {
+      guildMap = /* @__PURE__ */ new Map();
+      this.voiceStates.set(data.guildId, guildMap);
+    }
+    for (const vs of data.voiceStates) {
+      guildMap.set(vs.user_id, vs.channel_id);
+    }
+  }
+  /** Get the voice channel ID the user is in, or null. */
+  getVoiceChannelId(guildId, userId) {
+    const guildMap = this.voiceStates.get(guildId);
+    if (!guildMap) return null;
+    return guildMap.get(userId) ?? null;
+  }
+  handleVoiceStateUpdate(data) {
+    const guildId = data.guild_id ?? "";
+    if (!guildId) return;
+    let guildMap = this.voiceStates.get(guildId);
+    if (!guildMap) {
+      guildMap = /* @__PURE__ */ new Map();
+      this.voiceStates.set(guildId, guildMap);
+    }
+    guildMap.set(data.user_id, data.channel_id);
+    const pending = this.pending.get(guildId);
+    if (pending && data.user_id === this.client.user?.id) {
+      pending.state = data;
+      this.tryCompletePending(guildId);
+    }
+  }
+  handleVoiceServerUpdate(data) {
+    const guildId = data.guild_id;
+    const pending = this.pending.get(guildId);
+    if (pending) {
+      pending.server = data;
+      this.tryCompletePending(guildId);
+      return;
+    }
+    const conn = this.connections.get(guildId);
+    if (!conn) return;
+    if (!data.endpoint || !data.token) {
+      this.client.emit?.("debug", `[VoiceManager] Voice server endpoint null for guild ${guildId}; disconnecting until new allocation`);
+      conn.destroy();
+      this.connections.delete(guildId);
+      return;
+    }
+    if (!isLiveKitEndpoint(data.endpoint, data.token)) return;
+    if (conn instanceof LiveKitRtcConnection && conn.isSameServer(data.endpoint, data.token)) {
+      return;
+    }
+    const channel = conn.channel;
+    this.client.emit?.("debug", `[VoiceManager] Voice server migration for guild ${guildId}; reconnecting`);
+    conn.destroy();
+    this.connections.delete(guildId);
+    const ConnClass = LiveKitRtcConnection;
+    const newConn = new ConnClass(this.client, channel, this.client.user.id);
+    this.registerConnection(guildId, newConn);
+    const state = {
+      guild_id: guildId,
+      channel_id: channel.id,
+      user_id: this.client.user.id,
+      session_id: ""
+    };
+    newConn.connect(data, state).catch((e) => {
+      this.connections.delete(guildId);
+      newConn.emit("error", e instanceof Error ? e : new Error(String(e)));
+    });
+  }
+  registerConnection(guildId, conn) {
+    this.connections.set(guildId, conn);
+    conn.once("disconnect", () => this.connections.delete(guildId));
+  }
+  tryCompletePending(guildId) {
+    const pending = this.pending.get(guildId);
+    if (!pending?.server || !pending.state) return;
+    this.pending.delete(guildId);
+    const ConnClass = isLiveKitEndpoint(pending.server.endpoint, pending.server.token) ? LiveKitRtcConnection : VoiceConnection;
+    const conn = new ConnClass(this.client, pending.channel, this.client.user.id);
+    this.registerConnection(guildId, conn);
+    conn.connect(pending.server, pending.state).then(
+      () => pending.resolve(conn),
+      (e) => pending.reject(e)
+    );
+  }
+  /** Join a voice channel. Resolves when the connection is ready. */
+  async join(channel) {
+    const existing = this.connections.get(channel.guildId);
+    if (existing) {
+      const isReusable = existing.channel.id === channel.id && (existing instanceof LiveKitRtcConnection ? existing.isConnected() : true);
+      if (isReusable) return existing;
+      existing.destroy();
+      this.connections.delete(channel.guildId);
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (this.pending.has(channel.guildId)) {
+          this.pending.delete(channel.guildId);
+          reject(new Error("Voice connection timeout"));
+        }
+      }, 15e3);
+      this.pending.set(channel.guildId, {
+        channel,
+        resolve: (c) => {
+          clearTimeout(timeout);
+          resolve(c);
+        },
+        reject: (e) => {
+          clearTimeout(timeout);
+          reject(e);
+        }
+      });
+      this.client.sendToGateway(this.shardId, {
+        op: GatewayOpcodes.VoiceStateUpdate,
+        d: {
+          guild_id: channel.guildId,
+          channel_id: channel.id,
+          self_mute: false,
+          self_deaf: false
+        }
+      });
+    });
+  }
+  /** Leave a guild's voice channel. */
+  leave(guildId) {
+    const conn = this.connections.get(guildId);
+    if (conn) {
+      conn.destroy();
+      this.connections.delete(guildId);
+    }
+    this.client.sendToGateway(this.shardId, {
+      op: GatewayOpcodes.VoiceStateUpdate,
+      d: {
+        guild_id: guildId,
+        channel_id: null,
+        self_mute: false,
+        self_deaf: false
+      }
+    });
+  }
+  getConnection(guildId) {
+    return this.connections.get(guildId);
+  }
+};
+
+// src/index.ts
+async function joinVoiceChannel(client, channel, options) {
+  const manager = getVoiceManager(client, options);
+  return manager.join(channel);
+}
+var voiceManagers = /* @__PURE__ */ new WeakMap();
+function getVoiceManager(client, options) {
+  let manager = voiceManagers.get(client);
+  if (!manager) {
+    manager = new VoiceManager(client, options);
+    voiceManagers.set(client, manager);
+  }
+  return manager;
+}
+export {
+  LiveKitRtcConnection,
+  VoiceConnection,
+  VoiceManager,
+  getVoiceManager,
+  joinVoiceChannel
+};