@fluxerjs/voice 1.1.7 → 1.1.9

package/dist/index.js

@@ -3122,11 +3122,21 @@ function floatToInt16(float32) {
   }
   return int16;
 }
+function applyVolumeToInt16(samples, volumePercent) {
+  const vol = (volumePercent ?? 100) / 100;
+  if (vol === 1) return samples;
+  const out = new Int16Array(samples.length);
+  for (let i = 0; i < samples.length; i++) {
+    out[i] = Math.max(-32768, Math.min(32767, Math.round(samples[i] * vol)));
+  }
+  return out;
+}
 var VOICE_DEBUG = process.env.VOICE_DEBUG === "1" || process.env.VOICE_DEBUG === "true";
 var LiveKitRtcConnection = class extends import_events2.EventEmitter {
   client;
   channel;
   guildId;
+  _volume = 100;
   _playing = false;
   _playingVideo = false;
   _destroyed = false;
@@ -3183,6 +3193,14 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
     const ep = (endpoint ?? "").trim();
     return ep === (this.lastServerEndpoint ?? "") && token === (this.lastServerToken ?? "");
   }
+  /** Set playback volume (0-200, 100 = normal). Affects current and future playback. */
+  setVolume(volumePercent) {
+    this._volume = Math.max(0, Math.min(200, volumePercent ?? 100));
+  }
+  /** Get current volume (0-200). */
+  getVolume() {
+    return this._volume ?? 100;
+  }
   playOpus(_stream) {
     this.emit(
       "error",
@@ -3259,7 +3277,8 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       this.emit("error", new Error("LiveKit: not connected"));
       return;
     }
-    const useFFmpeg = options?.useFFmpeg ?? process.env.FLUXER_VIDEO_FFMPEG === "1";
+    let useFFmpeg = options?.useFFmpeg ?? process.env.FLUXER_VIDEO_FFMPEG === "1";
+    if (options?.resolution) useFFmpeg = true;
     if (useFFmpeg && typeof urlOrBuffer === "string") {
       await this.playVideoFFmpeg(urlOrBuffer, options);
       return;
@@ -3656,8 +3675,9 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
                 newBuffer.set(int16, sampleBuffer.length);
                 sampleBuffer = newBuffer;
                 while (sampleBuffer.length >= FRAME_SAMPLES && this._playingVideo && audioSource) {
-                  const outSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
+                  const rawSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
                   sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
+                  const outSamples = applyVolumeToInt16(rawSamples, this._volume);
                   const audioFrame = new import_rtc_node.AudioFrame(
                     outSamples,
                     SAMPLE_RATE,
@@ -3724,6 +3744,7 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
     const loop = options?.loop ?? true;
     let width = 640;
     let height = 480;
+    let hasAudio = false;
     try {
       const { execFile } = await import("child_process");
       const { promisify } = await import("util");
@@ -3733,10 +3754,9 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
         [
           "-v",
           "error",
-          "-select_streams",
-          "v:0",
+          "-show_streams",
           "-show_entries",
-          "stream=width,height",
+          "stream=codec_type,width,height",
           "-of",
           "json",
           url
@@ -3744,10 +3764,19 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
         { encoding: "utf8", timeout: 1e4 }
       );
       const parsed = JSON.parse(stdout);
-      const stream = parsed?.streams?.[0];
-      if (stream?.width && stream?.height) {
-        width = stream.width;
-        height = stream.height;
+      const streams = parsed?.streams ?? [];
+      for (const s of streams) {
+        if (s.codec_type === "video" && s.width != null && s.height != null) {
+          width = s.width;
+          height = s.height;
+          break;
+        }
+      }
+      for (const s of streams) {
+        if (s.codec_type === "audio") {
+          hasAudio = true;
+          break;
+        }
       }
     } catch (probeErr) {
       this.emit(
@@ -3758,7 +3787,29 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       );
       return;
     }
-    if (options?.width && options?.height) {
+    let maxFps = options?.maxFramerate ?? 60;
+    const res = options?.resolution;
+    if (res === "480p") {
+      width = 854;
+      height = 480;
+      maxFps = 60;
+    } else if (res === "720p") {
+      width = 1280;
+      height = 720;
+      maxFps = 60;
+    } else if (res === "1080p") {
+      width = 1920;
+      height = 1080;
+      maxFps = 60;
+    } else if (res === "1440p") {
+      width = 2560;
+      height = 1440;
+      maxFps = 60;
+    } else if (res === "4k") {
+      width = 3840;
+      height = 2160;
+      maxFps = 60;
+    } else if (options?.width != null && options?.height != null) {
       width = options.width;
       height = options.height;
     }
@@ -3770,7 +3821,7 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       source: sourceOption === "screenshare" ? import_rtc_node.TrackSource.SOURCE_SCREENSHARE : import_rtc_node.TrackSource.SOURCE_CAMERA,
       videoEncoding: {
         maxBitrate: BigInt(options?.videoBitrate ?? 25e5),
-        maxFramerate: options?.maxFramerate ?? 60
+        maxFramerate: maxFps
       }
     });
     const participant = this.room?.localParticipant;
@@ -3781,24 +3832,29 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       this.emit("error", err instanceof Error ? err : new Error(String(err)));
       return;
     }
-    let audioFfmpegProc = null;
-    const audioSource = new import_rtc_node.AudioSource(SAMPLE_RATE, CHANNELS2);
-    const audioTrack = import_rtc_node.LocalAudioTrack.createAudioTrack(
-      "audio",
-      audioSource
-    );
-    this.audioSource = audioSource;
-    this.audioTrack = audioTrack;
-    try {
-      await participant.publishTrack(
-        audioTrack,
-        new import_rtc_node.TrackPublishOptions({ source: import_rtc_node.TrackSource.SOURCE_MICROPHONE })
-      );
-    } catch {
-      audioTrack.close().catch(() => {
-      });
-      this.audioTrack = null;
+    let audioSource = null;
+    let audioReady = false;
+    if (hasAudio) {
+      const src = new import_rtc_node.AudioSource(SAMPLE_RATE, CHANNELS2);
+      audioSource = src;
+      this.audioSource = src;
+      const track2 = import_rtc_node.LocalAudioTrack.createAudioTrack("audio", src);
+      this.audioTrack = track2;
+      try {
+        await participant.publishTrack(
+          track2,
+          new import_rtc_node.TrackPublishOptions({ source: import_rtc_node.TrackSource.SOURCE_MICROPHONE })
+        );
+        audioReady = true;
+      } catch {
+        track2.close().catch(() => {
+        });
+        this.audioTrack = null;
+        this.audioSource = null;
+      }
+    } else {
       this.audioSource = null;
+      this.audioTrack = null;
     }
     this._playingVideo = true;
     this.emit("requestVoiceStateSync", {
@@ -3806,7 +3862,6 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       self_video: sourceOption === "camera"
     });
     const frameSize = Math.ceil(width * height * 3 / 2);
-    const maxFps = options?.maxFramerate ?? 60;
     const FRAME_INTERVAL_MS = Math.round(1e3 / maxFps);
     let pacingTimeout = null;
     let ffmpegProc = null;
@@ -3824,10 +3879,6 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
         ffmpegProc.kill("SIGKILL");
         ffmpegProc = null;
       }
-      if (audioFfmpegProc && !audioFfmpegProc.killed) {
-        audioFfmpegProc.kill("SIGKILL");
-        audioFfmpegProc = null;
-      }
       this.emit("requestVoiceStateSync", { self_stream: false, self_video: false });
       this.currentVideoStream = null;
       if (this.audioTrack) {
@@ -3912,32 +3963,38 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       pacingTimeout = setTimeout(scheduleNextPacing, FRAME_INTERVAL_MS);
     };
     scheduleNextPacing();
-    const runFFmpeg = () => {
+    const runFFmpeg = async () => {
       const ffmpegArgs = [
         "-loglevel",
         "warning",
         "-re",
+        ...loop ? ["-stream_loop", "-1"] : [],
         "-i",
         url,
+        "-map",
+        "0:v",
+        "-vf",
+        `scale=${width}:${height}`,
+        "-r",
+        String(maxFps),
         "-f",
         "rawvideo",
         "-pix_fmt",
         "yuv420p",
-        "-r",
-        String(maxFps)
+        "-an",
+        "pipe:1",
+        ...hasAudio ? ["-map", "0:a", "-c:a", "libopus", "-f", "webm", "-vn", "pipe:3"] : []
       ];
-      if (options?.width && options?.height) {
-        ffmpegArgs.splice(ffmpegArgs.indexOf("-f"), 0, "-vf", `scale=${width}:${height}`);
-      }
-      ffmpegArgs.push("-");
-      ffmpegProc = (0, import_node_child_process.spawn)("ffmpeg", ffmpegArgs, { stdio: ["ignore", "pipe", "pipe"] });
+      const stdioOpts = hasAudio ? ["ignore", "pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"];
+      const proc = (0, import_node_child_process.spawn)("ffmpeg", ffmpegArgs, { stdio: stdioOpts });
+      ffmpegProc = proc;
       this.currentVideoStream = {
         destroy: () => {
-          if (ffmpegProc && !ffmpegProc.killed) ffmpegProc.kill("SIGKILL");
+          if (proc && !proc.killed) proc.kill("SIGKILL");
         }
       };
-      const stdout = ffmpegProc.stdout;
-      const stderr = ffmpegProc.stderr;
+      const stdout = proc.stdout;
+      const stderr = proc.stderr;
       if (stdout) {
         stdout.on("data", (chunk) => {
           if (!this._playingVideo || cleanupCalled) return;
@@ -3951,105 +4008,79 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
           if (line && VOICE_DEBUG) this.audioDebug("ffmpeg stderr", { line: line.slice(0, 200) });
         });
       }
-      ffmpegProc.on("error", (err) => {
+      if (hasAudio && audioReady && audioSource && proc.stdio[3]) {
+        const audioPipe = proc.stdio[3];
+        const { opus: prismOpus } = await import("prism-media");
+        const { OpusDecoder } = await import("opus-decoder");
+        const demuxer = new prismOpus.WebmDemuxer();
+        audioPipe.pipe(demuxer);
+        const decoder = new OpusDecoder({ sampleRate: SAMPLE_RATE, channels: CHANNELS2 });
+        await decoder.ready;
+        let sampleBuffer = new Int16Array(0);
+        let opusBuffer = new Uint8Array(0);
+        let processing = false;
+        const opusFrameQueue = [];
+        const processOneOpusFrame = async (frame) => {
+          if (frame.length < 2 || !audioSource || !this._playingVideo) 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._playingVideo && audioSource) {
+              const rawSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
+              sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
+              const outSamples = applyVolumeToInt16(rawSamples, this._volume);
+              const audioFrame = new import_rtc_node.AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
+              if (audioSource.queuedDuration > 500) await audioSource.waitForPlayout();
+              await audioSource.captureFrame(audioFrame);
+            }
+          } catch {
+          }
+        };
+        const drainQueue = async () => {
+          if (processing || opusFrameQueue.length === 0) return;
+          processing = true;
+          while (opusFrameQueue.length > 0 && this._playingVideo && audioSource) {
+            const f = opusFrameQueue.shift();
+            await processOneOpusFrame(f);
+          }
+          processing = false;
+        };
+        demuxer.on("data", (chunk) => {
+          if (!this._playingVideo) return;
+          opusBuffer = new Uint8Array(concatUint8Arrays(opusBuffer, new Uint8Array(chunk)));
+          while (opusBuffer.length > 0) {
+            const parsed = parseOpusPacketBoundaries(opusBuffer);
+            if (!parsed) break;
+            opusBuffer = new Uint8Array(opusBuffer.subarray(parsed.consumed));
+            for (const frame of parsed.frames) opusFrameQueue.push(frame);
+          }
+          drainQueue().catch(() => {
+          });
+        });
+      }
+      proc.on("error", (err) => {
         this.emit("error", err);
         doCleanup();
       });
-      ffmpegProc.on("exit", (code) => {
+      proc.on("exit", (code) => {
         ffmpegProc = null;
         if (cleanupCalled || !this._playingVideo) return;
         if (loop && (code === 0 || code === null)) {
           frameBuffer.length = 0;
           frameBufferBytes = 0;
           frameIndex = 0n;
-          setImmediate(runFFmpeg);
+          setImmediate(() => runFFmpeg());
         } else {
           doCleanup();
         }
       });
     };
-    runFFmpeg();
-    const runAudioFfmpeg = async () => {
-      if (!this._playingVideo || cleanupCalled || !audioSource) return;
-      const audioProc = (0, import_node_child_process.spawn)(
-        "ffmpeg",
-        [
-          "-loglevel",
-          "warning",
-          "-re",
-          "-i",
-          url,
-          "-vn",
-          "-c:a",
-          "libopus",
-          "-f",
-          "webm",
-          ...loop ? ["-stream_loop", "-1"] : [],
-          "pipe:1"
-        ],
-        { stdio: ["ignore", "pipe", "pipe"] }
-      );
-      audioFfmpegProc = audioProc;
-      const { opus: prismOpus } = await import("prism-media");
-      const { OpusDecoder } = await import("opus-decoder");
-      const demuxer = new prismOpus.WebmDemuxer();
-      if (audioProc.stdout) audioProc.stdout.pipe(demuxer);
-      const decoder = new OpusDecoder({ sampleRate: SAMPLE_RATE, channels: CHANNELS2 });
-      await decoder.ready;
-      let sampleBuffer = new Int16Array(0);
-      let opusBuffer = new Uint8Array(0);
-      let processing = false;
-      const opusFrameQueue = [];
-      const processOneOpusFrame = async (frame) => {
-        if (frame.length < 2 || !audioSource || !this._playingVideo) 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._playingVideo && audioSource) {
-            const outSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
-            sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
-            const audioFrame = new import_rtc_node.AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
-            if (audioSource.queuedDuration > 500) await audioSource.waitForPlayout();
-            await audioSource.captureFrame(audioFrame);
-          }
-        } catch {
-        }
-      };
-      const drainQueue = async () => {
-        if (processing || opusFrameQueue.length === 0) return;
-        processing = true;
-        while (opusFrameQueue.length > 0 && this._playingVideo && audioSource) {
-          const f = opusFrameQueue.shift();
-          await processOneOpusFrame(f);
-        }
-        processing = false;
-      };
-      demuxer.on("data", (chunk) => {
-        if (!this._playingVideo) return;
-        opusBuffer = new Uint8Array(concatUint8Arrays(opusBuffer, new Uint8Array(chunk)));
-        while (opusBuffer.length > 0) {
-          const parsed = parseOpusPacketBoundaries(opusBuffer);
-          if (!parsed) break;
-          opusBuffer = new Uint8Array(opusBuffer.subarray(parsed.consumed));
-          for (const frame of parsed.frames) opusFrameQueue.push(frame);
-        }
-        drainQueue().catch(() => {
-        });
-      });
-      audioProc.on("exit", (code) => {
-        if (audioFfmpegProc === audioProc) audioFfmpegProc = null;
-        if (loop && this._playingVideo && !cleanupCalled && (code === 0 || code === null)) {
-          setImmediate(() => runAudioFfmpeg());
-        }
-      });
-    };
-    runAudioFfmpeg().catch(() => {
-    });
+    runFFmpeg().catch((e) => this.audioDebug("ffmpeg error", { error: String(e) }));
   }
   /**
    * Play audio from a WebM/Opus URL or readable stream. Publishes to the LiveKit room as an audio track.
@@ -4108,8 +4139,9 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
         newBuffer.set(int16, sampleBuffer.length);
         sampleBuffer = newBuffer;
         while (sampleBuffer.length >= FRAME_SAMPLES && this._playing && source) {
-          const outSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
+          const rawSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
           sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
+          const outSamples = applyVolumeToInt16(rawSamples, this._volume);
           const audioFrame = new import_rtc_node.AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
           if (source.queuedDuration > 500) {
             await source.waitForPlayout();
@@ -4164,8 +4196,9 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
         await new Promise((r) => setImmediate(r));
       }
       while (sampleBuffer.length >= FRAME_SAMPLES && this._playing && source) {
-        const outSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
+        const rawSamples = sampleBuffer.subarray(0, FRAME_SAMPLES);
         sampleBuffer = sampleBuffer.subarray(FRAME_SAMPLES).slice();
+        const outSamples = applyVolumeToInt16(rawSamples, this._volume);
         const audioFrame = new import_rtc_node.AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
         await source.captureFrame(audioFrame);
         framesCaptured++;
@@ -4173,7 +4206,8 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
       if (sampleBuffer.length > 0 && this._playing && source) {
         const padded = new Int16Array(FRAME_SAMPLES);
         padded.set(sampleBuffer);
-        const audioFrame = new import_rtc_node.AudioFrame(padded, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
+        const outSamples = applyVolumeToInt16(padded, this._volume);
+        const audioFrame = new import_rtc_node.AudioFrame(outSamples, SAMPLE_RATE, CHANNELS2, FRAME_SAMPLES);
         await source.captureFrame(audioFrame);
         framesCaptured++;
       }
@@ -4263,11 +4297,13 @@ var LiveKitRtcConnection = class extends import_events2.EventEmitter {
 var import_collection = require("@fluxerjs/collection");
 var VoiceManager = class extends import_events3.EventEmitter {
   client;
+  /** channel_id -> connection (Fluxer multi-channel: allows multiple connections per guild) */
   connections = new import_collection.Collection();
-  /** guild_id -> connection_id (from VoiceServerUpdate; required for voice state updates when in channel) */
+  /** channel_id -> connection_id (from VoiceServerUpdate; required for voice state updates) */
   connectionIds = /* @__PURE__ */ new Map();
   /** guild_id -> user_id -> channel_id */
   voiceStates = /* @__PURE__ */ new Map();
+  /** channel_id -> pending join */
   pending = /* @__PURE__ */ new Map();
   shardId;
   constructor(client, options = {}) {
@@ -4320,31 +4356,43 @@ var VoiceManager = class extends import_events3.EventEmitter {
       this.voiceStates.set(guildId, guildMap);
     }
     guildMap.set(data.user_id, data.channel_id);
-    const pending = this.pending.get(guildId);
+    const channelKey = data.channel_id ?? guildId;
+    const pendingByChannel = this.pending.get(channelKey);
+    const pendingByGuild = this.pending.get(guildId);
+    const pending = pendingByChannel ?? pendingByGuild;
     const isBot = String(data.user_id) === String(this.client.user?.id);
     if (isBot && data.connection_id) {
-      this.storeConnectionId(guildId, data.connection_id);
+      this.storeConnectionId(channelKey, data.connection_id);
     }
     if (pending && isBot) {
       this.client.emit?.(
         "debug",
-        `[VoiceManager] VoiceStateUpdate for bot - completing pending guild ${guildId}`
+        `[VoiceManager] VoiceStateUpdate for bot - completing pending channel ${channelKey}`
       );
       pending.state = data;
-      this.tryCompletePending(guildId);
+      this.tryCompletePending(pendingByChannel ? channelKey : guildId, pending);
     }
   }
   handleVoiceServerUpdate(data) {
     const guildId = data.guild_id;
-    const pending = this.pending.get(guildId);
+    let pending = this.pending.get(guildId);
+    if (!pending) {
+      for (const [, p] of this.pending) {
+        if (p.channel?.guildId === guildId) {
+          pending = p;
+          break;
+        }
+      }
+    }
     if (pending) {
+      const channelKey = pending.channel?.id ?? guildId;
       const hasToken = !!(data.token && data.token.length > 0);
       this.client.emit?.(
         "debug",
-        `[VoiceManager] VoiceServerUpdate guild=${guildId} endpoint=${data.endpoint ?? "null"} token=${hasToken ? "yes" : "NO"}`
+        `[VoiceManager] VoiceServerUpdate guild=${guildId} channel=${channelKey} endpoint=${data.endpoint ?? "null"} token=${hasToken ? "yes" : "NO"}`
       );
       pending.server = data;
-      this.tryCompletePending(guildId);
+      this.tryCompletePending(channelKey, pending);
       return;
     }
     const userId = this.client.user?.id;
@@ -4355,15 +4403,21 @@ var VoiceManager = class extends import_events3.EventEmitter {
       );
       return;
     }
-    const conn = this.connections.get(guildId);
+    let conn;
+    for (const [, c] of this.connections) {
+      if (c?.channel?.guildId === guildId) {
+        conn = c;
+        break;
+      }
+    }
     if (!conn) return;
     if (!data.endpoint || !data.token) {
       this.client.emit?.(
         "debug",
-        `[VoiceManager] Voice server endpoint null for guild ${guildId}; disconnecting until new allocation`
+        `[VoiceManager] Voice server endpoint null for guild ${guildId}; disconnecting`
       );
       conn.destroy();
-      this.connections.delete(guildId);
+      this.connections.delete(conn.channel.id);
       return;
     }
     if (!isLiveKitEndpoint(data.endpoint, data.token)) return;
@@ -4373,14 +4427,15 @@ var VoiceManager = class extends import_events3.EventEmitter {
     const channel = conn.channel;
     this.client.emit?.(
       "debug",
-      `[VoiceManager] Voice server migration for guild ${guildId}; reconnecting`
+      `[VoiceManager] Voice server migration for guild ${guildId} channel ${channel.id}; reconnecting`
     );
     conn.destroy();
-    this.connections.delete(guildId);
-    this.storeConnectionId(guildId, data.connection_id);
+    this.connections.delete(channel.id);
+    this.connectionIds.delete(channel.id);
+    this.storeConnectionId(channel.id, data.connection_id);
     const ConnClass = LiveKitRtcConnection;
     const newConn = new ConnClass(this.client, channel, userId);
-    this.registerConnection(guildId, newConn);
+    this.registerConnection(channel.id, newConn);
     const state = {
       guild_id: guildId,
       channel_id: channel.id,
@@ -4388,42 +4443,43 @@ var VoiceManager = class extends import_events3.EventEmitter {
       session_id: ""
     };
     newConn.connect(data, state).catch((e) => {
-      this.connections.delete(guildId);
+      this.connections.delete(channel.id);
       newConn.emit("error", e instanceof Error ? e : new Error(String(e)));
     });
   }
-  storeConnectionId(guildId, connectionId) {
+  storeConnectionId(channelId, connectionId) {
     const id = connectionId != null ? String(connectionId) : null;
-    if (id) this.connectionIds.set(guildId, id);
-    else this.connectionIds.delete(guildId);
+    if (id) this.connectionIds.set(channelId, id);
+    else this.connectionIds.delete(channelId);
   }
-  registerConnection(guildId, conn) {
-    this.connections.set(guildId, conn);
+  registerConnection(channelId, conn) {
+    const cid = conn.channel?.id ?? channelId;
+    this.connections.set(cid, conn);
     conn.once("disconnect", () => {
-      this.connections.delete(guildId);
-      this.connectionIds.delete(guildId);
+      this.connections.delete(cid);
+      this.connectionIds.delete(cid);
     });
     conn.on("requestVoiceStateSync", (p) => {
-      this.updateVoiceState(guildId, p);
+      this.updateVoiceState(cid, p);
       if (p.self_stream) {
-        this.uploadStreamPreview(guildId, conn).catch(
+        this.uploadStreamPreview(cid, conn).catch(
           (e) => this.client.emit?.("debug", `[VoiceManager] Stream preview upload failed: ${String(e)}`)
         );
       }
     });
   }
   /** Upload a placeholder stream preview so the preview URL returns 200 instead of 404. */
-  async uploadStreamPreview(guildId, conn) {
-    const connectionId = this.connectionIds.get(guildId);
+  async uploadStreamPreview(channelId, conn) {
+    const cid = conn.channel?.id ?? channelId;
+    const connectionId = this.connectionIds.get(cid);
     if (!connectionId) return;
-    const streamKey = `${guildId}:${conn.channel.id}:${connectionId}`;
+    const streamKey = `${conn.channel.guildId}:${conn.channel.id}:${connectionId}`;
     const route = import_types.Routes.streamPreview(streamKey);
     const body = { channel_id: conn.channel.id, thumbnail, content_type: "image/png" };
     await this.client.rest.post(route, { body, auth: true });
     this.client.emit?.("debug", `[VoiceManager] Uploaded stream preview for ${streamKey}`);
   }
-  tryCompletePending(guildId) {
-    const pending = this.pending.get(guildId);
+  tryCompletePending(channelId, pending) {
     if (!pending?.server) return;
     const useLiveKit = isLiveKitEndpoint(pending.server.endpoint, pending.server.token);
     const hasState = !!pending.state;
@@ -4442,6 +4498,7 @@ var VoiceManager = class extends import_events3.EventEmitter {
       );
       return;
     }
+    const guildId = pending.channel?.guildId ?? "";
     const state = pending.state ?? {
       guild_id: guildId,
       channel_id: pending.channel.id,
@@ -4449,13 +4506,13 @@ var VoiceManager = class extends import_events3.EventEmitter {
       session_id: ""
     };
     this.storeConnectionId(
-      guildId,
+      channelId,
       pending.server.connection_id ?? state.connection_id
     );
-    this.pending.delete(guildId);
+    this.pending.delete(channelId);
     const ConnClass = useLiveKit ? LiveKitRtcConnection : VoiceConnection;
     const conn = new ConnClass(this.client, pending.channel, userId);
-    this.registerConnection(guildId, conn);
+    this.registerConnection(channelId, conn);
     conn.connect(pending.server, state).then(
       () => pending.resolve(conn),
       (e) => pending.reject(e)
@@ -4463,25 +4520,27 @@ var VoiceManager = class extends import_events3.EventEmitter {
   }
   /**
    * Join a voice channel. Resolves when the connection is ready.
+   * Supports multiple connections per guild (Fluxer multi-channel).
    * @param channel - The voice channel to join
    * @returns The voice connection (LiveKitRtcConnection when Fluxer uses LiveKit)
    */
   async join(channel) {
-    const existing = this.connections.get(channel.guildId);
+    const channelId = channel.id;
+    const existing = this.connections.get(channelId);
     if (existing) {
-      const isReusable = existing.channel.id === channel.id && (existing instanceof LiveKitRtcConnection ? existing.isConnected() : true);
+      const isReusable = existing instanceof LiveKitRtcConnection ? existing.isConnected() : true;
       if (isReusable) return existing;
       existing.destroy();
-      this.connections.delete(channel.guildId);
+      this.connections.delete(channelId);
     }
     return new Promise((resolve, reject) => {
       this.client.emit?.(
         "debug",
-        `[VoiceManager] Requesting voice join guild=${channel.guildId} channel=${channel.id}`
+        `[VoiceManager] Requesting voice join guild=${channel.guildId} channel=${channelId}`
       );
       const timeout = setTimeout(() => {
-        if (this.pending.has(channel.guildId)) {
-          this.pending.delete(channel.guildId);
+        if (this.pending.has(channelId)) {
+          this.pending.delete(channelId);
           reject(
             new Error(
               "Voice connection timeout. Ensure the server has voice enabled and the bot has Connect permissions. The gateway must send VoiceServerUpdate and VoiceStateUpdate in response."
@@ -4489,7 +4548,7 @@ var VoiceManager = class extends import_events3.EventEmitter {
           );
         }
       }, 2e4);
-      this.pending.set(channel.guildId, {
+      this.pending.set(channelId, {
         channel,
         resolve: (c) => {
           clearTimeout(timeout);
@@ -4512,56 +4571,92 @@ var VoiceManager = class extends import_events3.EventEmitter {
     });
   }
   /**
-   * Leave a guild's voice channel and disconnect.
+   * Leave all voice channels in a guild.
+   * With multi-channel support, disconnects from every channel in the guild.
    * @param guildId - Guild ID to leave
    */
   leave(guildId) {
-    const conn = this.connections.get(guildId);
-    if (conn) {
+    const toLeave = [];
+    for (const [cid, c] of this.connections) {
+      if (c?.channel?.guildId === guildId) toLeave.push({ channelId: cid, conn: c });
+    }
+    for (const { channelId, conn } of toLeave) {
       conn.destroy();
-      this.connections.delete(guildId);
-      this.connectionIds.delete(guildId);
+      this.connections.delete(channelId);
+      this.connectionIds.delete(channelId);
     }
-    this.client.sendToGateway(this.shardId, {
-      op: import_types.GatewayOpcodes.VoiceStateUpdate,
-      d: {
-        guild_id: guildId,
-        channel_id: null,
-        self_mute: false,
-        self_deaf: false
+    if (toLeave.length > 0) {
+      this.client.sendToGateway(this.shardId, {
+        op: import_types.GatewayOpcodes.VoiceStateUpdate,
+        d: {
+          guild_id: guildId,
+          channel_id: null,
+          self_mute: false,
+          self_deaf: false
+        }
+      });
+    }
+  }
+  /**
+   * Leave a specific voice channel by channel ID.
+   * @param channelId - Channel ID to leave
+   */
+  leaveChannel(channelId) {
+    const conn = this.connections.get(channelId);
+    if (conn) {
+      const guildId = conn.channel?.guildId;
+      conn.destroy();
+      this.connections.delete(channelId);
+      this.connectionIds.delete(channelId);
+      if (guildId) {
+        this.client.sendToGateway(this.shardId, {
+          op: import_types.GatewayOpcodes.VoiceStateUpdate,
+          d: {
+            guild_id: guildId,
+            channel_id: null,
+            self_mute: false,
+            self_deaf: false
+          }
+        });
       }
-    });
+    }
   }
   /**
-   * Get the active voice connection for a guild, if any.
-   * @param guildId - Guild ID to look up
+   * Get the active voice connection for a channel or guild.
+   * @param channelOrGuildId - Channel ID (primary) or guild ID (returns first connection in that guild)
    */
-  getConnection(guildId) {
-    return this.connections.get(guildId);
+  getConnection(channelOrGuildId) {
+    const byChannel = this.connections.get(channelOrGuildId);
+    if (byChannel) return byChannel;
+    for (const [, c] of this.connections) {
+      if (c?.channel?.guildId === channelOrGuildId) return c;
+    }
+    return void 0;
   }
   /**
    * Update voice state (e.g. self_stream, self_video) while in a channel.
    * Sends a VoiceStateUpdate to the gateway so the server and clients see the change.
    * Requires connection_id (from VoiceServerUpdate); without it, the gateway would treat
    * the update as a new join and trigger a new VoiceServerUpdate, causing connection loops.
-   * @param guildId - Guild ID
+   * @param channelId - Channel ID (connection key)
    * @param partial - Partial voice state to update (self_stream, self_video, self_mute, self_deaf)
    */
-  updateVoiceState(guildId, partial) {
-    const conn = this.connections.get(guildId);
+  updateVoiceState(channelId, partial) {
+    const conn = this.connections.get(channelId);
     if (!conn) return;
-    const connectionId = this.connectionIds.get(guildId);
+    const connectionId = this.connectionIds.get(channelId);
+    const guildId = conn.channel?.guildId;
     if (!connectionId) {
       this.client.emit?.(
         "debug",
-        `[VoiceManager] Skipping voice state sync: no connection_id for guild ${guildId}`
+        `[VoiceManager] Skipping voice state sync: no connection_id for channel ${channelId}`
       );
       return;
     }
     this.client.sendToGateway(this.shardId, {
       op: import_types.GatewayOpcodes.VoiceStateUpdate,
       d: {
-        guild_id: guildId,
+        guild_id: guildId ?? "",
         channel_id: conn.channel.id,
         connection_id: connectionId,
         self_mute: partial.self_mute ?? false,