From aa162d88c5337a77653e90779d717f8ea8320a1c Mon Sep 17 00:00:00 2001
From: jevb <jevb@telenet.be>
Date: Fri, 20 Mar 2026 05:46:19 +0100
Subject: [PATCH] feat: replace client WebRTC with LiveKit SDK (Phase 2)

Client changes:
- Create livekitSession.ts (~400 lines, replaces 1105-line
  voiceSession.ts): Room lifecycle, device switching via
  switchActiveDevice, RNNoise pre-processing for enhanced NS
- types.ts: add VoiceTokenPayload, remove VoiceOffer/Answer/Ice
  payloads, remove ThresholdMode
- dispatcher.ts: replace voice_offer/answer/ice handlers with
  single voice_token handler
- VoiceCallbacks.ts: swap imports to livekitSession
- VoiceAudioTab.ts: remove silence suppression toggle, inline
  threshold math (removed vad.ts dependency)
- Update all files importing from deleted modules

Deleted files (11 source + 5 test):
- webrtc.ts, vad.ts, voiceSession.ts, audio.ts, video.ts,
  Soundboard.ts + their test files

Kept: noise-suppression.ts + @jitsi/rnnoise-wasm (Krisp is
LiveKit Cloud only, not available for self-hosted)

Added: livekit-client@^2.17.3

TypeScript compiles with zero errors (tsc --noEmit).
---
 Client/tauri-client/package-lock.json         |  139 ++-
 Client/tauri-client/package.json              |    3 +-
 .../src/components/ChannelSidebar.ts          |    2 +-
 .../tauri-client/src/components/Soundboard.ts |  117 --
 .../src/components/VoiceChannel.ts            |    2 +-
 .../src/components/settings/LogsTab.ts        |  142 +--
 .../src/components/settings/VoiceAudioTab.ts  |   16 +-
 Client/tauri-client/src/lib/audio.ts          |  155 ---
 Client/tauri-client/src/lib/dispatcher.ts     |   22 +-
 Client/tauri-client/src/lib/livekitSession.ts |  605 +++++++++
 Client/tauri-client/src/lib/ptt.ts            |    2 +-
 Client/tauri-client/src/lib/types.ts          |   35 +-
 Client/tauri-client/src/lib/vad.ts            |  183 ---
 Client/tauri-client/src/lib/video.ts          |  144 ---
 Client/tauri-client/src/lib/voiceSession.ts   | 1104 -----------------
 Client/tauri-client/src/lib/webrtc.ts         |  394 ------
 Client/tauri-client/src/main.ts               |    2 +-
 Client/tauri-client/src/pages/MainPage.ts     |   13 +-
 .../pages/main-page/VideoModeController.ts    |    2 +-
 .../src/pages/main-page/VoiceCallbacks.ts     |    2 +-
 Client/tauri-client/src/stores/auth.store.ts  |    2 +-
 Client/tauri-client/tests/unit/ptt.test.ts    |    8 +-
 .../tests/unit/settings-overlay.test.ts       |    2 +-
 .../tests/unit/soundboard.test.ts             |  147 ---
 Client/tauri-client/tests/unit/types.test.ts  |   10 +-
 Client/tauri-client/tests/unit/vad.test.ts    |   35 -
 .../tests/unit/video-mode-controller.test.ts  |    2 +-
 Client/tauri-client/tests/unit/video.test.ts  |  242 ----
 .../tests/unit/voice-callbacks.test.ts        |    2 +-
 .../tests/unit/voice-session-video.test.ts    |  435 -------
 Client/tauri-client/tests/unit/webrtc.test.ts |  247 ----
 31 files changed, 781 insertions(+), 3435 deletions(-)
 delete mode 100644 Client/tauri-client/src/components/Soundboard.ts
 delete mode 100644 Client/tauri-client/src/lib/audio.ts
 create mode 100644 Client/tauri-client/src/lib/livekitSession.ts
 delete mode 100644 Client/tauri-client/src/lib/vad.ts
 delete mode 100644 Client/tauri-client/src/lib/video.ts
 delete mode 100644 Client/tauri-client/src/lib/voiceSession.ts
 delete mode 100644 Client/tauri-client/src/lib/webrtc.ts
 delete mode 100644 Client/tauri-client/tests/unit/soundboard.test.ts
 delete mode 100644 Client/tauri-client/tests/unit/vad.test.ts
 delete mode 100644 Client/tauri-client/tests/unit/video.test.ts
 delete mode 100644 Client/tauri-client/tests/unit/voice-session-video.test.ts
 delete mode 100644 Client/tauri-client/tests/unit/webrtc.test.ts

diff --git a/Client/tauri-client/package-lock.json b/Client/tauri-client/package-lock.json
index f678639b..928e163e 100644
--- a/Client/tauri-client/package-lock.json
+++ b/Client/tauri-client/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "owncord-client",
-  "version": "0.1.0",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "owncord-client",
-      "version": "0.1.0",
+      "version": "1.2.0",
       "dependencies": {
         "@jitsi/rnnoise-wasm": "^0.2.1",
         "@tauri-apps/api": "^2.10.1",
@@ -18,7 +18,8 @@
         "@tauri-apps/plugin-opener": "^2.5.3",
         "@tauri-apps/plugin-process": "^2.3.1",
         "@tauri-apps/plugin-store": "^2",
-        "@tauri-apps/plugin-updater": "^2.10.0"
+        "@tauri-apps/plugin-updater": "^2.10.0",
+        "livekit-client": "^2.17.3"
       },
       "devDependencies": {
         "@playwright/test": "^1",
@@ -178,6 +179,12 @@
         "specificity": "bin/cli.js"
       }
     },
+    "node_modules/@bufbuild/protobuf": {
+      "version": "1.10.1",
+      "resolved": "https://registry.npmjs.org/@bufbuild/protobuf/-/protobuf-1.10.1.tgz",
+      "integrity": "sha512-wJ8ReQbHxsAfXhrf9ixl0aYbZorRuOWpBNzm8pL8ftmSxQx/wnJD5Eg861NwJU/czy2VXFIebCeZnZrI9rktIQ==",
+      "license": "(Apache-2.0 AND BSD-3-Clause)"
+    },
     "node_modules/@csstools/color-helpers": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.2.tgz",
@@ -850,6 +857,21 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@livekit/mutex": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@livekit/mutex/-/mutex-1.1.1.tgz",
+      "integrity": "sha512-EsshAucklmpuUAfkABPxJNhzj9v2sG7JuzFDL4ML1oJQSV14sqrpTYnsaOudMAw9yOaW53NU3QQTlUQoRs4czw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@livekit/protocol": {
+      "version": "1.44.0",
+      "resolved": "https://registry.npmjs.org/@livekit/protocol/-/protocol-1.44.0.tgz",
+      "integrity": "sha512-/vfhDUGcUKO8Q43r6i+5FrDhl5oZjm/X3U4x2Iciqvgn5C8qbj+57YPcWSJ1kyIZm5Cm6AV2nAPjMm3ETD/iyg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@bufbuild/protobuf": "^1.10.0"
+      }
+    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -1553,6 +1575,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/dom-mediacapture-record": {
+      "version": "1.0.22",
+      "resolved": "https://registry.npmjs.org/@types/dom-mediacapture-record/-/dom-mediacapture-record-1.0.22.tgz",
+      "integrity": "sha512-mUMZLK3NvwRLcAAT9qmcK+9p7tpU2FHdDsntR3YI4+GY88XrgG4XiE7u1Q2LAN2/FZOz/tdMDC3GQCR4T8nFuw==",
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -2011,6 +2040,15 @@
         "@types/estree": "^1.0.0"
       }
     },
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.x"
+      }
+    },
     "node_modules/expect-type": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
@@ -2250,6 +2288,15 @@
         "@pkgjs/parseargs": "^0.11.0"
       }
     },
+    "node_modules/jose": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.2.tgz",
+      "integrity": "sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
     "node_modules/js-tokens": {
       "version": "10.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
@@ -2308,6 +2355,39 @@
         "node": "20 || >=22"
       }
     },
+    "node_modules/livekit-client": {
+      "version": "2.17.3",
+      "resolved": "https://registry.npmjs.org/livekit-client/-/livekit-client-2.17.3.tgz",
+      "integrity": "sha512-htwsAL/BMylY/zwdcT/z00U789csbi9DldSW7DO+5tz7Q15pwu++E1X+ZdtZDfkmlysfQLLibdcqlyg9FY7veQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@livekit/mutex": "1.1.1",
+        "@livekit/protocol": "1.44.0",
+        "events": "^3.3.0",
+        "jose": "^6.1.0",
+        "loglevel": "^1.9.2",
+        "sdp-transform": "^2.15.0",
+        "tslib": "2.8.1",
+        "typed-emitter": "^2.1.0",
+        "webrtc-adapter": "^9.0.1"
+      },
+      "peerDependencies": {
+        "@types/dom-mediacapture-record": "^1"
+      }
+    },
+    "node_modules/loglevel": {
+      "version": "1.9.2",
+      "resolved": "https://registry.npmjs.org/loglevel/-/loglevel-1.9.2.tgz",
+      "integrity": "sha512-HgMmCqIJSAKqo68l0rS2AanEWfkxaZ5wNiEFb5ggm08lDs9Xl2KxBlX3PTcaD2chBM1gXAYf491/M2Rv8Jwayg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6.0"
+      },
+      "funding": {
+        "type": "tidelift",
+        "url": "https://tidelift.com/funding/github/npm/loglevel"
+      }
+    },
     "node_modules/loupe": {
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
@@ -2644,6 +2724,16 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/rxjs": {
+      "version": "7.8.2",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
+      "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
     "node_modules/saxes": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
@@ -2657,6 +2747,21 @@
         "node": ">=v12.22.7"
       }
     },
+    "node_modules/sdp": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/sdp/-/sdp-3.2.1.tgz",
+      "integrity": "sha512-lwsAIzOPlH8/7IIjjz3K0zYBk7aBVVcvjMwt3M4fLxpjMYyy7i3I97SLHebgn4YBjirkzfp3RvRDWSKsh/+WFw==",
+      "license": "MIT"
+    },
+    "node_modules/sdp-transform": {
+      "version": "2.15.0",
+      "resolved": "https://registry.npmjs.org/sdp-transform/-/sdp-transform-2.15.0.tgz",
+      "integrity": "sha512-KrOH82c/W+GYQ0LHqtr3caRpM3ITglq3ljGUIb8LTki7ByacJZ9z+piSGiwZDsRyhQbYBOBJgr2k6X4BZXi3Kw==",
+      "license": "MIT",
+      "bin": {
+        "sdp-verify": "checker.js"
+      }
+    },
     "node_modules/semver": {
       "version": "7.7.4",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
@@ -3003,6 +3108,21 @@
         "node": ">=20"
       }
     },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/typed-emitter": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/typed-emitter/-/typed-emitter-2.1.0.tgz",
+      "integrity": "sha512-g/KzbYKbH5C2vPkaXGu8DJlHrGKHLsM25Zg9WuC9pMGfuvT+X25tZQWo5fK1BjBm8+UrVE9LDCvaY0CQk+fXDA==",
+      "license": "MIT",
+      "optionalDependencies": {
+        "rxjs": "*"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
@@ -3221,6 +3341,19 @@
         "node": ">=20"
       }
     },
+    "node_modules/webrtc-adapter": {
+      "version": "9.0.4",
+      "resolved": "https://registry.npmjs.org/webrtc-adapter/-/webrtc-adapter-9.0.4.tgz",
+      "integrity": "sha512-5ZZY1+lGq8LEKuDlg9M2RPJHlH3R7OVwyHqMcUsLKCgd9Wvf+QrFTCItkXXYPmrJn8H6gRLXbSgxLLdexiqHxw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "sdp": "^3.2.0"
+      },
+      "engines": {
+        "node": ">=6.0.0",
+        "npm": ">=3.10.0"
+      }
+    },
     "node_modules/whatwg-mimetype": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
diff --git a/Client/tauri-client/package.json b/Client/tauri-client/package.json
index 6ecad5a9..812dd9f8 100644
--- a/Client/tauri-client/package.json
+++ b/Client/tauri-client/package.json
@@ -38,6 +38,7 @@
     "@tauri-apps/plugin-opener": "^2.5.3",
     "@tauri-apps/plugin-process": "^2.3.1",
     "@tauri-apps/plugin-store": "^2",
-    "@tauri-apps/plugin-updater": "^2.10.0"
+    "@tauri-apps/plugin-updater": "^2.10.0",
+    "livekit-client": "^2.17.3"
   }
 }
diff --git a/Client/tauri-client/src/components/ChannelSidebar.ts b/Client/tauri-client/src/components/ChannelSidebar.ts
index 2f3bd758..c8a5fefc 100644
--- a/Client/tauri-client/src/components/ChannelSidebar.ts
+++ b/Client/tauri-client/src/components/ChannelSidebar.ts
@@ -26,7 +26,7 @@ import {
   isCategoryCollapsed,
 } from "@stores/ui.store";
 import { voiceStore, getChannelVoiceUsers } from "@stores/voice.store";
-import { setUserVolume, getUserVolume } from "@lib/voiceSession";
+import { setUserVolume, getUserVolume } from "@lib/livekitSession";
 
 // ---------------------------------------------------------------------------
 // Per-user volume context menu (right-click on voice user row)
diff --git a/Client/tauri-client/src/components/Soundboard.ts b/Client/tauri-client/src/components/Soundboard.ts
deleted file mode 100644
index 28f1fc8e..00000000
--- a/Client/tauri-client/src/components/Soundboard.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- * Step 6.53 — Soundboard component.
- * Grid of sound buttons with cooldown enforcement (1 play per 3s).
- */
-
-import { createElement, appendChildren, setText, clearChildren } from "@lib/dom";
-import type { MountableComponent } from "@lib/safe-render";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface SoundItem {
-  readonly id: number;
-  readonly name: string;
-  readonly durationMs: number;
-}
-
-export interface SoundboardOptions {
-  readonly sounds: readonly SoundItem[];
-  readonly onPlaySound: (soundId: number) => void;
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const COOLDOWN_MS = 3_000;
-
-function formatDuration(ms: number): string {
-  return `${(ms / 1000).toFixed(1)}s`;
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createSoundboard(options: SoundboardOptions): MountableComponent {
-  let root: HTMLDivElement | null = null;
-  let cooldownTimer: ReturnType<typeof setTimeout> | null = null;
-  const ac = new AbortController();
-
-  function mount(container: Element): void {
-    root = createElement("div", { class: "soundboard" });
-
-    if (options.sounds.length === 0) {
-      const empty = createElement(
-        "div",
-        { class: "soundboard__empty" },
-        "No sounds available",
-      );
-      root.appendChild(empty);
-      container.appendChild(root);
-      return;
-    }
-
-    const grid = createElement("div", { class: "soundboard__grid" });
-    const buttons: HTMLButtonElement[] = [];
-
-    for (const sound of options.sounds) {
-      const btn = createElement("button", { class: "sound-btn", type: "button" });
-      const nameSpan = createElement("span", { class: "sound-btn__name" }, sound.name);
-      const durSpan = createElement(
-        "span",
-        { class: "sound-btn__duration" },
-        formatDuration(sound.durationMs),
-      );
-
-      appendChildren(btn, nameSpan, durSpan);
-
-      btn.addEventListener("click", () => {
-        if (btn.disabled) return;
-        options.onPlaySound(sound.id);
-        startCooldown(buttons);
-      }, { signal: ac.signal });
-
-      buttons.push(btn);
-      grid.appendChild(btn);
-    }
-
-    root.appendChild(grid);
-    container.appendChild(root);
-  }
-
-  function startCooldown(buttons: readonly HTMLButtonElement[]): void {
-    for (const btn of buttons) {
-      btn.disabled = true;
-      btn.classList.add("sound-btn--cooldown");
-    }
-
-    if (cooldownTimer !== null) {
-      clearTimeout(cooldownTimer);
-    }
-
-    cooldownTimer = setTimeout(() => {
-      cooldownTimer = null;
-      for (const btn of buttons) {
-        btn.disabled = false;
-        btn.classList.remove("sound-btn--cooldown");
-      }
-    }, COOLDOWN_MS);
-  }
-
-  function destroy(): void {
-    ac.abort();
-    if (cooldownTimer !== null) {
-      clearTimeout(cooldownTimer);
-      cooldownTimer = null;
-    }
-    if (root !== null) {
-      root.remove();
-      root = null;
-    }
-  }
-
-  return { mount, destroy };
-}
diff --git a/Client/tauri-client/src/components/VoiceChannel.ts b/Client/tauri-client/src/components/VoiceChannel.ts
index 3f82ed87..fde27da0 100644
--- a/Client/tauri-client/src/components/VoiceChannel.ts
+++ b/Client/tauri-client/src/components/VoiceChannel.ts
@@ -8,7 +8,7 @@ import { createElement, appendChildren, clearChildren, setText } from "@lib/dom"
 import { voiceStore } from "@stores/voice.store";
 import type { VoiceUser } from "@stores/voice.store";
 import { membersStore } from "@stores/members.store";
-import { setUserVolume, getUserVolume } from "@lib/voiceSession";
+import { setUserVolume, getUserVolume } from "@lib/livekitSession";
 import { authStore } from "@stores/auth.store";
 
 export interface VoiceChannelOptions {
diff --git a/Client/tauri-client/src/components/settings/LogsTab.ts b/Client/tauri-client/src/components/settings/LogsTab.ts
index 312c225e..4d3f538f 100644
--- a/Client/tauri-client/src/components/settings/LogsTab.ts
+++ b/Client/tauri-client/src/components/settings/LogsTab.ts
@@ -6,7 +6,7 @@ import { createElement, appendChildren, clearChildren } from "@lib/dom";
 import { getLogBuffer, clearLogBuffer, addLogListener, setLogLevel } from "@lib/logger";
 import type { LogEntry, LogLevel } from "@lib/logger";
 import type { TabName } from "../SettingsOverlay";
-import { getSessionDebugInfo, measureStreamLevel, getRemoteStreams, getLocalProcessedStream } from "@lib/voiceSession";
+import { getSessionDebugInfo } from "@lib/livekitSession";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -175,53 +175,7 @@ export function createLogsTab(
 
     function refreshDiag(): void {
       const info = getSessionDebugInfo();
-      const ctx = info.sharedAudioCtx as { state: string; sampleRate: number } | null;
-      const localTracks = info.localTracks as Array<{ id: string; enabled: boolean; muted: boolean; readyState: string }>;
-      const remoteEls = info.remoteAudioElements as Array<{
-        streamId: string; userId: number; audioPaused: boolean; audioMuted: boolean;
-        audioVolume: number; audioReadyState: number; hasSrcObject: boolean;
-        gainValue: number | string;
-        tracks: Array<{ id: string; enabled: boolean; muted: boolean; readyState: string }>;
-      }>;
-      const webrtcStreams = info.webrtcRemoteStreams as Array<{
-        streamId: string; trackCount: number;
-        audioTracks: Array<{ id: string; enabled: boolean; muted: boolean; readyState: string }>;
-      }>;
-
-      const lines: string[] = [
-        `=== Session ===`,
-        `WebRTC: ${info.hasWebrtc}  VAD: ${info.hasVad}  Suppressor: ${info.hasNoiseSuppressor}`,
-        `Join in progress: ${info.joinInProgress}  Silence suppression: ${info.silenceSuppressionEnabled}`,
-        `SharedAudioCtx: ${ctx ? `${ctx.state} @ ${ctx.sampleRate}Hz` : "none"}`,
-        ``,
-        `=== Local Audio ===`,
-        `Stream: ${info.hasLocalStream}  Processed: ${info.hasProcessedStream}`,
-      ];
-      for (const t of localTracks) {
-        lines.push(`  Track ${t.id.slice(0, 8)}: enabled=${t.enabled} muted=${t.muted} state=${t.readyState}`);
-      }
-
-      lines.push(``, `=== WebRTC Remote Streams ===`);
-      if (webrtcStreams.length === 0) lines.push(`  (none)`);
-      for (const s of webrtcStreams) {
-        lines.push(`  Stream ${s.streamId}: ${s.trackCount} tracks`);
-        for (const t of s.audioTracks) {
-          lines.push(`    Track ${t.id.slice(0, 8)}: enabled=${t.enabled} muted=${t.muted} state=${t.readyState}`);
-        }
-      }
-
-      lines.push(``, `=== Remote Audio Elements ===`);
-      if (remoteEls.length === 0) lines.push(`  (none)`);
-      for (const el of remoteEls) {
-        lines.push(`  [user ${el.userId}] stream=${el.streamId}`);
-        lines.push(`    <audio> paused=${el.audioPaused} muted=${el.audioMuted} volume=${el.audioVolume} readyState=${el.audioReadyState} srcObject=${el.hasSrcObject}`);
-        lines.push(`    GainNode: ${typeof el.gainValue === "number" ? el.gainValue.toFixed(2) : el.gainValue}`);
-        for (const t of el.tracks) {
-          lines.push(`    Track ${t.id.slice(0, 8)}: enabled=${t.enabled} muted=${t.muted} state=${t.readyState}`);
-        }
-      }
-
-      diagPanel.textContent = lines.join("\n");
+      diagPanel.textContent = JSON.stringify(info, null, 2);
     }
 
     refreshDiag();
@@ -236,100 +190,10 @@ export function createLogsTab(
       });
     }, { signal });
 
-    // Live audio level probe — measures actual signal flowing through streams
-    const levelBtn = createElement("button", { class: "ac-btn", style: "margin: 6px 0 0 6px;" }, "Probe Audio Levels");
-    const levelResult = createElement("pre", {
-      style: "margin: 6px 0 0 0; color: #ccc; font-family: monospace; font-size: 12px; white-space: pre-wrap;",
-    });
-    levelBtn.addEventListener("click", () => {
-      levelBtn.textContent = "Probing...";
-      levelResult.textContent = "";
-
-      const info = getSessionDebugInfo();
-      const promises: Array<Promise<string>> = [];
-
-      // 1. Probe local mic (what we're sending)
-      const localStream = getLocalProcessedStream();
-      if (localStream) {
-        promises.push(
-          measureStreamLevel(localStream).then((lvl) => `Local mic (outgoing): level=${lvl} ${lvl > 0 ? "✅ AUDIO FLOWING" : "❌ SILENCE"}`),
-        );
-      } else {
-        promises.push(Promise.resolve("Local mic: no stream"));
-      }
-
-      // 2. Probe raw WebRTC remote streams (before GainNode)
-      const rawRemoteStreams = getRemoteStreams();
-      rawRemoteStreams.forEach((s, i) => {
-        promises.push(
-          measureStreamLevel(s).then((lvl) => `Remote [${i}] (raw WebRTC ${s.id}): level=${lvl} ${lvl > 0 ? "✅ AUDIO FLOWING" : "❌ SILENCE"}`),
-        );
-      });
-
-      // 3. Probe GainNode output (what <audio> element plays)
-      const audioContainer = document.getElementById("voice-audio-container");
-      const audioEls = audioContainer?.querySelectorAll("audio") ?? [];
-      audioEls.forEach((el, i) => {
-        const a = el as HTMLAudioElement;
-        const src = a.srcObject as MediaStream | null;
-        if (src) {
-          promises.push(
-            measureStreamLevel(src).then((lvl) => `Remote [${i}] (GainNode output): level=${lvl} ${lvl > 0 ? "✅ AUDIO FLOWING" : "❌ SILENCE"}`),
-          );
-        }
-      });
-
-      if (promises.length === 0) {
-        levelResult.textContent = "No audio streams to probe";
-        levelBtn.textContent = "Probe Audio Levels";
-        return;
-      }
-
-      void Promise.all(promises).then((results) => {
-        levelResult.textContent = results.join("\n");
-        levelBtn.textContent = "Probe Audio Levels";
-      });
-    }, { signal });
-
     section.appendChild(diagPanel);
     const diagBtns = createElement("div", { style: "display: flex; flex-wrap: wrap;" });
-    appendChildren(diagBtns, diagRefresh, diagCopy, levelBtn);
+    appendChildren(diagBtns, diagRefresh, diagCopy);
     section.appendChild(diagBtns);
-    section.appendChild(levelResult);
-
-    // Direct playback test — bypasses GainNode pipeline entirely
-    const directBtn = createElement("button", { class: "ac-btn", style: "margin: 6px 0 0 6px;" }, "Test Direct Playback");
-    const directResult = createElement("pre", {
-      style: "margin: 6px 0 0 0; color: #ccc; font-family: monospace; font-size: 12px; white-space: pre-wrap;",
-    });
-    directBtn.addEventListener("click", () => {
-      const rawStreams = getRemoteStreams();
-      if (rawStreams.length === 0) {
-        directResult.textContent = "No remote streams to test";
-        return;
-      }
-      const lines: string[] = [];
-      for (const s of rawStreams) {
-        const testAudio = document.createElement("audio");
-        testAudio.srcObject = s;
-        testAudio.autoplay = true;
-        testAudio.volume = 1.0;
-        document.body.appendChild(testAudio);
-        testAudio.play().then(() => {
-          lines.push(`Stream ${s.id}: play() succeeded, paused=${testAudio.paused}, readyState=${testAudio.readyState}`);
-          lines.push(`  tracks: ${s.getAudioTracks().map((t) => `${t.id.slice(0,8)} enabled=${t.enabled} muted=${t.muted} readyState=${t.readyState}`).join(", ")}`);
-          directResult.textContent = lines.join("\n") + "\n\nDirect <audio> element added — can you hear audio now? (playing raw WebRTC stream, no GainNode)";
-          // Clean up after 10 seconds
-          setTimeout(() => { testAudio.srcObject = null; testAudio.remove(); }, 10000);
-        }).catch((err) => {
-          lines.push(`Stream ${s.id}: play() FAILED — ${err instanceof Error ? err.message : String(err)}`);
-          directResult.textContent = lines.join("\n");
-          testAudio.remove();
-        });
-      }
-    }, { signal });
-    diagBtns.appendChild(directBtn);
-    section.appendChild(directResult);
 
     // Log count
     const countEl = createElement("div", {
diff --git a/Client/tauri-client/src/components/settings/VoiceAudioTab.ts b/Client/tauri-client/src/components/settings/VoiceAudioTab.ts
index c4ce7b8f..08e865ac 100644
--- a/Client/tauri-client/src/components/settings/VoiceAudioTab.ts
+++ b/Client/tauri-client/src/components/settings/VoiceAudioTab.ts
@@ -4,8 +4,7 @@
 
 import { createElement, appendChildren, setText } from "@lib/dom";
 import { loadPref, savePref, createToggle } from "./helpers";
-import { switchInputDevice, switchOutputDevice, setVoiceSensitivity, updateSilenceSuppressionPref } from "@lib/voiceSession";
-import { sensitivityToThreshold } from "@lib/vad";
+import { switchInputDevice, switchOutputDevice, setVoiceSensitivity } from "@lib/livekitSession";
 
 export interface VoiceAudioTabHandle {
   build(): HTMLDivElement;
@@ -237,7 +236,7 @@ function buildVoiceAudioTabInner(signal: AbortSignal, registerMic: MicRegistrar,
 
   // Position threshold indicator
   function updateThresholdIndicator(sensitivity: number): void {
-    const threshold = sensitivityToThreshold(sensitivity);
+    const threshold = ((100 - sensitivity) / 100) * 0.15;
     // Map threshold (0-0.15) to percentage position (0-100%)
     const pct = Math.min((threshold / 0.15) * 100, 100);
     meterThreshold.style.left = `${pct}%`;
@@ -287,7 +286,7 @@ function buildVoiceAudioTabInner(signal: AbortSignal, registerMic: MicRegistrar,
         meterLevel.style.width = `${visual * 100}%`;
 
         // Color: green if above threshold, yellow/red if below
-        const threshold = sensitivityToThreshold(Number(sensitivitySlider.value));
+        const threshold = ((100 - Number(sensitivitySlider.value)) / 100) * 0.15;
         if (rms >= threshold) {
           meterLevel.style.background = "#43b581"; // green — voice detected
         } else {
@@ -310,7 +309,6 @@ function buildVoiceAudioTabInner(signal: AbortSignal, registerMic: MicRegistrar,
     { key: "noiseSuppression", label: "Noise Suppression", desc: "Filter out background noise from your microphone", fallback: true },
     { key: "autoGainControl", label: "Automatic Gain Control", desc: "Automatically adjust microphone volume", fallback: true },
     { key: "enhancedNoiseSuppression", label: "Enhanced Noise Suppression", desc: "ML-powered noise removal (RNNoise) — filters keyboard, pets, and other non-voice sounds", fallback: false },
-    { key: "silenceSuppression", label: "Silence Suppression", desc: "Stop sending audio during silence to save bandwidth", fallback: true },
   ];
 
   for (const item of audioToggles) {
@@ -325,12 +323,8 @@ function buildVoiceAudioTabInner(signal: AbortSignal, registerMic: MicRegistrar,
       signal,
       onChange: (nowOn) => {
         savePref(item.key, nowOn);
-        if (item.key === "silenceSuppression") {
-          updateSilenceSuppressionPref();
-        } else {
-          const currentDevice = loadPref<string>("audioInputDevice", "");
-          void switchInputDevice(currentDevice);
-        }
+        const currentDevice = loadPref<string>("audioInputDevice", "");
+        void switchInputDevice(currentDevice);
       },
     });
 
diff --git a/Client/tauri-client/src/lib/audio.ts b/Client/tauri-client/src/lib/audio.ts
deleted file mode 100644
index d898c2bb..00000000
--- a/Client/tauri-client/src/lib/audio.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-// =============================================================================
-// Audio Device Manager — enumerate devices, acquire streams, set output
-// =============================================================================
-
-import { loadPref } from "@components/settings/helpers";
-import { createLogger } from "@lib/logger";
-
-const log = createLogger("audio");
-
-export interface AudioDevice {
-  readonly deviceId: string;
-  readonly label: string;
-  readonly kind: "audioinput" | "audiooutput";
-}
-
-export interface AudioManager {
-  enumerateDevices(): Promise<readonly AudioDevice[]>;
-  getUserMedia(deviceId?: string): Promise<MediaStream>;
-  setOutputDevice(element: HTMLAudioElement, deviceId: string): Promise<void>;
-  getInputDeviceId(): string | null;
-  getOutputDeviceId(): string | null;
-  onDeviceChange(callback: (devices: readonly AudioDevice[]) => void): () => void;
-  destroy(): void;
-}
-
-type DeviceChangeCallback = (devices: readonly AudioDevice[]) => void;
-
-function toAudioDevice(info: MediaDeviceInfo): AudioDevice | null {
-  if (info.kind !== "audioinput" && info.kind !== "audiooutput") return null;
-  return {
-    deviceId: info.deviceId,
-    label: info.label || `${info.kind === "audioinput" ? "Microphone" : "Speaker"} (${info.deviceId.slice(0, 8)})`,
-    kind: info.kind,
-  };
-}
-
-export function createAudioManager(): AudioManager {
-  let currentInputDeviceId: string | null = null;
-  let currentOutputDeviceId: string | null = null;
-  let destroyed = false;
-
-  const activeStreams = new Set<MediaStream>();
-  const deviceChangeCallbacks = new Set<DeviceChangeCallback>();
-
-  async function listAudioDevices(): Promise<readonly AudioDevice[]> {
-    const devices = await navigator.mediaDevices.enumerateDevices();
-    const audioDevices: AudioDevice[] = [];
-    for (const d of devices) {
-      const mapped = toAudioDevice(d);
-      if (mapped !== null) {
-        audioDevices.push(mapped);
-      }
-    }
-    return audioDevices;
-  }
-
-  function handleDeviceChange(): void {
-    if (destroyed) return;
-    void listAudioDevices().then((devices) => {
-      log.info("Audio device change detected", {
-        inputs: devices.filter((d) => d.kind === "audioinput").length,
-        outputs: devices.filter((d) => d.kind === "audiooutput").length,
-      });
-      for (const cb of deviceChangeCallbacks) {
-        cb(devices);
-      }
-    });
-  }
-
-  navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
-
-  return {
-    async enumerateDevices(): Promise<readonly AudioDevice[]> {
-      if (destroyed) throw new Error("AudioManager has been destroyed");
-      return listAudioDevices();
-    },
-
-    async getUserMedia(deviceId?: string): Promise<MediaStream> {
-      if (destroyed) throw new Error("AudioManager has been destroyed");
-
-      const constraints: MediaStreamConstraints = {
-        audio: {
-          deviceId: deviceId !== undefined ? { exact: deviceId } : undefined,
-          echoCancellation: loadPref<boolean>("echoCancellation", true),
-          noiseSuppression: loadPref<boolean>("noiseSuppression", true),
-          autoGainControl: loadPref<boolean>("autoGainControl", true),
-        },
-        video: false,
-      };
-
-      const stream = await navigator.mediaDevices.getUserMedia(constraints);
-      activeStreams.add(stream);
-
-      // Determine actual device ID from the track settings
-      const audioTrack = stream.getAudioTracks()[0];
-      if (audioTrack !== undefined) {
-        const settings = audioTrack.getSettings();
-        currentInputDeviceId = settings.deviceId ?? deviceId ?? null;
-        log.info("Microphone acquired", {
-          deviceId: currentInputDeviceId,
-          sampleRate: settings.sampleRate,
-          channelCount: settings.channelCount,
-          echoCancellation: settings.echoCancellation,
-          noiseSuppression: settings.noiseSuppression,
-          autoGainControl: settings.autoGainControl,
-        });
-      }
-
-      return stream;
-    },
-
-    async setOutputDevice(element: HTMLAudioElement, deviceId: string): Promise<void> {
-      if (destroyed) throw new Error("AudioManager has been destroyed");
-
-      // setSinkId is not available in all browsers; check before calling
-      if (typeof element.setSinkId !== "function") {
-        throw new Error("Audio output device selection is not supported in this browser");
-      }
-      await element.setSinkId(deviceId);
-      currentOutputDeviceId = deviceId;
-    },
-
-    getInputDeviceId(): string | null {
-      return currentInputDeviceId;
-    },
-
-    getOutputDeviceId(): string | null {
-      return currentOutputDeviceId;
-    },
-
-    onDeviceChange(callback: DeviceChangeCallback): () => void {
-      deviceChangeCallbacks.add(callback);
-      return () => { deviceChangeCallbacks.delete(callback); };
-    },
-
-    destroy(): void {
-      if (destroyed) return;
-      destroyed = true;
-
-      navigator.mediaDevices.removeEventListener("devicechange", handleDeviceChange);
-
-      // Stop all tracks on all active streams
-      log.debug("AudioManager destroying", { activeStreams: activeStreams.size });
-      for (const stream of activeStreams) {
-        for (const track of stream.getTracks()) {
-          track.stop();
-        }
-      }
-      activeStreams.clear();
-      deviceChangeCallbacks.clear();
-      currentInputDeviceId = null;
-      currentOutputDeviceId = null;
-    },
-  };
-}
diff --git a/Client/tauri-client/src/lib/dispatcher.ts b/Client/tauri-client/src/lib/dispatcher.ts
index 72e8b5cd..4a49b63a 100644
--- a/Client/tauri-client/src/lib/dispatcher.ts
+++ b/Client/tauri-client/src/lib/dispatcher.ts
@@ -38,11 +38,7 @@ import {
   joinVoiceChannel,
   leaveVoiceChannel,
 } from "@stores/voice.store";
-import {
-  handleServerOffer,
-  handleServerAnswer,
-  handleServerIce,
-} from "@lib/voiceSession";
+import { handleVoiceToken } from "@lib/livekitSession";
 import { notifyIncomingMessage } from "./notifications";
 import { createLogger } from "./logger";
 
@@ -269,20 +265,8 @@ export function wireDispatcher(ws: WsClient): DispatcherCleanup {
   );
 
   unsubs.push(
-    ws.on("voice_offer", (payload) => {
-      handleServerOffer(payload.sdp, payload.channel_id);
-    }),
-  );
-
-  unsubs.push(
-    ws.on("voice_answer", (payload) => {
-      handleServerAnswer(payload.sdp);
-    }),
-  );
-
-  unsubs.push(
-    ws.on("voice_ice", (payload) => {
-      handleServerIce(payload.candidate);
+    ws.on("voice_token", (payload) => {
+      void handleVoiceToken(payload.token, payload.url, payload.channel_id);
     }),
   );
 
diff --git a/Client/tauri-client/src/lib/livekitSession.ts b/Client/tauri-client/src/lib/livekitSession.ts
new file mode 100644
index 00000000..2c177fbb
--- /dev/null
+++ b/Client/tauri-client/src/lib/livekitSession.ts
@@ -0,0 +1,605 @@
+// =============================================================================
+// LiveKit Session — lifecycle orchestrator for voice chat via LiveKit
+//
+// Replaces the old WebRTC-based voiceSession.ts. Manages LiveKit Room
+// connection, mic publishing (with optional RNNoise pre-processing),
+// remote track playback, and camera/screenshare.
+// =============================================================================
+
+import {
+  Room,
+  RoomEvent,
+  Track,
+  type RemoteTrack,
+  type RemoteTrackPublication,
+  type RemoteParticipant,
+  type Participant,
+  DisconnectReason,
+} from "livekit-client";
+import type { WsClient } from "@lib/ws";
+import {
+  voiceStore,
+  setLocalMuted,
+  setLocalDeafened,
+  setLocalSpeaking,
+  setLocalCamera,
+} from "@stores/voice.store";
+import { loadPref, savePref } from "@components/settings/helpers";
+import { createLogger } from "@lib/logger";
+import { createNoiseSuppressor } from "@lib/noise-suppression";
+import type { NoiseSuppressor } from "@lib/noise-suppression";
+
+const log = createLogger("livekitSession");
+
+// ---------------------------------------------------------------------------
+// Module-level state (singleton)
+// ---------------------------------------------------------------------------
+
+let room: Room | null = null;
+let ws: WsClient | null = null;
+let noiseSuppressor: NoiseSuppressor | null = null;
+let onErrorCallback: ((message: string) => void) | null = null;
+let currentChannelId: number | null = null;
+
+/** The raw mic stream acquired for RNNoise processing (must be stopped on cleanup). */
+let rawMicStream: MediaStream | null = null;
+
+// Remote audio playback
+const audioElements = new Map<string, HTMLAudioElement>();
+let audioContainer: HTMLDivElement | null = null;
+
+// Remote video callbacks
+type RemoteVideoCallback = (userId: number, stream: MediaStream) => void;
+type RemoteVideoRemovedCallback = (userId: number) => void;
+let onRemoteVideoCallback: RemoteVideoCallback | null = null;
+let onRemoteVideoRemovedCallback: RemoteVideoRemovedCallback | null = null;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Parse userId from LiveKit participant identity "user-{id}". Returns 0 if unparseable. */
+function parseUserId(identity: string): number {
+  const match = identity.match(/^user-(\d+)$/);
+  if (match !== null && match[1] !== undefined) {
+    return parseInt(match[1], 10);
+  }
+  return 0;
+}
+
+/** Get or create the hidden container for remote audio elements. */
+function getOrCreateAudioContainer(): HTMLDivElement {
+  if (audioContainer !== null) return audioContainer;
+
+  const existing = document.getElementById("voice-audio-container");
+  if (existing instanceof HTMLDivElement) {
+    audioContainer = existing;
+    return audioContainer;
+  }
+
+  const div = document.createElement("div");
+  div.id = "voice-audio-container";
+  div.style.display = "none";
+  document.body.appendChild(div);
+  audioContainer = div;
+  return audioContainer;
+}
+
+/** Get saved per-user volume (0-200 range, default 100). */
+function getSavedUserVolume(userId: number): number {
+  return loadPref<number>(`userVolume_${userId}`, 100);
+}
+
+/** Clean up all remote audio elements. */
+function cleanupAudioElements(): void {
+  for (const el of audioElements.values()) {
+    el.srcObject = null;
+    el.remove();
+  }
+  audioElements.clear();
+}
+
+// ---------------------------------------------------------------------------
+// RNNoise integration
+// ---------------------------------------------------------------------------
+
+/** Acquire mic, run through RNNoise, and publish the processed track to LiveKit. */
+async function publishWithNoiseSuppression(): Promise<void> {
+  if (room === null) return;
+
+  const savedDevice = loadPref<string>("audioInputDevice", "");
+  const constraints: MediaStreamConstraints = {
+    audio: {
+      deviceId: savedDevice ? { exact: savedDevice } : undefined,
+      echoCancellation: loadPref("echoCancellation", true),
+      noiseSuppression: loadPref("noiseSuppression", true),
+      autoGainControl: loadPref("autoGainControl", true),
+    },
+    video: false,
+  };
+  const rawStream = await navigator.mediaDevices.getUserMedia(constraints);
+  rawMicStream = rawStream;
+  noiseSuppressor = createNoiseSuppressor();
+  const processedStream = await noiseSuppressor.process(rawStream);
+  const processedTrack = processedStream.getAudioTracks()[0];
+  if (processedTrack) {
+    await room.localParticipant.publishTrack(processedTrack, {
+      source: Track.Source.Microphone,
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Room event handlers
+// ---------------------------------------------------------------------------
+
+function handleTrackSubscribed(
+  track: RemoteTrack,
+  publication: RemoteTrackPublication,
+  participant: RemoteParticipant,
+): void {
+  const userId = parseUserId(participant.identity);
+
+  if (track.kind === Track.Kind.Audio) {
+    // Attach audio track to a hidden <audio> element for playback
+    const container = getOrCreateAudioContainer();
+    const audioEl = track.attach();
+
+    // Apply saved per-user volume
+    const savedVolume = userId > 0 ? getSavedUserVolume(userId) : 100;
+    audioEl.volume = Math.min(savedVolume, 100) / 100;
+
+    // Respect current deafen state
+    if (voiceStore.getState().localDeafened) {
+      audioEl.muted = true;
+    }
+
+    // Apply saved output device
+    const savedOutput = loadPref<string>("audioOutputDevice", "");
+    if (savedOutput !== "" && typeof audioEl.setSinkId === "function") {
+      audioEl.setSinkId(savedOutput).catch((err) => {
+        log.warn("Failed to set output device on remote audio", err);
+      });
+    }
+
+    container.appendChild(audioEl);
+    const trackKey = `${participant.identity}-${track.sid}`;
+    audioElements.set(trackKey, audioEl);
+    log.debug("Remote audio track subscribed", { userId, trackSid: track.sid });
+  } else if (track.kind === Track.Kind.Video) {
+    if (userId > 0 && onRemoteVideoCallback !== null) {
+      // Create a MediaStream from the video track for the VideoGrid
+      const mediaTrack = track.mediaStreamTrack;
+      const stream = new MediaStream([mediaTrack]);
+      onRemoteVideoCallback(userId, stream);
+    }
+    log.debug("Remote video track subscribed", { userId, trackSid: track.sid });
+  }
+}
+
+function handleTrackUnsubscribed(
+  track: RemoteTrack,
+  _publication: RemoteTrackPublication,
+  participant: RemoteParticipant,
+): void {
+  const userId = parseUserId(participant.identity);
+
+  if (track.kind === Track.Kind.Audio) {
+    track.detach().forEach((el) => {
+      el.remove();
+    });
+    const trackKey = `${participant.identity}-${track.sid}`;
+    audioElements.delete(trackKey);
+    log.debug("Remote audio track unsubscribed", { userId, trackSid: track.sid });
+  } else if (track.kind === Track.Kind.Video) {
+    track.detach();
+    if (userId > 0) {
+      onRemoteVideoRemovedCallback?.(userId);
+    }
+    log.debug("Remote video track unsubscribed", { userId, trackSid: track.sid });
+  }
+}
+
+function handleActiveSpeakersChanged(speakers: Participant[]): void {
+  const speakerIds = new Set<number>();
+  for (const speaker of speakers) {
+    const userId = parseUserId(speaker.identity);
+    if (userId > 0) {
+      speakerIds.add(userId);
+    }
+  }
+
+  // Update speaking state in voice store for all users in the channel
+  const state = voiceStore.getState();
+  const channelId = state.currentChannelId;
+  if (channelId === null) return;
+
+  const channelUsers = state.voiceUsers.get(channelId);
+  if (!channelUsers) return;
+
+  for (const [userId] of channelUsers) {
+    const isSpeaking = speakerIds.has(userId);
+    setLocalSpeaking(isSpeaking);
+  }
+}
+
+function handleDisconnected(reason?: DisconnectReason): void {
+  log.info("LiveKit room disconnected", { reason });
+
+  const isUnexpected = reason !== DisconnectReason.CLIENT_INITIATED;
+  leaveVoice(false);
+
+  if (isUnexpected) {
+    onErrorCallback?.("Voice connection lost — disconnected");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Set the WS client reference used for signaling. */
+export function setWsClient(client: WsClient): void {
+  ws = client;
+}
+
+/** Set error callback for UI feedback (e.g. toast on connection failure). */
+export function setOnError(cb: (message: string) => void): void {
+  onErrorCallback = cb;
+}
+
+/** Clear the error callback. */
+export function clearOnError(): void {
+  onErrorCallback = null;
+}
+
+/** Set callback for when a remote user enables their camera. */
+export function setOnRemoteVideo(cb: RemoteVideoCallback): void {
+  onRemoteVideoCallback = cb;
+}
+
+/** Set callback for when a remote user disables their camera. */
+export function setOnRemoteVideoRemoved(cb: RemoteVideoRemovedCallback): void {
+  onRemoteVideoRemovedCallback = cb;
+}
+
+/** Clear remote video callbacks. */
+export function clearOnRemoteVideo(): void {
+  onRemoteVideoCallback = null;
+  onRemoteVideoRemovedCallback = null;
+}
+
+/**
+ * Handle a voice_token message from the server. Creates a LiveKit Room,
+ * connects to the SFU, and publishes the local microphone track.
+ */
+export async function handleVoiceToken(
+  token: string,
+  url: string,
+  channelId: number,
+): Promise<void> {
+  // Disconnect existing session first
+  if (room !== null) {
+    leaveVoice(false);
+  }
+
+  try {
+    // Create room with audio processing defaults
+    room = new Room({
+      adaptiveStream: true,
+      dynacast: true,
+      audioCaptureDefaults: {
+        echoCancellation: loadPref("echoCancellation", true),
+        noiseSuppression: loadPref("noiseSuppression", true),
+        autoGainControl: loadPref("autoGainControl", true),
+      },
+    });
+
+    // Wire room events
+    room.on(RoomEvent.TrackSubscribed, handleTrackSubscribed);
+    room.on(RoomEvent.TrackUnsubscribed, handleTrackUnsubscribed);
+    room.on(RoomEvent.ActiveSpeakersChanged, handleActiveSpeakersChanged);
+    room.on(RoomEvent.Disconnected, handleDisconnected);
+
+    // Connect to LiveKit server
+    await room.connect(url, token);
+    log.info("Connected to LiveKit room", { channelId, url });
+
+    // Enable microphone: use RNNoise if Enhanced Noise Suppression is on
+    const enhancedNS = loadPref<boolean>("enhancedNoiseSuppression", false);
+    if (enhancedNS) {
+      await publishWithNoiseSuppression();
+      log.info("Published mic with RNNoise noise suppression");
+    } else {
+      await room.localParticipant.setMicrophoneEnabled(true);
+      log.info("Published mic via LiveKit native capture");
+    }
+
+    // Apply saved input device
+    const savedInput = loadPref<string>("audioInputDevice", "");
+    if (savedInput) {
+      await room.switchActiveDevice("audioinput", savedInput);
+    }
+
+    // Apply saved output device
+    const savedOutput = loadPref<string>("audioOutputDevice", "");
+    if (savedOutput) {
+      await room.switchActiveDevice("audiooutput", savedOutput);
+    }
+
+    currentChannelId = channelId;
+    log.info("Voice session active", { channelId });
+  } catch (err) {
+    log.error("Failed to connect to LiveKit", err);
+    onErrorCallback?.("Failed to join voice — connection error");
+    leaveVoice(false);
+  }
+}
+
+/**
+ * Leave the current voice session and clean up all resources.
+ * If sendWs is true (default), also notifies the server via voice_leave.
+ */
+export function leaveVoice(sendWs = true): void {
+  if (sendWs && ws !== null) {
+    ws.send({ type: "voice_leave", payload: {} });
+  }
+
+  // Stop raw mic stream acquired for RNNoise
+  if (rawMicStream !== null) {
+    for (const track of rawMicStream.getTracks()) {
+      track.stop();
+    }
+    rawMicStream = null;
+  }
+
+  // Destroy noise suppressor
+  if (noiseSuppressor !== null) {
+    noiseSuppressor.destroy();
+    noiseSuppressor = null;
+  }
+
+  // Disconnect LiveKit room
+  if (room !== null) {
+    room.removeAllListeners();
+    void room.disconnect();
+    room = null;
+  }
+
+  // Clean up remote audio elements
+  cleanupAudioElements();
+
+  currentChannelId = null;
+  log.info("Left voice session");
+}
+
+/** Mute or unmute the local microphone. */
+export function setMuted(muted: boolean): void {
+  setLocalMuted(muted);
+  if (room !== null) {
+    void room.localParticipant.setMicrophoneEnabled(!muted);
+  }
+}
+
+/** Deafen or undeafen — mutes all remote audio playback. */
+export function setDeafened(deafened: boolean): void {
+  setLocalDeafened(deafened);
+  if (room !== null) {
+    // Toggle subscription on remote audio tracks for deafen
+    for (const participant of room.remoteParticipants.values()) {
+      for (const pub of participant.audioTrackPublications.values()) {
+        pub.setSubscribed(!deafened);
+      }
+    }
+  }
+  // Also mute/unmute audio elements directly for immediate effect
+  for (const el of audioElements.values()) {
+    el.muted = deafened;
+  }
+  log.debug("Deafen state changed", { deafened });
+}
+
+/** Enable camera: publish video track, notify server. */
+export async function enableCamera(): Promise<void> {
+  if (room === null || ws === null) {
+    log.warn("Cannot enable camera: no active voice session");
+    onErrorCallback?.("Join a voice channel first");
+    return;
+  }
+
+  try {
+    await room.localParticipant.setCameraEnabled(true);
+
+    // Apply saved video device
+    const savedVideoDevice = loadPref<string>("videoInputDevice", "");
+    if (savedVideoDevice) {
+      await room.switchActiveDevice("videoinput", savedVideoDevice);
+    }
+
+    setLocalCamera(true);
+    ws.send({ type: "voice_camera", payload: { enabled: true } });
+    log.info("Camera enabled");
+  } catch (err) {
+    log.error("Failed to enable camera", err);
+    if (err instanceof DOMException && err.name === "NotAllowedError") {
+      onErrorCallback?.("Camera permission denied");
+    } else if (err instanceof DOMException && err.name === "NotFoundError") {
+      onErrorCallback?.("No camera found");
+    } else {
+      onErrorCallback?.("Failed to start camera");
+    }
+  }
+}
+
+/** Disable camera: unpublish video track, notify server. */
+export async function disableCamera(): Promise<void> {
+  if (room !== null) {
+    await room.localParticipant.setCameraEnabled(false);
+  }
+
+  setLocalCamera(false);
+  if (ws !== null) {
+    ws.send({ type: "voice_camera", payload: { enabled: false } });
+  }
+  log.info("Camera disabled");
+}
+
+/** Switch the input (microphone) device on an active session. */
+export async function switchInputDevice(deviceId: string): Promise<void> {
+  if (room === null) {
+    log.debug("Skipping input device switch — no active voice session");
+    return;
+  }
+
+  try {
+    const enhancedNS = loadPref<boolean>("enhancedNoiseSuppression", false);
+    if (enhancedNS && noiseSuppressor !== null) {
+      // Need to re-acquire mic and re-process through RNNoise
+      // Stop old raw stream
+      if (rawMicStream !== null) {
+        for (const track of rawMicStream.getTracks()) {
+          track.stop();
+        }
+        rawMicStream = null;
+      }
+      noiseSuppressor.destroy();
+      noiseSuppressor = null;
+
+      // Unpublish current mic track
+      for (const pub of room.localParticipant.audioTrackPublications.values()) {
+        if (pub.source === Track.Source.Microphone && pub.track) {
+          await room.localParticipant.unpublishTrack(pub.track);
+        }
+      }
+
+      // Re-publish with new device
+      await publishWithNoiseSuppression();
+    } else {
+      await room.switchActiveDevice("audioinput", deviceId);
+    }
+    log.info("Switched input device", { deviceId });
+  } catch (err) {
+    log.error("Failed to switch input device", err);
+    onErrorCallback?.("Failed to switch microphone");
+  }
+}
+
+/** Switch the output (speaker) device on an active session. */
+export async function switchOutputDevice(deviceId: string): Promise<void> {
+  if (room !== null) {
+    await room.switchActiveDevice("audiooutput", deviceId);
+  }
+
+  // Also update any existing audio elements
+  for (const el of audioElements.values()) {
+    if (typeof el.setSinkId === "function") {
+      try {
+        await el.setSinkId(deviceId);
+      } catch (err) {
+        log.warn("Failed to set output device on audio element", err);
+      }
+    }
+  }
+  log.info("Switched output device", { deviceId });
+}
+
+/**
+ * Set per-user volume (0-200%). Persisted to localStorage.
+ * Note: HTMLAudioElement.volume only supports 0.0-1.0, so volumes above
+ * 100% are clamped.
+ */
+export function setUserVolume(userId: number, volume: number): void {
+  const clamped = Math.max(0, Math.min(200, volume));
+  savePref(`userVolume_${userId}`, clamped);
+
+  // Find audio elements for this user's tracks
+  if (room !== null) {
+    for (const participant of room.remoteParticipants.values()) {
+      const pUserId = parseUserId(participant.identity);
+      if (pUserId === userId) {
+        for (const pub of participant.audioTrackPublications.values()) {
+          if (pub.track) {
+            const els = pub.track.attachedElements;
+            for (const el of els) {
+              if (el instanceof HTMLAudioElement) {
+                el.volume = Math.min(clamped, 100) / 100;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/** Get the current per-user volume (0-200%, default 100). */
+export function getUserVolume(userId: number): number {
+  return getSavedUserVolume(userId);
+}
+
+/** Update the VAD sensitivity — no-op in LiveKit (server handles VAD). */
+export function setVoiceSensitivity(_sensitivity: number): void {
+  // No local VAD in LiveKit mode — server/SFU handles speaker detection
+}
+
+/** Get the local camera stream for self-view display. */
+export function getLocalCameraStream(): MediaStream | null {
+  if (room === null) return null;
+  const cameraPub = room.localParticipant.getTrackPublication(Track.Source.Camera);
+  if (cameraPub?.track?.mediaStreamTrack) {
+    return new MediaStream([cameraPub.track.mediaStreamTrack]);
+  }
+  return null;
+}
+
+/** Snapshot of current voice session state for debugging. */
+export function getSessionDebugInfo(): Record<string, unknown> {
+  if (room === null) {
+    return {
+      hasRoom: false,
+      hasNoiseSuppressor: noiseSuppressor !== null,
+      currentChannelId,
+    };
+  }
+
+  const remoteParticipants: Record<string, unknown>[] = [];
+  for (const p of room.remoteParticipants.values()) {
+    const tracks: Record<string, unknown>[] = [];
+    for (const pub of p.trackPublications.values()) {
+      tracks.push({
+        sid: pub.trackSid,
+        source: pub.source,
+        kind: pub.kind,
+        subscribed: pub.isSubscribed,
+        enabled: pub.isEnabled,
+      });
+    }
+    remoteParticipants.push({
+      identity: p.identity,
+      userId: parseUserId(p.identity),
+      tracks,
+    });
+  }
+
+  const localTracks: Record<string, unknown>[] = [];
+  for (const pub of room.localParticipant.trackPublications.values()) {
+    localTracks.push({
+      sid: pub.trackSid,
+      source: pub.source,
+      kind: pub.kind,
+      isMuted: pub.isMuted,
+    });
+  }
+
+  return {
+    hasRoom: true,
+    roomName: room.name,
+    roomState: room.state,
+    hasNoiseSuppressor: noiseSuppressor !== null,
+    currentChannelId,
+    localParticipant: room.localParticipant.identity,
+    localTracks,
+    remoteParticipants,
+    audioElements: audioElements.size,
+  };
+}
diff --git a/Client/tauri-client/src/lib/ptt.ts b/Client/tauri-client/src/lib/ptt.ts
index edb0a921..a208d630 100644
--- a/Client/tauri-client/src/lib/ptt.ts
+++ b/Client/tauri-client/src/lib/ptt.ts
@@ -6,7 +6,7 @@
 
 import { loadPref, savePref } from "@components/settings/helpers";
 import { voiceStore } from "@stores/voice.store";
-import { setMuted } from "./voiceSession";
+import { setMuted } from "./livekitSession";
 import { createLogger } from "./logger";
 
 const log = createLogger("ptt");
diff --git a/Client/tauri-client/src/lib/types.ts b/Client/tauri-client/src/lib/types.ts
index 029fe263..cd80dc07 100644
--- a/Client/tauri-client/src/lib/types.ts
+++ b/Client/tauri-client/src/lib/types.ts
@@ -17,9 +17,6 @@ export type ChannelType = "text" | "voice" | "announcement";
 /** Voice quality presets. */
 export type VoiceQuality = "low" | "medium" | "high";
 
-/** Voice threshold mode. CRITICAL: always "threshold_mode", never "mode". */
-export type ThresholdMode = "forwarding" | "selective";
-
 /** Reaction action direction. */
 export type ReactionAction = "add" | "remove";
 
@@ -262,7 +259,7 @@ export interface VoiceConfigPayload {
   readonly channel_id: number;
   readonly quality: VoiceQuality;
   readonly bitrate: number;
-  readonly threshold_mode: ThresholdMode;
+  readonly threshold_mode: string;
   readonly mixing_threshold: number;
   readonly top_speakers: number;
   readonly max_users: number;
@@ -272,22 +269,13 @@ export interface VoiceConfigPayload {
 export interface VoiceSpeakersPayload {
   readonly channel_id: number;
   readonly speakers: readonly number[];
-  readonly threshold_mode: ThresholdMode;
+  readonly threshold_mode: string;
 }
 
-export interface VoiceOfferPayload {
+export interface VoiceTokenPayload {
   readonly channel_id: number;
-  readonly sdp: string;
-}
-
-export interface VoiceAnswerPayload {
-  readonly channel_id: number;
-  readonly sdp: string;
-}
-
-export interface VoiceIcePayload {
-  readonly channel_id: number;
-  readonly candidate: RTCIceCandidateInit;
+  readonly token: string;
+  readonly url: string;
 }
 
 export interface MemberJoinPayload {
@@ -390,10 +378,6 @@ export interface SoundboardPlayPayload {
   readonly sound_id: string;
 }
 
-// Note: VoiceOfferPayload, VoiceAnswerPayload, VoiceIcePayload are
-// bidirectional — the same interface is used for both client→server
-// and server→client directions. See definitions above.
-
 // -----------------------------------------------------------------------------
 // Discriminated Union: Server → Client Messages
 // -----------------------------------------------------------------------------
@@ -416,9 +400,7 @@ export type ServerMessage =
   | (WsEnvelope<VoiceLeavePayload> & { readonly type: "voice_leave" })
   | (WsEnvelope<VoiceConfigPayload> & { readonly type: "voice_config" })
   | (WsEnvelope<VoiceSpeakersPayload> & { readonly type: "voice_speakers" })
-  | (WsEnvelope<VoiceOfferPayload> & { readonly type: "voice_offer" })
-  | (WsEnvelope<VoiceAnswerPayload> & { readonly type: "voice_answer" })
-  | (WsEnvelope<VoiceIcePayload> & { readonly type: "voice_ice" })
+  | (WsEnvelope<VoiceTokenPayload> & { readonly type: "voice_token" })
   | (WsEnvelope<MemberJoinPayload> & { readonly type: "member_join" })
   | (WsEnvelope<MemberLeavePayload> & { readonly type: "member_leave" })
   | (WsEnvelope<MemberUpdatePayload> & { readonly type: "member_update" })
@@ -446,10 +428,7 @@ export type ClientMessage =
   | (WsEnvelope<VoiceDeafenPayload> & { readonly type: "voice_deafen" })
   | (WsEnvelope<VoiceCameraPayload> & { readonly type: "voice_camera" })
   | (WsEnvelope<VoiceScreensharePayload> & { readonly type: "voice_screenshare" })
-  | (WsEnvelope<SoundboardPlayPayload> & { readonly type: "soundboard_play" })
-  | (WsEnvelope<VoiceOfferPayload> & { readonly type: "voice_offer" })
-  | (WsEnvelope<VoiceAnswerPayload> & { readonly type: "voice_answer" })
-  | (WsEnvelope<VoiceIcePayload> & { readonly type: "voice_ice" });
+  | (WsEnvelope<SoundboardPlayPayload> & { readonly type: "soundboard_play" });
 
 // -----------------------------------------------------------------------------
 // REST API Response Types
diff --git a/Client/tauri-client/src/lib/vad.ts b/Client/tauri-client/src/lib/vad.ts
deleted file mode 100644
index bbb1721f..00000000
--- a/Client/tauri-client/src/lib/vad.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-// =============================================================================
-// Voice Activity Detection — Web Audio API based speech detection
-// =============================================================================
-
-import { createLogger } from "@lib/logger";
-
-const log = createLogger("vad");
-
-export interface VadOptions {
-  /** Audio volume threshold (0-1) to detect speech. Default 0.01 */
-  readonly threshold?: number;
-  /** How often to check volume in ms. Default 50 */
-  readonly intervalMs?: number;
-  /** Minimum consecutive detections before triggering. Default 3 */
-  readonly minConsecutive?: number;
-}
-
-export interface VadDetector {
-  start(stream: MediaStream): void;
-  stop(): void;
-  setThreshold(threshold: number): void;
-  onSpeakingChange(callback: (speaking: boolean) => void): () => void;
-  isSpeaking(): boolean;
-  destroy(): void;
-}
-
-type SpeakingCallback = (speaking: boolean) => void;
-
-const DEFAULT_THRESHOLD = 0.01;
-const DEFAULT_INTERVAL_MS = 50;
-const DEFAULT_MIN_CONSECUTIVE = 3;
-
-/** Max VAD threshold value. Sensitivity 0% maps to this threshold. */
-const MAX_THRESHOLD = 0.15;
-
-/** Convert sensitivity slider (0-100) to VAD threshold (0-MAX_THRESHOLD).
- *  High sensitivity = low threshold (picks up quiet sounds).
- *  0% sensitivity = threshold 0.15 (only loud sounds trigger).
- *  100% sensitivity = threshold 0.0 (everything triggers). */
-export function sensitivityToThreshold(sensitivity: number): number {
-  return ((100 - sensitivity) / 100) * MAX_THRESHOLD;
-}
-// Require more silence samples than speech samples to prevent flicker
-const SILENCE_MULTIPLIER = 2;
-
-function computeRms(data: Uint8Array): number {
-  let sum = 0;
-  for (let i = 0; i < data.length; i++) {
-    const val = data[i];
-    if (val === undefined) continue;
-    // getByteFrequencyData returns 0-255 where 0 = silence, 255 = max.
-    // Normalize to 0-1 range.
-    const normalized = val / 255;
-    sum += normalized * normalized;
-  }
-  return Math.sqrt(sum / data.length);
-}
-
-export function createVadDetector(options?: VadOptions): VadDetector {
-  let threshold = options?.threshold ?? DEFAULT_THRESHOLD;
-  const intervalMs = options?.intervalMs ?? DEFAULT_INTERVAL_MS;
-  const minConsecutive = options?.minConsecutive ?? DEFAULT_MIN_CONSECUTIVE;
-  const silenceRequired = minConsecutive * SILENCE_MULTIPLIER;
-
-  let audioContext: AudioContext | null = null;
-  let analyser: AnalyserNode | null = null;
-  let sourceNode: MediaStreamAudioSourceNode | null = null;
-  let intervalId: ReturnType<typeof setInterval> | null = null;
-  let destroyed = false;
-
-  let speaking = false;
-  let consecutiveAbove = 0;
-  let consecutiveBelow = 0;
-
-  const callbacks = new Set<SpeakingCallback>();
-
-  function emitChange(newState: boolean): void {
-    if (speaking === newState) return;
-    speaking = newState;
-    for (const cb of callbacks) {
-      cb(speaking);
-    }
-  }
-
-  function tick(): void {
-    if (analyser === null) return;
-
-    const data = new Uint8Array(analyser.frequencyBinCount);
-    analyser.getByteFrequencyData(data);
-    const rms = computeRms(data);
-
-    if (rms >= threshold) {
-      consecutiveAbove++;
-      consecutiveBelow = 0;
-      if (!speaking && consecutiveAbove >= minConsecutive) {
-        emitChange(true);
-      }
-    } else {
-      consecutiveBelow++;
-      consecutiveAbove = 0;
-      if (speaking && consecutiveBelow >= silenceRequired) {
-        emitChange(false);
-      }
-    }
-  }
-
-  function cleanup(): void {
-    if (intervalId !== null) {
-      clearInterval(intervalId);
-      intervalId = null;
-    }
-    if (sourceNode !== null) {
-      sourceNode.disconnect();
-      sourceNode = null;
-    }
-    if (analyser !== null) {
-      analyser.disconnect();
-      analyser = null;
-    }
-    if (audioContext !== null) {
-      void audioContext.close();
-      audioContext = null;
-    }
-    consecutiveAbove = 0;
-    consecutiveBelow = 0;
-    if (speaking) {
-      emitChange(false);
-    }
-  }
-
-  return {
-    start(stream: MediaStream): void {
-      if (destroyed) throw new Error("VadDetector has been destroyed");
-      // Stop any existing monitoring first
-      cleanup();
-
-      // Force 48kHz so FFT bins cover the voice-frequency range (0-24kHz)
-      // consistently regardless of the system audio device's native rate.
-      // At high native rates (e.g. 192kHz), most bins would be above voice
-      // frequencies, making the RMS calculation artificially low.
-      audioContext = new AudioContext({ sampleRate: 48000 });
-      analyser = audioContext.createAnalyser();
-      analyser.fftSize = 256;
-      analyser.smoothingTimeConstant = 0.5;
-
-      sourceNode = audioContext.createMediaStreamSource(stream);
-      sourceNode.connect(analyser);
-
-      intervalId = setInterval(tick, intervalMs);
-      log.debug("VAD started", { threshold, intervalMs, minConsecutive, sampleRate: audioContext.sampleRate });
-    },
-
-    stop(): void {
-      if (destroyed) return;
-      cleanup();
-    },
-
-    setThreshold(newThreshold: number): void {
-      if (newThreshold < 0 || newThreshold > 1) {
-        throw new Error("Threshold must be between 0 and 1");
-      }
-      log.debug("VAD threshold changed", { old: threshold, new: newThreshold });
-      threshold = newThreshold;
-    },
-
-    onSpeakingChange(callback: SpeakingCallback): () => void {
-      callbacks.add(callback);
-      return () => { callbacks.delete(callback); };
-    },
-
-    isSpeaking(): boolean {
-      return speaking;
-    },
-
-    destroy(): void {
-      if (destroyed) return;
-      destroyed = true;
-      cleanup();
-      callbacks.clear();
-      log.debug("VAD destroyed");
-    },
-  };
-}
diff --git a/Client/tauri-client/src/lib/video.ts b/Client/tauri-client/src/lib/video.ts
deleted file mode 100644
index f9232497..00000000
--- a/Client/tauri-client/src/lib/video.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-// =============================================================================
-// Video Device Manager — enumerate cameras, acquire streams, stop capture
-// =============================================================================
-
-import { createLogger } from "@lib/logger";
-
-const log = createLogger("video");
-
-export interface VideoDevice {
-  readonly deviceId: string;
-  readonly label: string;
-  readonly kind: "videoinput";
-}
-
-export interface VideoManager {
-  enumerateDevices(): Promise<readonly VideoDevice[]>;
-  getCameraStream(deviceId?: string): Promise<MediaStream>;
-  stopCameraStream(): void;
-  getCurrentStream(): MediaStream | null;
-  onDeviceChange(callback: (devices: readonly VideoDevice[]) => void): () => void;
-  destroy(): void;
-}
-
-type DeviceChangeCallback = (devices: readonly VideoDevice[]) => void;
-
-function toVideoDevice(info: MediaDeviceInfo): VideoDevice | null {
-  if (info.kind !== "videoinput") return null;
-  return {
-    deviceId: info.deviceId,
-    label: info.label || `Camera (${info.deviceId.slice(0, 8)})`,
-    kind: "videoinput",
-  };
-}
-
-export function createVideoManager(): VideoManager {
-  let currentStream: MediaStream | null = null;
-  let destroyed = false;
-
-  const deviceChangeCallbacks = new Set<DeviceChangeCallback>();
-
-  async function listVideoDevices(): Promise<readonly VideoDevice[]> {
-    const devices = await navigator.mediaDevices.enumerateDevices();
-    const videoDevices: VideoDevice[] = [];
-    for (const d of devices) {
-      const mapped = toVideoDevice(d);
-      if (mapped !== null) {
-        videoDevices.push(mapped);
-      }
-    }
-    return videoDevices;
-  }
-
-  function handleDeviceChange(): void {
-    if (destroyed) return;
-    void listVideoDevices().then((devices) => {
-      log.info("Video device change detected", {
-        cameras: devices.length,
-      });
-      for (const cb of deviceChangeCallbacks) {
-        cb(devices);
-      }
-    });
-  }
-
-  navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
-
-  return {
-    async enumerateDevices(): Promise<readonly VideoDevice[]> {
-      if (destroyed) throw new Error("VideoManager has been destroyed");
-      return listVideoDevices();
-    },
-
-    async getCameraStream(deviceId?: string): Promise<MediaStream> {
-      if (destroyed) throw new Error("VideoManager has been destroyed");
-
-      // Stop any existing stream before acquiring a new one
-      if (currentStream !== null) {
-        for (const track of currentStream.getTracks()) {
-          track.stop();
-        }
-        currentStream = null;
-      }
-
-      const constraints: MediaStreamConstraints = {
-        video: {
-          width: { ideal: 1280 },
-          height: { ideal: 720 },
-          deviceId: deviceId !== undefined ? { exact: deviceId } : undefined,
-        },
-        audio: false,
-      };
-
-      const stream = await navigator.mediaDevices.getUserMedia(constraints);
-      currentStream = stream;
-
-      const videoTrack = stream.getVideoTracks()[0];
-      if (videoTrack !== undefined) {
-        const settings = videoTrack.getSettings();
-        log.info("Camera acquired", {
-          deviceId: settings.deviceId ?? deviceId ?? null,
-          width: settings.width,
-          height: settings.height,
-          frameRate: settings.frameRate,
-        });
-      }
-
-      return stream;
-    },
-
-    stopCameraStream(): void {
-      if (currentStream === null) return;
-      for (const track of currentStream.getTracks()) {
-        track.stop();
-      }
-      currentStream = null;
-      log.info("Camera stream stopped");
-    },
-
-    getCurrentStream(): MediaStream | null {
-      return currentStream;
-    },
-
-    onDeviceChange(callback: DeviceChangeCallback): () => void {
-      deviceChangeCallbacks.add(callback);
-      return () => { deviceChangeCallbacks.delete(callback); };
-    },
-
-    destroy(): void {
-      if (destroyed) return;
-      destroyed = true;
-
-      navigator.mediaDevices.removeEventListener("devicechange", handleDeviceChange);
-
-      log.debug("VideoManager destroying", { hasStream: currentStream !== null });
-      if (currentStream !== null) {
-        for (const track of currentStream.getTracks()) {
-          track.stop();
-        }
-        currentStream = null;
-      }
-      deviceChangeCallbacks.clear();
-    },
-  };
-}
diff --git a/Client/tauri-client/src/lib/voiceSession.ts b/Client/tauri-client/src/lib/voiceSession.ts
deleted file mode 100644
index b754e116..00000000
--- a/Client/tauri-client/src/lib/voiceSession.ts
+++ /dev/null
@@ -1,1104 +0,0 @@
-// =============================================================================
-// Voice Session — lifecycle orchestrator for voice chat
-//
-// Manages audio capture, WebRTC connection, remote audio playback, and
-// WS signaling. Singleton module: only one voice session at a time.
-// =============================================================================
-
-import type { WsClient } from "@lib/ws";
-import type { VoiceConfigPayload, IceServer } from "@lib/types";
-import type { WebRtcService } from "@lib/webrtc";
-import type { AudioManager } from "@lib/audio";
-import type { VadDetector } from "@lib/vad";
-import { createWebRtcService } from "@lib/webrtc";
-import { createAudioManager } from "@lib/audio";
-import { createVadDetector, sensitivityToThreshold } from "@lib/vad";
-import { createNoiseSuppressor } from "@lib/noise-suppression";
-import type { NoiseSuppressor } from "@lib/noise-suppression";
-import { voiceStore, setLocalMuted, setLocalDeafened, setLocalSpeaking, setLocalCamera } from "@stores/voice.store";
-import { createVideoManager } from "@lib/video";
-import type { VideoManager } from "@lib/video";
-import { loadPref, savePref } from "@components/settings/helpers";
-import { createLogger } from "@lib/logger";
-
-const log = createLogger("voiceSession");
-
-// ---------------------------------------------------------------------------
-// Module-level state (singleton)
-// ---------------------------------------------------------------------------
-
-let audioManager: AudioManager | null = null;
-let webrtcService: WebRtcService | null = null;
-let vadDetector: VadDetector | null = null;
-let noiseSuppressor: NoiseSuppressor | null = null;
-let localStream: MediaStream | null = null;
-/** The stream actually sent to WebRTC (may be noise-suppressed). */
-let processedStream: MediaStream | null = null;
-let ws: WsClient | null = null;
-let videoManager: VideoManager | null = null;
-let cameraStream: MediaStream | null = null;
-let videoSender: RTCRtpSender | null = null;
-const audioElements = new Map<string, HTMLAudioElement>();
-/** Shared AudioContext for all remote audio processing (avoids browser limit of ~6 contexts). */
-let sharedAudioCtx: AudioContext | null = null;
-
-function getSharedAudioContext(): AudioContext {
-  if (sharedAudioCtx === null || sharedAudioCtx.state === "closed") {
-    // Force 48kHz to match WebRTC Opus output. At high native rates
-    // (e.g. 192kHz), the Web Audio resampling pipeline can introduce
-    // issues or silence when bridging MediaStream → GainNode → destination.
-    sharedAudioCtx = new AudioContext({ sampleRate: 48000 });
-  }
-  return sharedAudioCtx;
-}
-
-/** Map userId → GainNode for per-user volume control (legacy, unused — kept for diagnostics). */
-const userGainNodes = new Map<number, GainNode>();
-/** Map userId → HTMLAudioElement for per-user volume control via element.volume. */
-const userAudioElements = new Map<number, HTMLAudioElement>();
-/** Map stream.id → userId (parsed from server's "user-{id}" stream label). */
-const streamUserMap = new Map<string, number>();
-let audioContainer: HTMLDivElement | null = null;
-
-// Optional error callback for UI feedback (e.g. toast on WebRTC failure)
-let onErrorCallback: ((message: string) => void) | null = null;
-
-// Remote video callbacks
-type RemoteVideoCallback = (userId: number, stream: MediaStream) => void;
-type RemoteVideoRemovedCallback = (userId: number) => void;
-let onRemoteVideoCallback: RemoteVideoCallback | null = null;
-let onRemoteVideoRemovedCallback: RemoteVideoRemovedCallback | null = null;
-
-export function setOnRemoteVideo(cb: RemoteVideoCallback): void {
-  onRemoteVideoCallback = cb;
-}
-
-export function setOnRemoteVideoRemoved(cb: RemoteVideoRemovedCallback): void {
-  onRemoteVideoRemovedCallback = cb;
-}
-
-export function clearOnRemoteVideo(): void {
-  onRemoteVideoCallback = null;
-  onRemoteVideoRemovedCallback = null;
-}
-
-// Track event-unsubscribe functions for cleanup
-let unsubIce: (() => void) | null = null;
-let unsubTrack: (() => void) | null = null;
-let unsubState: (() => void) | null = null;
-let unsubIceState: (() => void) | null = null;
-let unsubVad: (() => void) | null = null;
-
-// ICE restart state
-const ICE_RESTART_DELAY_MS = 5000;
-let iceRestartTimer: ReturnType<typeof setTimeout> | null = null;
-let currentChannelId: number | null = null;
-
-// Guard against concurrent joinVoice calls
-let joinInProgress = false;
-
-// Cached silence suppression preference (avoid localStorage reads in hot path)
-let silenceSuppressionEnabled = true;
-
-/** Update cached silence suppression preference. Called from settings. */
-export function updateSilenceSuppressionPref(): void {
-  silenceSuppressionEnabled = loadPref<boolean>("silenceSuppression", true);
-}
-
-/** Shared VAD speaking callback — includes silence suppression logic. */
-function onVadSpeakingChange(speaking: boolean): void {
-  setLocalSpeaking(speaking);
-  if (silenceSuppressionEnabled && webrtcService !== null) {
-    webrtcService.setSilenced(!speaking);
-  }
-}
-
-/** Pipe a raw mic stream through noise suppression if enabled, returning the
- *  stream to send to WebRTC. Destroys any existing suppressor first. */
-async function applyNoiseSuppression(raw: MediaStream): Promise<MediaStream> {
-  if (noiseSuppressor !== null) {
-    noiseSuppressor.destroy();
-    noiseSuppressor = null;
-  }
-  if (!loadPref<boolean>("enhancedNoiseSuppression", false)) return raw;
-  try {
-    noiseSuppressor = createNoiseSuppressor();
-    const cleaned = await noiseSuppressor.process(raw);
-    log.info("Enhanced noise suppression enabled");
-    return cleaned;
-  } catch (err) {
-    log.warn("Failed to init noise suppression, using raw stream", err);
-    return raw;
-  }
-}
-
-/** Start (or restart) VAD on the stream that's actually sent to WebRTC.
- *  When noise suppression is active, this is the processed stream so the
- *  threshold matches what's transmitted (not raw mic noise). */
-function startVad(stream: MediaStream): void {
-  // Destroy old detector to avoid reusing a closed AudioContext
-  if (vadDetector !== null) {
-    if (unsubVad !== null) { unsubVad(); unsubVad = null; }
-    vadDetector.destroy();
-    vadDetector = null;
-  }
-  const sensitivity = loadPref<number>("voiceSensitivity", 50);
-  vadDetector = createVadDetector({ threshold: sensitivityToThreshold(sensitivity) });
-  vadDetector.start(stream);
-  unsubVad = vadDetector.onSpeakingChange(onVadSpeakingChange);
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Get or create the hidden container for remote audio elements. */
-function getOrCreateAudioContainer(): HTMLDivElement {
-  if (audioContainer !== null) return audioContainer;
-
-  const existing = document.getElementById("voice-audio-container");
-  if (existing instanceof HTMLDivElement) {
-    audioContainer = existing;
-    return audioContainer;
-  }
-
-  const div = document.createElement("div");
-  div.id = "voice-audio-container";
-  div.style.display = "none";
-  document.body.appendChild(div);
-  audioContainer = div;
-  return audioContainer;
-}
-
-/** Parse userId from server's stream label "user-{id}" or "user-{id}-{kind}". Returns 0 if unparseable. */
-function parseUserIdFromStream(stream: MediaStream): number {
-  // The server creates tracks with streamID = "user-{userID}-{kind}" (e.g. "user-42-audio", "user-42-video")
-  const match = stream.id.match(/^user-(\d+)(?:-(?:audio|video))?$/);
-  if (match !== null && match[1] !== undefined) {
-    return Number(match[1]);
-  }
-  // Fallback: check track labels "audio-{userID}"
-  for (const track of stream.getTracks()) {
-    const trackMatch = track.id.match(/^(?:audio|video)-(\d+)$/);
-    if (trackMatch !== null && trackMatch[1] !== undefined) {
-      return Number(trackMatch[1]);
-    }
-  }
-  log.warn("Could not parse userId from remote stream", {
-    streamId: stream.id,
-    trackIds: stream.getTracks().map((t) => t.id),
-  });
-  return 0;
-}
-
-/** Get saved per-user volume (0-200 range, default 100). */
-function getSavedUserVolume(userId: number): number {
-  return loadPref<number>(`userVolume_${userId}`, 100);
-}
-
-/** Add a remote MediaStream as an <audio> element with per-user volume.
- *  Uses HTMLAudioElement.volume directly instead of Web Audio GainNode —
- *  WebView2/Chromium silences remote WebRTC streams routed through
- *  createMediaStreamSource → GainNode → createMediaStreamDestination. */
-function addRemoteStream(stream: MediaStream): void {
-  if (audioElements.has(stream.id)) return;
-
-  const container = getOrCreateAudioContainer();
-  const userId = parseUserIdFromStream(stream);
-  if (userId > 0) {
-    streamUserMap.set(stream.id, userId);
-
-    // Clean up any existing audio element for this user — renegotiation
-    // creates a new stream ID so the old element becomes stale. Without
-    // this, dead audio elements accumulate and degrade playback over time.
-    const oldAudio = userAudioElements.get(userId);
-    if (oldAudio !== undefined) {
-      const oldStreamId = oldAudio.srcObject instanceof MediaStream ? oldAudio.srcObject.id : null;
-      oldAudio.srcObject = null;
-      oldAudio.remove();
-      if (oldStreamId !== null) {
-        audioElements.delete(oldStreamId);
-        streamUserMap.delete(oldStreamId);
-      }
-      userGainNodes.delete(userId);
-      userAudioElements.delete(userId);
-      log.debug("Replaced stale audio element for user", { userId, oldStreamId, newStreamId: stream.id });
-    }
-  }
-
-  const audio = document.createElement("audio");
-  audio.autoplay = true;
-  audio.setAttribute("playsinline", "");
-  audio.srcObject = stream;
-
-  // Apply saved per-user volume via HTMLAudioElement.volume (0.0-1.0 range).
-  // We clamp the stored 0-200 range to 0-100 for element volume.
-  const savedVolume = userId > 0 ? getSavedUserVolume(userId) : 100;
-  audio.volume = Math.min(savedVolume, 100) / 100;
-
-  // Respect current deafen state — if user is deafened, mute this element
-  // immediately so late-arriving streams don't bypass the deafen.
-  if (voiceStore.getState().localDeafened) {
-    audio.muted = true;
-  }
-
-  if (userId > 0) {
-    userAudioElements.set(userId, audio);
-  }
-  log.debug("Remote audio stream attached (direct playback)", { userId, volume: audio.volume });
-
-  // Monitor playback state — autoplay may be blocked by browser policy
-  audio.addEventListener("playing", () => {
-    log.info("Remote audio playing", { streamId: stream.id, userId });
-  });
-  audio.addEventListener("pause", () => {
-    // Ignore pause events that fire before the element is attached to DOM
-    if (!audio.parentElement) return;
-    log.warn("Remote audio paused", { streamId: stream.id, userId });
-  });
-  audio.addEventListener("error", () => {
-    log.error("Remote audio element error", {
-      streamId: stream.id,
-      userId,
-      error: audio.error?.message ?? "unknown",
-      code: audio.error?.code,
-    });
-  });
-
-  // Apply saved output device
-  const savedOutput = loadPref<string>("audioOutputDevice", "");
-  if (savedOutput !== "" && typeof audio.setSinkId === "function") {
-    audio.setSinkId(savedOutput).catch((err) => {
-      log.warn("Failed to set output device on remote audio", err);
-    });
-  }
-
-  // Auto-remove when all tracks end
-  stream.onremovetrack = () => {
-    if (stream.getTracks().length === 0) {
-      audio.srcObject = null;
-      audio.remove();
-      audioElements.delete(stream.id);
-      streamUserMap.delete(stream.id);
-      if (userId > 0) {
-        userGainNodes.delete(userId);
-        userAudioElements.delete(userId);
-      }
-      log.debug("Removed remote audio element", { streamId: stream.id, userId });
-    }
-  };
-
-  container.appendChild(audio);
-  audioElements.set(stream.id, audio);
-  log.debug("Added remote audio element", { streamId: stream.id, userId });
-
-  // Kick playback after DOM attachment — avoids "interrupted by a new load request"
-  // race between autoplay and srcObject assignment.
-  queueMicrotask(() => {
-    if (audio.paused && audio.srcObject !== null) {
-      audio.play().catch((err) => {
-        log.error("Remote audio play() rejected", {
-          streamId: stream.id,
-          userId,
-          error: err instanceof Error ? err.message : String(err),
-        });
-      });
-    }
-  });
-}
-
-/** Attempt to acquire the microphone, falling back to system default. */
-async function acquireMicrophone(): Promise<MediaStream | null> {
-  if (audioManager === null) {
-    audioManager = createAudioManager();
-  }
-
-  const savedDevice = loadPref<string>("audioInputDevice", "");
-
-  // Try saved device first
-  if (savedDevice !== "") {
-    try {
-      return await audioManager.getUserMedia(savedDevice);
-    } catch (err) {
-      log.warn("Failed to use saved input device, trying default", err);
-    }
-  }
-
-  // Fall back to system default
-  try {
-    return await audioManager.getUserMedia();
-  } catch (err) {
-    log.warn("Failed to acquire microphone — entering listen-only mode", err);
-    return null;
-  }
-}
-
-/** Clean up all remote audio elements and per-user gain nodes. */
-function cleanupAudioElements(): void {
-  for (const el of audioElements.values()) {
-    el.srcObject = null;
-    el.remove();
-  }
-  audioElements.clear();
-  userGainNodes.clear();
-  userAudioElements.clear();
-  streamUserMap.clear();
-
-  // Close the shared AudioContext (will be re-created on next join)
-  if (sharedAudioCtx !== null) {
-    void sharedAudioCtx.close();
-    sharedAudioCtx = null;
-  }
-}
-
-/** Attempt ICE restart by creating a new offer with iceRestart flag. */
-async function attemptIceRestart(): Promise<void> {
-  if (webrtcService === null || ws === null || currentChannelId === null) {
-    log.warn("Cannot ICE restart — no active session");
-    return;
-  }
-  try {
-    log.info("Attempting ICE restart", { channelId: currentChannelId });
-    const offerSdp = await webrtcService.createOffer(true);
-    ws.send({
-      type: "voice_offer",
-      payload: { channel_id: currentChannelId, sdp: offerSdp },
-    });
-    log.info("ICE restart offer sent");
-  } catch (err) {
-    log.error("ICE restart failed", err);
-    onErrorCallback?.("Voice reconnection failed — please rejoin");
-    leaveVoice();
-  }
-}
-
-/** Unsubscribe WebRTC and VAD event handlers. */
-function cleanupWebrtcSubs(): void {
-  if (unsubIce !== null) {
-    unsubIce();
-    unsubIce = null;
-  }
-  if (unsubTrack !== null) {
-    unsubTrack();
-    unsubTrack = null;
-  }
-  if (unsubState !== null) {
-    unsubState();
-    unsubState = null;
-  }
-  if (unsubIceState !== null) {
-    unsubIceState();
-    unsubIceState = null;
-  }
-  if (unsubVad !== null) {
-    unsubVad();
-    unsubVad = null;
-  }
-  // Cancel any pending ICE restart
-  if (iceRestartTimer !== null) {
-    clearTimeout(iceRestartTimer);
-    iceRestartTimer = null;
-  }
-  currentChannelId = null;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/** Set the WS client reference used for signaling. */
-export function setWsClient(client: WsClient): void {
-  ws = client;
-}
-
-/** Set error callback for UI feedback (e.g. toast on WebRTC failure). */
-export function setOnError(cb: (message: string) => void): void {
-  onErrorCallback = cb;
-}
-
-/** Clear the error callback (call on component destroy to avoid stale refs). */
-export function clearOnError(): void {
-  onErrorCallback = null;
-}
-
-/**
- * Fetch ICE servers (TURN/STUN credentials) for WebRTC.
- * Falls back to empty array on failure so voice still works on LAN.
- */
-export type IceServerFetcher = () => Promise<readonly IceServer[]>;
-
-/** Join a voice channel: acquire mic, set up WebRTC, send offer. */
-export async function joinVoice(
-  channelId: number,
-  config: VoiceConfigPayload,
-  fetchIceServers?: IceServerFetcher,
-): Promise<void> {
-  if (ws === null) {
-    log.error("Cannot join voice: WS client not set");
-    return;
-  }
-
-  // Prevent concurrent join attempts
-  if (joinInProgress) {
-    log.warn("Join already in progress, ignoring");
-    return;
-  }
-  joinInProgress = true;
-
-  // Clean up any existing voice session to prevent stale callbacks
-  // from killing the new session (don't send voice_leave — server
-  // already handled the channel switch).
-  if (webrtcService !== null) {
-    leaveVoice(false);
-  }
-
-  // Cache silence suppression pref at join time
-  silenceSuppressionEnabled = loadPref<boolean>("silenceSuppression", true);
-
-  try {
-    // 1. Acquire microphone and ICE servers in parallel
-    const [stream, iceServers] = await Promise.all([
-      acquireMicrophone(),
-      fetchIceServers
-        ? fetchIceServers().catch((err) => {
-            log.warn("Failed to fetch ICE servers, falling back to direct", err);
-            return [] as readonly IceServer[];
-          })
-        : Promise.resolve([] as readonly IceServer[]),
-    ]);
-    localStream = stream;
-
-    // 2. Create WebRTC peer connection with TURN/STUN servers
-    webrtcService = createWebRtcService();
-    webrtcService.createConnection({
-      iceServers: iceServers.map((s) => ({
-        urls: s.urls,
-        username: s.username,
-        credential: s.credential,
-      })),
-      opusBitrate: config.bitrate,
-    });
-
-    // 3. Apply noise suppression if enabled, then attach to WebRTC
-    processedStream = localStream !== null
-      ? await applyNoiseSuppression(localStream)
-      : null;
-
-    // 4. Attach local stream if available
-    if (processedStream !== null) {
-      webrtcService.setLocalStream(processedStream);
-    }
-
-    // 5. Wire ICE candidate forwarding
-    unsubIce = webrtcService.onIceCandidate((candidate) => {
-      if (ws === null) return;
-      ws.send({
-        type: "voice_ice",
-        payload: { channel_id: channelId, candidate },
-      });
-    });
-
-    // 6. Wire remote track playback
-    unsubTrack = webrtcService.onRemoteTrack((stream) => {
-      const hasVideo = stream.getVideoTracks().length > 0;
-      const hasAudio = stream.getAudioTracks().length > 0;
-
-      if (hasAudio && !hasVideo) {
-        addRemoteStream(stream);
-      } else if (hasVideo) {
-        const userId = parseUserIdFromStream(stream);
-        if (userId > 0 && onRemoteVideoCallback !== null) {
-          onRemoteVideoCallback(userId, stream);
-        }
-        stream.onremovetrack = () => {
-          if (stream.getTracks().length === 0 && userId > 0) {
-            onRemoteVideoRemovedCallback?.(userId);
-          }
-        };
-      }
-    });
-
-    // 7. Wire connection state monitoring
-    unsubState = webrtcService.onStateChange((state) => {
-      log.info("WebRTC connection state changed", { state });
-      if (state === "failed") {
-        log.error("WebRTC connection failed, leaving voice");
-        onErrorCallback?.("Voice connection failed — disconnected");
-        leaveVoice();
-      }
-    });
-
-    // 7b. Wire ICE connection state for automatic ICE restart
-    currentChannelId = channelId;
-    unsubIceState = webrtcService.onIceStateChange((state) => {
-      log.info("ICE connection state changed", { state });
-
-      if (state === "disconnected") {
-        // Start timer — ICE may self-recover. If not, restart after delay.
-        if (iceRestartTimer === null) {
-          log.info("ICE disconnected, scheduling restart", { delayMs: ICE_RESTART_DELAY_MS });
-          iceRestartTimer = setTimeout(() => {
-            iceRestartTimer = null;
-            void attemptIceRestart();
-          }, ICE_RESTART_DELAY_MS);
-        }
-      } else if (state === "connected" || state === "completed") {
-        // ICE recovered on its own — cancel pending restart
-        if (iceRestartTimer !== null) {
-          log.info("ICE recovered, cancelling restart timer");
-          clearTimeout(iceRestartTimer);
-          iceRestartTimer = null;
-        }
-      } else if (state === "failed") {
-        // ICE failed — attempt restart immediately
-        if (iceRestartTimer !== null) {
-          clearTimeout(iceRestartTimer);
-          iceRestartTimer = null;
-        }
-        void attemptIceRestart();
-      }
-    });
-
-    // 8. Start VAD on the processed stream (so threshold matches what's sent)
-    if (localStream !== null && processedStream !== null) {
-      startVad(processedStream);
-    }
-
-    // 9. Create and send SDP offer (guard: session may have been destroyed
-    //    by a connection-failed event firing between wire-up and offer)
-    if (webrtcService === null) {
-      log.warn("WebRTC service destroyed before offer — aborting join");
-      return;
-    }
-    // If the server already sent us an offer (renegotiation arrived before we
-    // could create ours), we're in have-remote-offer state — skip our offer.
-    // The handleServerOffer path will send an answer instead.
-    try {
-      const offerSdp = await webrtcService.createOffer();
-      ws.send({
-        type: "voice_offer",
-        payload: { channel_id: channelId, sdp: offerSdp },
-      });
-    } catch (offerErr) {
-      // Likely "Called in wrong state: have-remote-offer" — server renegotiation
-      // arrived first. The onRemoteTrack + handleServerOffer path handles it.
-      log.info("Skipping initial offer — server offer arrived first", {
-        error: offerErr instanceof Error ? offerErr.message : String(offerErr),
-      });
-    }
-
-    log.info("Joined voice channel", { channelId });
-  } catch (err) {
-    log.error("Failed to join voice channel", err);
-    leaveVoice();
-  } finally {
-    joinInProgress = false;
-  }
-}
-
-/**
- * Leave the current voice session and clean up all resources.
- * If sendWs is true (default), also notifies the server via voice_leave.
- * Pass sendWs=false when the server already knows (e.g. explicit UI leave
- * that sends voice_leave separately).
- */
-export function leaveVoice(sendWs = true): void {
-  // Notify server so it cleans up our voice state
-  if (sendWs && ws !== null) {
-    ws.send({ type: "voice_leave", payload: {} });
-  }
-  // Clear join guard so a new join can proceed after leave
-  joinInProgress = false;
-
-  // Stop camera stream
-  if (cameraStream !== null) {
-    for (const track of cameraStream.getTracks()) {
-      track.stop();
-    }
-    cameraStream = null;
-    videoSender = null;
-  }
-
-  // Stop processedStream tracks first (before nulling localStream so guard works)
-  if (processedStream !== null && processedStream !== localStream) {
-    for (const track of processedStream.getTracks()) {
-      track.stop();
-    }
-  }
-  processedStream = null;
-
-  // Stop all local media tracks
-  if (localStream !== null) {
-    for (const track of localStream.getTracks()) {
-      track.stop();
-    }
-    localStream = null;
-  }
-
-  // Destroy VAD
-  if (vadDetector !== null) {
-    vadDetector.destroy();
-    vadDetector = null;
-  }
-
-  // Clean up WebRTC subscriptions before destroying
-  cleanupWebrtcSubs();
-
-  // Destroy noise suppressor
-  if (noiseSuppressor !== null) {
-    noiseSuppressor.destroy();
-    noiseSuppressor = null;
-  }
-
-  // Destroy WebRTC
-  if (webrtcService !== null) {
-    webrtcService.destroy();
-    webrtcService = null;
-  }
-
-  // Clean up remote audio playback
-  cleanupAudioElements();
-
-  // Destroy audio manager
-  if (audioManager !== null) {
-    audioManager.destroy();
-    audioManager = null;
-  }
-
-  // Destroy video manager
-  if (videoManager !== null) {
-    videoManager.destroy();
-    videoManager = null;
-  }
-
-  log.info("Left voice session");
-}
-
-/** Mute or unmute the local microphone. */
-export function setMuted(muted: boolean): void {
-  setLocalMuted(muted);
-  if (webrtcService !== null) {
-    // Mute via track.enabled — no renegotiation, instant, no race conditions.
-    webrtcService.setMuted(muted);
-  } else {
-    // Fallback for listen-only mode (no WebRTC): disable raw mic tracks
-    if (localStream !== null) {
-      for (const track of localStream.getAudioTracks()) {
-        track.enabled = !muted;
-      }
-    }
-  }
-}
-
-/** Deafen or undeafen — mutes all remote audio playback. */
-export function setDeafened(deafened: boolean): void {
-  setLocalDeafened(deafened);
-  for (const el of audioElements.values()) {
-    el.muted = deafened;
-  }
-  log.debug("Deafen state changed", { deafened, audioElements: audioElements.size });
-}
-
-/** Enable camera: acquire webcam, add video track to WebRTC, notify server. */
-export async function enableCamera(): Promise<void> {
-  if (webrtcService === null || ws === null || currentChannelId === null) {
-    log.warn("Cannot enable camera: no active voice session");
-    onErrorCallback?.("Join a voice channel first");
-    return;
-  }
-
-  if (cameraStream !== null) {
-    log.debug("Camera already enabled");
-    return;
-  }
-
-  if (videoManager === null) {
-    videoManager = createVideoManager();
-  }
-
-  try {
-    const savedDevice = loadPref<string>("videoInputDevice", "");
-    cameraStream = savedDevice !== ""
-      ? await videoManager.getCameraStream(savedDevice)
-      : await videoManager.getCameraStream();
-
-    const videoTrack = cameraStream.getVideoTracks()[0];
-    if (videoTrack !== undefined) {
-      videoTrack.addEventListener("ended", () => {
-        log.warn("Camera track ended unexpectedly (device disconnected?)");
-        void disableCamera();
-        onErrorCallback?.("Camera disconnected");
-      });
-    }
-
-    videoSender = webrtcService.addVideoTrack(cameraStream);
-
-    if (webrtcService !== null && ws !== null) {
-      const offerSdp = await webrtcService.createOffer();
-      ws.send({
-        type: "voice_offer",
-        payload: { channel_id: currentChannelId, sdp: offerSdp },
-      });
-    }
-
-    // Notify server and update store AFTER successful track addition
-    setLocalCamera(true);
-    ws.send({ type: "voice_camera", payload: { enabled: true } });
-
-    log.info("Camera enabled", { channelId: currentChannelId });
-  } catch (err) {
-    log.error("Failed to enable camera", err);
-    cameraStream = null;
-    videoSender = null;
-
-    if (err instanceof DOMException && err.name === "NotAllowedError") {
-      onErrorCallback?.("Camera permission denied");
-    } else if (err instanceof DOMException && err.name === "NotFoundError") {
-      onErrorCallback?.("No camera found");
-    } else {
-      onErrorCallback?.("Failed to start camera");
-    }
-  }
-}
-
-/** Disable camera: stop stream, remove video track, notify server. */
-export async function disableCamera(): Promise<void> {
-  if (cameraStream !== null) {
-    for (const track of cameraStream.getTracks()) {
-      track.stop();
-    }
-    cameraStream = null;
-  }
-
-  if (videoSender !== null && webrtcService !== null) {
-    webrtcService.removeVideoTrack(videoSender);
-    videoSender = null;
-
-    if (ws !== null && currentChannelId !== null) {
-      try {
-        const offerSdp = await webrtcService.createOffer();
-        ws.send({
-          type: "voice_offer",
-          payload: { channel_id: currentChannelId, sdp: offerSdp },
-        });
-      } catch (err) {
-        log.error("Failed to renegotiate after camera disable", err);
-      }
-    }
-  }
-
-  setLocalCamera(false);
-  if (ws !== null) {
-    ws.send({ type: "voice_camera", payload: { enabled: false } });
-  }
-
-  log.info("Camera disabled");
-}
-
-/** Switch the input (microphone) device on an active session. */
-export async function switchInputDevice(deviceId: string): Promise<void> {
-  // Don't acquire microphone if there's no active voice session
-  if (webrtcService === null) {
-    log.debug("Skipping input device switch — no active voice session");
-    return;
-  }
-  if (audioManager === null) {
-    audioManager = createAudioManager();
-  }
-
-  // Save old state so we can roll back on failure
-  const oldLocalStream = localStream;
-  const oldProcessedStream = processedStream;
-  const oldSuppressor = noiseSuppressor;
-
-  try {
-    const newStream = await audioManager.getUserMedia(deviceId || undefined);
-    if (newStream === null) return;
-
-    // Guard: session may have ended during the async getUserMedia call
-    if (webrtcService === null) {
-      for (const track of newStream.getTracks()) track.stop();
-      return;
-    }
-
-    // Temporarily detach old suppressor so applyNoiseSuppression doesn't
-    // destroy it — we need the old pipeline alive for rollback on failure.
-    noiseSuppressor = null;
-    let newProcessed: MediaStream;
-    try {
-      newProcessed = await applyNoiseSuppression(newStream);
-    } catch (err) {
-      // Noise suppression failed — restore old suppressor, stop new stream
-      noiseSuppressor = oldSuppressor;
-      log.warn("Noise suppression failed during device switch, keeping old device", err);
-      for (const track of newStream.getTracks()) track.stop();
-      onErrorCallback?.("Failed to switch microphone — noise suppression error");
-      return;
-    }
-
-    // Guard: session may have ended during noise suppression setup
-    if (webrtcService === null) {
-      if (newProcessed !== newStream) {
-        for (const track of newProcessed.getTracks()) track.stop();
-      }
-      for (const track of newStream.getTracks()) track.stop();
-      return;
-    }
-
-    // Swap track on WebRTC sender — no renegotiation needed
-    await webrtcService.replaceTrack(newProcessed);
-
-    // Success — update module state and stop old tracks
-    localStream = newStream;
-    processedStream = newProcessed;
-
-    // Restart VAD on processed stream with full silence suppression
-    startVad(newProcessed);
-
-    // NOW clean up old resources (after new pipeline is fully wired)
-    if (oldSuppressor !== null && oldSuppressor !== noiseSuppressor) {
-      oldSuppressor.destroy();
-    }
-    if (oldProcessedStream !== null && oldProcessedStream !== oldLocalStream) {
-      for (const track of oldProcessedStream.getTracks()) {
-        track.stop();
-      }
-    }
-    if (oldLocalStream !== null) {
-      for (const track of oldLocalStream.getTracks()) {
-        track.stop();
-      }
-    }
-
-    log.info("Switched input device", { deviceId });
-  } catch (err) {
-    log.error("Failed to switch input device", err);
-    onErrorCallback?.("Failed to switch microphone");
-  }
-}
-
-/** Switch the output (speaker) device on an active session. */
-export async function switchOutputDevice(deviceId: string): Promise<void> {
-  let hadError = false;
-  for (const el of audioElements.values()) {
-    if (typeof el.setSinkId === "function") {
-      try {
-        await el.setSinkId(deviceId);
-      } catch (err) {
-        log.error("Failed to set output device on audio element", err);
-        hadError = true;
-      }
-    }
-  }
-  if (hadError) {
-    onErrorCallback?.("Failed to switch some audio to new speaker");
-  }
-  log.info("Switched output device", { deviceId });
-}
-
-/**
- * Set per-user volume (0-200%). Persisted to localStorage.
- * Like Discord, this only affects YOUR playback of that user's audio.
- * Note: HTMLAudioElement.volume only supports 0.0-1.0, so volumes above
- * 100% are clamped. For boost beyond 100%, a Web Audio GainNode would
- * be needed, but WebView2 silences remote WebRTC streams through GainNode.
- */
-export function setUserVolume(userId: number, volume: number): void {
-  const clamped = Math.max(0, Math.min(200, volume));
-  savePref(`userVolume_${userId}`, clamped);
-
-  const audioEl = userAudioElements.get(userId);
-  if (audioEl !== undefined) {
-    audioEl.volume = Math.min(clamped, 100) / 100;
-  }
-}
-
-/** Get the current per-user volume (0-200%, default 100). */
-export function getUserVolume(userId: number): number {
-  return getSavedUserVolume(userId);
-}
-
-/** Update the VAD sensitivity threshold on an active session. */
-export function setVoiceSensitivity(sensitivity: number): void {
-  if (vadDetector === null) return;
-  vadDetector.setThreshold(sensitivityToThreshold(sensitivity));
-}
-
-/** Get raw WebRTC remote streams for diagnostics (before GainNode). */
-export function getRemoteStreams(): readonly MediaStream[] {
-  return webrtcService?.getRemoteStreams() ?? [];
-}
-
-/** Get the local processed stream for diagnostics. */
-export function getLocalProcessedStream(): MediaStream | null {
-  return processedStream;
-}
-
-/** Handle an SDP offer from the server (re-negotiation). */
-export async function handleServerOffer(
-  sdp: string,
-  channelId: number,
-): Promise<void> {
-  if (webrtcService === null) {
-    log.warn("Received server offer but no WebRTC service active");
-    return;
-  }
-  if (ws === null) {
-    log.warn("Received server offer but no WS client set");
-    return;
-  }
-
-  try {
-    const answerSdp = await webrtcService.handleServerOffer(sdp);
-    ws.send({
-      type: "voice_answer",
-      payload: { channel_id: channelId, sdp: answerSdp },
-    });
-    log.debug("Responded to server offer with answer", { channelId });
-  } catch (err) {
-    log.error("Failed to handle server offer", err);
-  }
-}
-
-/** Handle an SDP answer from the server. */
-export async function handleServerAnswer(sdp: string): Promise<void> {
-  if (webrtcService === null) {
-    log.warn("Received server answer but no WebRTC service active");
-    return;
-  }
-
-  try {
-    await webrtcService.handleAnswer(sdp);
-    log.debug("Applied server answer");
-  } catch (err) {
-    log.error("Failed to handle server answer", err);
-  }
-}
-
-/** Measure RMS audio level on a MediaStream (0-1). Returns 0 if no data. */
-export function measureStreamLevel(stream: MediaStream): Promise<number> {
-  return new Promise((resolve) => {
-    try {
-      const ctx = new AudioContext({ sampleRate: 48000 });
-      const source = ctx.createMediaStreamSource(stream);
-      const analyser = ctx.createAnalyser();
-      analyser.fftSize = 256;
-      source.connect(analyser);
-      const data = new Uint8Array(analyser.frequencyBinCount);
-
-      // Wait a few frames for data to flow
-      let attempts = 0;
-      const check = (): void => {
-        analyser.getByteFrequencyData(data);
-        let sum = 0;
-        for (let i = 0; i < data.length; i++) {
-          const v = (data[i] ?? 0) / 255;
-          sum += v * v;
-        }
-        const rms = Math.sqrt(sum / data.length);
-        attempts++;
-        if (rms > 0 || attempts >= 10) {
-          source.disconnect();
-          void ctx.close();
-          resolve(Math.round(rms * 1000) / 1000);
-        } else {
-          setTimeout(check, 50);
-        }
-      };
-      setTimeout(check, 100);
-    } catch {
-      resolve(-1);
-    }
-  });
-}
-
-/** Get the local camera stream for self-view display. */
-export function getLocalCameraStream(): MediaStream | null {
-  return cameraStream;
-}
-
-/** Snapshot of current voice session state for debugging. */
-export function getSessionDebugInfo(): Record<string, unknown> {
-  // Gather detailed remote track info
-  const remoteTrackDetails: Record<string, unknown>[] = [];
-  for (const [streamId, audioEl] of audioElements.entries()) {
-    const userId = streamUserMap.get(streamId) ?? 0;
-    const gainNode = userId > 0 ? userGainNodes.get(userId) : undefined;
-    const srcObj = audioEl.srcObject as MediaStream | null;
-    const tracks = srcObj?.getAudioTracks() ?? [];
-    const trackInfo = tracks.map((t) => ({
-      id: t.id,
-      enabled: t.enabled,
-      muted: t.muted,
-      readyState: t.readyState,
-    }));
-
-    remoteTrackDetails.push({
-      streamId,
-      userId,
-      audioPaused: audioEl.paused,
-      audioMuted: audioEl.muted,
-      audioVolume: audioEl.volume,
-      audioReadyState: audioEl.readyState,
-      hasSrcObject: audioEl.srcObject !== null,
-      gainValue: gainNode?.gain.value ?? "no-node",
-      tracks: trackInfo,
-    });
-  }
-
-  // Local track info
-  const localTracks = processedStream?.getAudioTracks() ?? [];
-  const localTrackInfo = localTracks.map((t) => ({
-    id: t.id,
-    enabled: t.enabled,
-    muted: t.muted,
-    readyState: t.readyState,
-  }));
-
-  // WebRTC remote streams info
-  const webrtcRemoteStreams = webrtcService?.getRemoteStreams() ?? [];
-  const webrtcRemoteInfo = webrtcRemoteStreams.map((s) => ({
-    streamId: s.id,
-    trackCount: s.getTracks().length,
-    audioTracks: s.getAudioTracks().map((t) => ({
-      id: t.id,
-      enabled: t.enabled,
-      muted: t.muted,
-      readyState: t.readyState,
-    })),
-  }));
-
-  return {
-    hasAudioManager: audioManager !== null,
-    hasWebrtc: webrtcService !== null,
-    hasVad: vadDetector !== null,
-    hasNoiseSuppressor: noiseSuppressor !== null,
-    hasLocalStream: localStream !== null,
-    hasProcessedStream: processedStream !== null,
-    joinInProgress,
-    silenceSuppressionEnabled,
-    sharedAudioCtx: sharedAudioCtx !== null
-      ? { state: sharedAudioCtx.state, sampleRate: sharedAudioCtx.sampleRate }
-      : null,
-    localTracks: localTrackInfo,
-    remoteAudioElements: remoteTrackDetails,
-    webrtcRemoteStreams: webrtcRemoteInfo,
-  };
-}
-
-/** Handle an ICE candidate from the server. */
-export async function handleServerIce(
-  candidate: RTCIceCandidateInit,
-): Promise<void> {
-  if (webrtcService === null) {
-    log.warn("Received ICE candidate but no WebRTC service active");
-    return;
-  }
-
-  try {
-    await webrtcService.handleIceCandidate(candidate);
-    log.debug("Added server ICE candidate");
-  } catch (err) {
-    log.error("Failed to handle server ICE candidate", err);
-  }
-}
diff --git a/Client/tauri-client/src/lib/webrtc.ts b/Client/tauri-client/src/lib/webrtc.ts
deleted file mode 100644
index 02603cf0..00000000
--- a/Client/tauri-client/src/lib/webrtc.ts
+++ /dev/null
@@ -1,394 +0,0 @@
-// =============================================================================
-// WebRTC Service — peer connection management for voice communication
-// =============================================================================
-
-import { createLogger } from "@lib/logger";
-
-const log = createLogger("webrtc");
-
-export interface WebRtcConfig {
-  readonly iceServers: readonly RTCIceServer[];
-  readonly opusBitrate?: number;
-}
-
-export interface WebRtcService {
-  createConnection(config: WebRtcConfig): void;
-  handleOffer(sdp: string): Promise<string>;
-  handleAnswer(sdp: string): Promise<void>;
-  handleServerOffer(sdp: string): Promise<string>;
-  createOffer(iceRestart?: boolean): Promise<string>;
-  handleIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
-  /** Add a video track to the PeerConnection. Returns the sender for removal. */
-  addVideoTrack(stream: MediaStream): RTCRtpSender | null;
-  /** Remove the video track sender from the PeerConnection. */
-  removeVideoTrack(sender: RTCRtpSender): void;
-  setLocalStream(stream: MediaStream): void;
-  /** Swap the media track on existing senders without SDP renegotiation. */
-  replaceTrack(stream: MediaStream): Promise<void>;
-  getRemoteStreams(): readonly MediaStream[];
-  setMuted(muted: boolean): void;
-  setSilenced(silenced: boolean): void;
-  onIceCandidate(callback: (candidate: RTCIceCandidateInit) => void): () => void;
-  onRemoteTrack(callback: (stream: MediaStream) => void): () => void;
-  onStateChange(callback: (state: RTCPeerConnectionState) => void): () => void;
-  onIceStateChange(callback: (state: RTCIceConnectionState) => void): () => void;
-  destroy(): void;
-}
-
-type IceCandidateCallback = (candidate: RTCIceCandidateInit) => void;
-type RemoteTrackCallback = (stream: MediaStream) => void;
-type StateChangeCallback = (state: RTCPeerConnectionState) => void;
-type IceStateCallback = (state: RTCIceConnectionState) => void;
-
-/** Apply Opus bitrate and FEC constraints via SDP munging. */
-function applyOpusSettings(sdp: string, bitrate: number | undefined): string {
-  const lines = sdp.split("\r\n");
-  const result: string[] = [];
-  let inAudioSection = false;
-  let bitrateInserted = false;
-
-  for (let i = 0; i < lines.length; i++) {
-    let line = lines[i];
-    if (line === undefined) continue;
-
-    // Track which media section we're in
-    if (line.startsWith("m=audio")) {
-      inAudioSection = true;
-      bitrateInserted = false;
-    } else if (line.startsWith("m=")) {
-      inAudioSection = false;
-    }
-
-    // Enable Opus in-band FEC for packet loss resilience
-    if (line.startsWith("a=fmtp:111 ")) {
-      if (!line.includes("useinbandfec=")) {
-        line += ";useinbandfec=1";
-      }
-    }
-
-    result.push(line);
-
-    // Insert b=AS after m=audio line (always present, unlike c= which may
-    // only exist at session level)
-    if (inAudioSection && !bitrateInserted && bitrate !== undefined && line.startsWith("m=audio")) {
-      result.push(`b=AS:${Math.round(bitrate / 1000)}`);
-      bitrateInserted = true;
-    }
-  }
-  return result.join("\r\n");
-}
-
-export function createWebRtcService(): WebRtcService {
-  let pc: RTCPeerConnection | null = null;
-  let localSenders: readonly RTCRtpSender[] = [];
-  let isMuted = false;
-  let isSilenced = false;
-  let remoteStreams: readonly MediaStream[] = [];
-  let opusBitrate: number | undefined;
-  let destroyed = false;
-  /** True once setRemoteDescription has been called (ICE candidates are safe). */
-  let hasRemoteDescription = false;
-  /** Queue ICE candidates that arrive before the remote description is set. */
-  const pendingIceCandidates: RTCIceCandidateInit[] = [];
-
-  const iceCandidateCallbacks = new Set<IceCandidateCallback>();
-  const remoteTrackCallbacks = new Set<RemoteTrackCallback>();
-  const stateChangeCallbacks = new Set<StateChangeCallback>();
-  const iceStateCallbacks = new Set<IceStateCallback>();
-
-  function assertConnection(): RTCPeerConnection {
-    if (destroyed) throw new Error("WebRTC service has been destroyed");
-    if (pc === null) throw new Error("No peer connection created");
-    return pc;
-  }
-
-  /** Flush queued ICE candidates now that the remote description is set. */
-  async function flushIceCandidates(conn: RTCPeerConnection): Promise<void> {
-    hasRemoteDescription = true;
-    const queued = pendingIceCandidates.splice(0);
-    if (queued.length > 0) {
-      log.debug("Flushing queued ICE candidates", { count: queued.length });
-    }
-    for (const c of queued) {
-      await conn.addIceCandidate(c);
-    }
-  }
-
-  /** Apply track.enabled based on current mute + silence state. */
-  function applyTrackEnabled(): void {
-    for (const sender of localSenders) {
-      const track = sender.track;
-      if (track !== null) {
-        track.enabled = !isMuted && !isSilenced;
-      }
-    }
-  }
-
-  function handleIceCandidateEvent(event: RTCPeerConnectionIceEvent): void {
-    if (event.candidate === null) {
-      log.debug("ICE gathering complete");
-      return;
-    }
-    const c = event.candidate;
-    log.debug("Local ICE candidate", {
-      type: c.type,
-      address: c.address,
-      port: c.port,
-      protocol: c.protocol,
-      candidate: c.candidate,
-    });
-    const init: RTCIceCandidateInit = {
-      candidate: c.candidate,
-      sdpMid: c.sdpMid,
-      sdpMLineIndex: c.sdpMLineIndex,
-    };
-    for (const cb of iceCandidateCallbacks) {
-      cb(init);
-    }
-  }
-
-  function handleTrackEvent(event: RTCTrackEvent): void {
-    const stream = event.streams[0];
-    if (stream === undefined) {
-      log.warn("Remote track event with no stream");
-      return;
-    }
-    const isNew = !remoteStreams.some((s) => s.id === stream.id);
-    if (isNew) {
-      remoteStreams = [...remoteStreams, stream];
-    }
-    log.info("Remote track received", {
-      streamId: stream.id,
-      trackId: event.track.id,
-      kind: event.track.kind,
-      isNew,
-      totalStreams: remoteStreams.length,
-    });
-    // Always notify — renegotiation may add new tracks to existing
-    // streams (e.g. after leave/rejoin with the same stream ID).
-    for (const cb of remoteTrackCallbacks) {
-      cb(stream);
-    }
-  }
-
-  function handleConnectionStateChange(): void {
-    if (pc === null) return;
-    const state = pc.connectionState;
-    for (const cb of stateChangeCallbacks) {
-      cb(state);
-    }
-  }
-
-  function handleIceConnectionStateChange(): void {
-    if (pc === null) return;
-    const state = pc.iceConnectionState;
-    for (const cb of iceStateCallbacks) {
-      cb(state);
-    }
-  }
-
-  function handleNegotiationNeeded(): void {
-    // Log canary — if this fires, something triggered SDP renegotiation
-    // that our explicit offer/answer flow didn't handle. Upgrade to a
-    // full handler (auto-create offer) if this shows up in production.
-    log.warn("negotiationneeded fired unexpectedly", { signalingState: pc?.signalingState ?? "none" });
-  }
-
-  function mungeIfNeeded(sdp: string | undefined): string {
-    if (sdp === undefined) return "";
-    return applyOpusSettings(sdp, opusBitrate);
-  }
-
-  return {
-    createConnection(config: WebRtcConfig): void {
-      if (destroyed) throw new Error("WebRTC service has been destroyed");
-      if (pc !== null) {
-        pc.close();
-      }
-      opusBitrate = config.opusBitrate;
-      remoteStreams = [];
-      localSenders = [];
-      isMuted = false;
-      isSilenced = false;
-      hasRemoteDescription = false;
-      pendingIceCandidates.length = 0;
-
-      pc = new RTCPeerConnection({
-        iceServers: [...config.iceServers],
-      });
-      pc.addEventListener("icecandidate", handleIceCandidateEvent);
-      pc.addEventListener("track", handleTrackEvent);
-      pc.addEventListener("connectionstatechange", handleConnectionStateChange);
-      pc.addEventListener("iceconnectionstatechange", handleIceConnectionStateChange);
-      pc.addEventListener("negotiationneeded", handleNegotiationNeeded);
-      log.info("PeerConnection created", {
-        iceServerCount: config.iceServers.length,
-        opusBitrate: config.opusBitrate,
-      });
-    },
-
-    async handleOffer(sdp: string): Promise<string> {
-      const conn = assertConnection();
-      await conn.setRemoteDescription({ type: "offer", sdp });
-      await flushIceCandidates(conn);
-      const answer = await conn.createAnswer();
-      const mungedSdp = mungeIfNeeded(answer.sdp);
-      await conn.setLocalDescription({ type: "answer", sdp: mungedSdp });
-      return mungedSdp;
-    },
-
-    async handleAnswer(sdp: string): Promise<void> {
-      const conn = assertConnection();
-      await conn.setRemoteDescription({ type: "answer", sdp });
-      await flushIceCandidates(conn);
-    },
-
-    async handleServerOffer(sdp: string): Promise<string> {
-      const conn = assertConnection();
-      if (conn.signalingState === "have-local-offer") {
-        log.info("Rolling back local offer for server renegotiation (glare)");
-        await conn.setLocalDescription({ type: "rollback" });
-      }
-      await conn.setRemoteDescription({ type: "offer", sdp });
-      await flushIceCandidates(conn);
-      const answer = await conn.createAnswer();
-      const mungedSdp = mungeIfNeeded(answer.sdp);
-      await conn.setLocalDescription({ type: "answer", sdp: mungedSdp });
-      return mungedSdp;
-    },
-
-    async createOffer(iceRestart = false): Promise<string> {
-      const conn = assertConnection();
-      const offer = await conn.createOffer({ iceRestart });
-      const mungedSdp = mungeIfNeeded(offer.sdp);
-      await conn.setLocalDescription({ type: "offer", sdp: mungedSdp });
-      return mungedSdp;
-    },
-
-    async handleIceCandidate(candidate: RTCIceCandidateInit): Promise<void> {
-      const conn = assertConnection();
-      if (!hasRemoteDescription) {
-        pendingIceCandidates.push(candidate);
-        log.debug("ICE candidate queued (no remote description yet)", { queueDepth: pendingIceCandidates.length });
-        return;
-      }
-      await conn.addIceCandidate(candidate);
-    },
-
-    setLocalStream(stream: MediaStream): void {
-      const conn = assertConnection();
-      const removedCount = localSenders.length;
-      for (const sender of localSenders) {
-        conn.removeTrack(sender);
-      }
-
-      const newSenders = stream.getTracks().map((track) => conn.addTrack(track, stream));
-      localSenders = newSenders;
-
-      // Apply current mute/silence state to new tracks
-      applyTrackEnabled();
-      log.debug("Local stream set", { removedSenders: removedCount, addedTracks: newSenders.length });
-    },
-
-    async replaceTrack(stream: MediaStream): Promise<void> {
-      assertConnection();
-      const newTracks = stream.getAudioTracks();
-      if (newTracks.length === 0) {
-        log.warn("replaceTrack called with no audio tracks");
-        return;
-      }
-      const newTrack = newTracks[0]!;
-
-      if (localSenders.length > 0) {
-        // Swap track on existing sender — no SDP renegotiation needed
-        for (const sender of localSenders) {
-          await sender.replaceTrack(newTrack);
-        }
-        log.debug("Track replaced on existing senders", { senderCount: localSenders.length, trackId: newTrack.id });
-      } else {
-        // No existing senders — fall back to addTrack (initial attach)
-        log.debug("replaceTrack fallback: no senders, using addTrack");
-        const conn = assertConnection();
-        const newSenders = stream.getTracks().map((track) => conn.addTrack(track, stream));
-        localSenders = newSenders;
-      }
-
-      // Apply current mute/silence state to the new track
-      applyTrackEnabled();
-    },
-
-    addVideoTrack(stream: MediaStream): RTCRtpSender | null {
-      const conn = assertConnection();
-      const videoTrack = stream.getVideoTracks()[0];
-      if (videoTrack === undefined) {
-        log.warn("addVideoTrack called with no video tracks");
-        return null;
-      }
-      const sender = conn.addTrack(videoTrack, stream);
-      log.info("Video track added to PeerConnection", { trackId: videoTrack.id });
-      return sender;
-    },
-
-    removeVideoTrack(sender: RTCRtpSender): void {
-      const conn = assertConnection();
-      conn.removeTrack(sender);
-      log.info("Video track removed from PeerConnection");
-    },
-
-    getRemoteStreams(): readonly MediaStream[] {
-      return remoteStreams;
-    },
-
-    setMuted(muted: boolean): void {
-      isMuted = muted;
-      applyTrackEnabled();
-    },
-
-    setSilenced(silenced: boolean): void {
-      isSilenced = silenced;
-      applyTrackEnabled();
-    },
-
-    onIceCandidate(callback: IceCandidateCallback): () => void {
-      iceCandidateCallbacks.add(callback);
-      return () => { iceCandidateCallbacks.delete(callback); };
-    },
-
-    onRemoteTrack(callback: RemoteTrackCallback): () => void {
-      remoteTrackCallbacks.add(callback);
-      return () => { remoteTrackCallbacks.delete(callback); };
-    },
-
-    onStateChange(callback: StateChangeCallback): () => void {
-      stateChangeCallbacks.add(callback);
-      return () => { stateChangeCallbacks.delete(callback); };
-    },
-
-    onIceStateChange(callback: IceStateCallback): () => void {
-      iceStateCallbacks.add(callback);
-      return () => { iceStateCallbacks.delete(callback); };
-    },
-
-    destroy(): void {
-      if (destroyed) return;
-      destroyed = true;
-      log.debug("WebRTC service destroying", { remoteStreams: remoteStreams.length, localSenders: localSenders.length });
-      if (pc !== null) {
-        pc.removeEventListener("icecandidate", handleIceCandidateEvent);
-        pc.removeEventListener("track", handleTrackEvent);
-        pc.removeEventListener("connectionstatechange", handleConnectionStateChange);
-        pc.removeEventListener("iceconnectionstatechange", handleIceConnectionStateChange);
-        pc.removeEventListener("negotiationneeded", handleNegotiationNeeded);
-        pc.close();
-        pc = null;
-      }
-      localSenders = [];
-      remoteStreams = [];
-      pendingIceCandidates.length = 0;
-      iceCandidateCallbacks.clear();
-      remoteTrackCallbacks.clear();
-      stateChangeCallbacks.clear();
-      iceStateCallbacks.clear();
-    },
-  };
-}
diff --git a/Client/tauri-client/src/main.ts b/Client/tauri-client/src/main.ts
index bd52dfb7..1e0174f8 100644
--- a/Client/tauri-client/src/main.ts
+++ b/Client/tauri-client/src/main.ts
@@ -12,7 +12,7 @@ import { createWsClient } from "@lib/ws";
 import { wireDispatcher } from "@lib/dispatcher";
 import { authStore, setAuth, clearAuth } from "@stores/auth.store";
 import { voiceStore, leaveVoiceChannel } from "@stores/voice.store";
-import { leaveVoice as voiceSessionLeave } from "@lib/voiceSession";
+import { leaveVoice as voiceSessionLeave } from "@lib/livekitSession";
 import { createConnectPage } from "@pages/ConnectPage";
 import { createMainPage } from "@pages/MainPage";
 import { applyStoredAppearance } from "@components/SettingsOverlay";
diff --git a/Client/tauri-client/src/pages/MainPage.ts b/Client/tauri-client/src/pages/MainPage.ts
index 719f0e1c..eda2d1f1 100644
--- a/Client/tauri-client/src/pages/MainPage.ts
+++ b/Client/tauri-client/src/pages/MainPage.ts
@@ -27,7 +27,6 @@ import { closeSettings, toggleMemberList, uiStore } from "@stores/ui.store";
 import { channelsStore, getActiveChannel } from "@stores/channels.store";
 import { voiceStore } from "@stores/voice.store";
 import {
-  joinVoice,
   leaveVoice as voiceSessionLeave,
   setOnRemoteVideo,
   setOnRemoteVideoRemoved,
@@ -35,7 +34,7 @@ import {
   setWsClient,
   setOnError as setVoiceOnError,
   clearOnError as clearVoiceOnError,
-} from "@lib/voiceSession";
+} from "@lib/livekitSession";
 import { buildChatHeader } from "./main-page/ChatHeader";
 import { setServerHost } from "@components/message-list/renderers";
 import {
@@ -177,16 +176,6 @@ export function createMainPage(options: MainPageOptions): MountableComponent {
       }),
     );
 
-    // --- Voice config: trigger WebRTC join flow ---
-    unsubscribers.push(
-      ws.on("voice_config", (payload) => {
-        void joinVoice(payload.channel_id, payload, async () => {
-          const creds = await api.getVoiceCredentials();
-          return creds.ice_servers;
-        });
-      }),
-    );
-
     // --- Main .app row ---
     const app = createElement("div", { class: "app", "data-testid": "app-layout" });
 
diff --git a/Client/tauri-client/src/pages/main-page/VideoModeController.ts b/Client/tauri-client/src/pages/main-page/VideoModeController.ts
index 7a459b23..a91fbab4 100644
--- a/Client/tauri-client/src/pages/main-page/VideoModeController.ts
+++ b/Client/tauri-client/src/pages/main-page/VideoModeController.ts
@@ -4,7 +4,7 @@
  */
 
 import { voiceStore } from "@stores/voice.store";
-import { getLocalCameraStream } from "@lib/voiceSession";
+import { getLocalCameraStream } from "@lib/livekitSession";
 import type { VideoGridComponent } from "@components/VideoGrid";
 
 // ---------------------------------------------------------------------------
diff --git a/Client/tauri-client/src/pages/main-page/VoiceCallbacks.ts b/Client/tauri-client/src/pages/main-page/VoiceCallbacks.ts
index 9f8f40e9..20281490 100644
--- a/Client/tauri-client/src/pages/main-page/VoiceCallbacks.ts
+++ b/Client/tauri-client/src/pages/main-page/VoiceCallbacks.ts
@@ -17,7 +17,7 @@ import {
   setDeafened as voiceSessionSetDeafened,
   enableCamera,
   disableCamera,
-} from "@lib/voiceSession";
+} from "@lib/livekitSession";
 
 const log = createLogger("voice-callbacks");
 
diff --git a/Client/tauri-client/src/stores/auth.store.ts b/Client/tauri-client/src/stores/auth.store.ts
index 4e6093ed..b84b390d 100644
--- a/Client/tauri-client/src/stores/auth.store.ts
+++ b/Client/tauri-client/src/stores/auth.store.ts
@@ -6,7 +6,7 @@
 import { createStore } from "@lib/store";
 import type { UserWithRole } from "@lib/types";
 import { resetVoiceStore } from "@stores/voice.store";
-import { leaveVoice } from "@lib/voiceSession";
+import { leaveVoice } from "@lib/livekitSession";
 
 export interface AuthState {
   readonly token: string | null;
diff --git a/Client/tauri-client/tests/unit/ptt.test.ts b/Client/tauri-client/tests/unit/ptt.test.ts
index 2201b283..bb5de3cd 100644
--- a/Client/tauri-client/tests/unit/ptt.test.ts
+++ b/Client/tauri-client/tests/unit/ptt.test.ts
@@ -56,7 +56,7 @@ vi.mock("@lib/logger", () => ({
 }));
 
 // setMuted is called internally by the ptt-state listener — mock to isolate
-vi.mock("../../src/lib/voiceSession", () => ({
+vi.mock("../../src/lib/livekitSession", () => ({
   setMuted: vi.fn(),
 }));
 
@@ -465,7 +465,7 @@ describe("ptt-state event listener", () => {
   });
 
   it("calls setMuted(false) when PTT is pressed (payload true) and in a voice channel", async () => {
-    const { setMuted } = await import("../../src/lib/voiceSession");
+    const { setMuted } = await import("../../src/lib/livekitSession");
     const mockSetMuted = vi.mocked(setMuted);
     mockSetMuted.mockClear();
 
@@ -487,7 +487,7 @@ describe("ptt-state event listener", () => {
   });
 
   it("calls setMuted(true) when PTT is released (payload false) and in a voice channel", async () => {
-    const { setMuted } = await import("../../src/lib/voiceSession");
+    const { setMuted } = await import("../../src/lib/livekitSession");
     const mockSetMuted = vi.mocked(setMuted);
     mockSetMuted.mockClear();
 
@@ -508,7 +508,7 @@ describe("ptt-state event listener", () => {
   });
 
   it("does not call setMuted when not in a voice channel", async () => {
-    const { setMuted } = await import("../../src/lib/voiceSession");
+    const { setMuted } = await import("../../src/lib/livekitSession");
     const mockSetMuted = vi.mocked(setMuted);
     mockSetMuted.mockClear();
 
diff --git a/Client/tauri-client/tests/unit/settings-overlay.test.ts b/Client/tauri-client/tests/unit/settings-overlay.test.ts
index b5c947e0..2d051e3f 100644
--- a/Client/tauri-client/tests/unit/settings-overlay.test.ts
+++ b/Client/tauri-client/tests/unit/settings-overlay.test.ts
@@ -25,7 +25,7 @@ vi.mock("@stores/ui.store", () => ({
   setTheme: (...args: unknown[]) => mockSetTheme(...args),
 }));
 
-vi.mock("@lib/voiceSession", () => ({
+vi.mock("@lib/livekitSession", () => ({
   switchInputDevice: vi.fn().mockResolvedValue(undefined),
   switchOutputDevice: vi.fn().mockResolvedValue(undefined),
   setVoiceSensitivity: vi.fn(),
diff --git a/Client/tauri-client/tests/unit/soundboard.test.ts b/Client/tauri-client/tests/unit/soundboard.test.ts
deleted file mode 100644
index 1d01b88b..00000000
--- a/Client/tauri-client/tests/unit/soundboard.test.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createSoundboard } from "../../src/components/Soundboard";
-import type { SoundItem } from "../../src/components/Soundboard";
-
-const testSounds: SoundItem[] = [
-  { id: 1, name: "Airhorn", durationMs: 2500 },
-  { id: 2, name: "Rimshot", durationMs: 1200 },
-  { id: 3, name: "Sad Trombone", durationMs: 3800 },
-];
-
-describe("Soundboard", () => {
-  let container: HTMLDivElement;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    container = document.createElement("div");
-    document.body.appendChild(container);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    container.remove();
-  });
-
-  it("renders empty state when no sounds", () => {
-    const board = createSoundboard({
-      sounds: [],
-      onPlaySound: vi.fn(),
-    });
-    board.mount(container);
-
-    const empty = container.querySelector(".soundboard__empty");
-    expect(empty).not.toBeNull();
-    expect(empty!.textContent).toBe("No sounds available");
-
-    board.destroy?.();
-  });
-
-  it("renders sound buttons with names and durations", () => {
-    const board = createSoundboard({
-      sounds: testSounds,
-      onPlaySound: vi.fn(),
-    });
-    board.mount(container);
-
-    const buttons = container.querySelectorAll(".sound-btn");
-    expect(buttons.length).toBe(3);
-
-    const names = Array.from(container.querySelectorAll(".sound-btn__name")).map(
-      (el) => el.textContent,
-    );
-    expect(names).toEqual(["Airhorn", "Rimshot", "Sad Trombone"]);
-
-    const durations = Array.from(container.querySelectorAll(".sound-btn__duration")).map(
-      (el) => el.textContent,
-    );
-    expect(durations).toEqual(["2.5s", "1.2s", "3.8s"]);
-
-    board.destroy?.();
-  });
-
-  it("calls onPlaySound with correct id when button is clicked", () => {
-    const onPlaySound = vi.fn();
-    const board = createSoundboard({
-      sounds: testSounds,
-      onPlaySound,
-    });
-    board.mount(container);
-
-    const buttons = container.querySelectorAll(".sound-btn") as NodeListOf<HTMLButtonElement>;
-    buttons[1]!.click();
-    expect(onPlaySound).toHaveBeenCalledWith(2);
-
-    board.destroy?.();
-  });
-
-  it("disables all buttons during cooldown", () => {
-    const board = createSoundboard({
-      sounds: testSounds,
-      onPlaySound: vi.fn(),
-    });
-    board.mount(container);
-
-    const buttons = container.querySelectorAll(".sound-btn") as NodeListOf<HTMLButtonElement>;
-    buttons[0]!.click();
-
-    // All buttons should be disabled
-    for (const btn of buttons) {
-      expect(btn.disabled).toBe(true);
-      expect(btn.classList.contains("sound-btn--cooldown")).toBe(true);
-    }
-
-    board.destroy?.();
-  });
-
-  it("re-enables buttons after cooldown period", () => {
-    const board = createSoundboard({
-      sounds: testSounds,
-      onPlaySound: vi.fn(),
-    });
-    board.mount(container);
-
-    const buttons = container.querySelectorAll(".sound-btn") as NodeListOf<HTMLButtonElement>;
-    buttons[0]!.click();
-
-    // Advance past cooldown (3000ms)
-    vi.advanceTimersByTime(3000);
-
-    for (const btn of buttons) {
-      expect(btn.disabled).toBe(false);
-      expect(btn.classList.contains("sound-btn--cooldown")).toBe(false);
-    }
-
-    board.destroy?.();
-  });
-
-  it("does not fire onPlaySound when button is disabled", () => {
-    const onPlaySound = vi.fn();
-    const board = createSoundboard({
-      sounds: testSounds,
-      onPlaySound,
-    });
-    board.mount(container);
-
-    const buttons = container.querySelectorAll(".sound-btn") as NodeListOf<HTMLButtonElement>;
-    buttons[0]!.click(); // first click triggers cooldown
-    onPlaySound.mockClear();
-
-    buttons[1]!.click(); // should not fire since disabled
-    expect(onPlaySound).not.toHaveBeenCalled();
-
-    board.destroy?.();
-  });
-
-  it("cleans up on destroy", () => {
-    const board = createSoundboard({
-      sounds: testSounds,
-      onPlaySound: vi.fn(),
-    });
-    board.mount(container);
-
-    expect(container.querySelector(".soundboard")).not.toBeNull();
-
-    board.destroy?.();
-    expect(container.querySelector(".soundboard")).toBeNull();
-  });
-});
diff --git a/Client/tauri-client/tests/unit/types.test.ts b/Client/tauri-client/tests/unit/types.test.ts
index a801a603..09a5acb9 100644
--- a/Client/tauri-client/tests/unit/types.test.ts
+++ b/Client/tauri-client/tests/unit/types.test.ts
@@ -186,12 +186,12 @@ describe("ClientMessage types", () => {
     expect(soundboard.type).toBe("soundboard_play");
   });
 
-  it("includes voice signaling types", () => {
-    const offer: ClientMessage = {
-      type: "voice_offer",
-      payload: { channel_id: 10, sdp: "v=0..." },
+  it("includes voice mute type", () => {
+    const mute: ClientMessage = {
+      type: "voice_mute",
+      payload: { muted: true },
     };
-    expect(offer.type).toBe("voice_offer");
+    expect(mute.type).toBe("voice_mute");
   });
 });
 
diff --git a/Client/tauri-client/tests/unit/vad.test.ts b/Client/tauri-client/tests/unit/vad.test.ts
deleted file mode 100644
index 0caa4471..00000000
--- a/Client/tauri-client/tests/unit/vad.test.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Unit tests for VAD pure functions.
- */
-import { describe, it, expect } from "vitest";
-import { sensitivityToThreshold } from "@lib/vad";
-
-describe("sensitivityToThreshold", () => {
-  it("maps 0% sensitivity to max threshold (0.15)", () => {
-    expect(sensitivityToThreshold(0)).toBeCloseTo(0.15);
-  });
-
-  it("maps 100% sensitivity to zero threshold", () => {
-    expect(sensitivityToThreshold(100)).toBeCloseTo(0);
-  });
-
-  it("maps 50% sensitivity to half max threshold", () => {
-    expect(sensitivityToThreshold(50)).toBeCloseTo(0.075);
-  });
-
-  it("maps 75% sensitivity to quarter max threshold", () => {
-    expect(sensitivityToThreshold(75)).toBeCloseTo(0.0375);
-  });
-
-  it("is monotonically decreasing (higher sensitivity = lower threshold)", () => {
-    const t0 = sensitivityToThreshold(0);
-    const t25 = sensitivityToThreshold(25);
-    const t50 = sensitivityToThreshold(50);
-    const t75 = sensitivityToThreshold(75);
-    const t100 = sensitivityToThreshold(100);
-    expect(t0).toBeGreaterThan(t25);
-    expect(t25).toBeGreaterThan(t50);
-    expect(t50).toBeGreaterThan(t75);
-    expect(t75).toBeGreaterThan(t100);
-  });
-});
diff --git a/Client/tauri-client/tests/unit/video-mode-controller.test.ts b/Client/tauri-client/tests/unit/video-mode-controller.test.ts
index 915bfec9..86156a6b 100644
--- a/Client/tauri-client/tests/unit/video-mode-controller.test.ts
+++ b/Client/tauri-client/tests/unit/video-mode-controller.test.ts
@@ -13,7 +13,7 @@ vi.mock("@stores/voice.store", () => ({
   voiceStore: { getState: mockVoiceStoreGetState },
 }));
 
-vi.mock("@lib/voiceSession", () => ({
+vi.mock("@lib/livekitSession", () => ({
   getLocalCameraStream: mockGetLocalCameraStream,
 }));
 
diff --git a/Client/tauri-client/tests/unit/video.test.ts b/Client/tauri-client/tests/unit/video.test.ts
deleted file mode 100644
index e026e380..00000000
--- a/Client/tauri-client/tests/unit/video.test.ts
+++ /dev/null
@@ -1,242 +0,0 @@
-/**
- * Unit tests for the Video Device Manager.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createVideoManager } from "@lib/video";
-import type { VideoManager } from "@lib/video";
-
-// ---------------------------------------------------------------------------
-// Mock navigator.mediaDevices
-// ---------------------------------------------------------------------------
-
-function createMockTrack(kind: string): MediaStreamTrack {
-  return {
-    kind,
-    stop: vi.fn(),
-    getSettings: () => ({ deviceId: "cam-1", width: 1280, height: 720, frameRate: 30 }),
-  } as unknown as MediaStreamTrack;
-}
-
-function createMockStream(tracks: MediaStreamTrack[]): MediaStream {
-  return {
-    getTracks: () => tracks,
-    getVideoTracks: () => tracks.filter((t) => t.kind === "video"),
-    getAudioTracks: () => tracks.filter((t) => t.kind === "audio"),
-  } as unknown as MediaStream;
-}
-
-const mockDevices: MediaDeviceInfo[] = [
-  { deviceId: "cam-1", label: "Front Camera", kind: "videoinput", groupId: "g1", toJSON: () => ({}) },
-  { deviceId: "cam-2", label: "Back Camera", kind: "videoinput", groupId: "g2", toJSON: () => ({}) },
-  { deviceId: "mic-1", label: "Microphone", kind: "audioinput", groupId: "g3", toJSON: () => ({}) },
-  { deviceId: "spk-1", label: "Speakers", kind: "audiooutput", groupId: "g4", toJSON: () => ({}) },
-];
-
-let deviceChangeListeners: Array<() => void>;
-
-beforeEach(() => {
-  deviceChangeListeners = [];
-
-  Object.defineProperty(navigator, "mediaDevices", {
-    value: {
-      enumerateDevices: vi.fn().mockResolvedValue(mockDevices),
-      getUserMedia: vi.fn().mockResolvedValue(
-        createMockStream([createMockTrack("video")]),
-      ),
-      addEventListener: vi.fn((event: string, handler: () => void) => {
-        if (event === "devicechange") deviceChangeListeners.push(handler);
-      }),
-      removeEventListener: vi.fn((event: string, handler: () => void) => {
-        deviceChangeListeners = deviceChangeListeners.filter((h) => h !== handler);
-      }),
-    },
-    writable: true,
-    configurable: true,
-  });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("VideoManager", () => {
-  let manager: VideoManager;
-
-  beforeEach(() => {
-    manager = createVideoManager();
-  });
-
-  afterEach(() => {
-    manager.destroy();
-  });
-
-  describe("enumerateDevices", () => {
-    it("returns only videoinput devices", async () => {
-      const devices = await manager.enumerateDevices();
-      expect(devices).toHaveLength(2);
-      expect(devices.every((d) => d.kind === "videoinput")).toBe(true);
-    });
-
-    it("returns deviceId and label for each device", async () => {
-      const devices = await manager.enumerateDevices();
-      expect(devices[0]).toEqual({
-        deviceId: "cam-1",
-        label: "Front Camera",
-        kind: "videoinput",
-      });
-      expect(devices[1]).toEqual({
-        deviceId: "cam-2",
-        label: "Back Camera",
-        kind: "videoinput",
-      });
-    });
-  });
-
-  describe("getCameraStream", () => {
-    it("calls getUserMedia with correct video constraints and no audio", async () => {
-      await manager.getCameraStream("cam-1");
-
-      expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledWith({
-        video: {
-          width: { ideal: 1280 },
-          height: { ideal: 720 },
-          deviceId: { exact: "cam-1" },
-        },
-        audio: false,
-      });
-    });
-
-    it("uses default device when no deviceId is provided", async () => {
-      await manager.getCameraStream();
-
-      expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledWith({
-        video: {
-          width: { ideal: 1280 },
-          height: { ideal: 720 },
-          deviceId: undefined,
-        },
-        audio: false,
-      });
-    });
-
-    it("returns the media stream", async () => {
-      const stream = await manager.getCameraStream();
-      expect(stream).toBeDefined();
-      expect(stream.getVideoTracks()).toHaveLength(1);
-    });
-
-    it("stores the stream as current stream", async () => {
-      expect(manager.getCurrentStream()).toBeNull();
-      const stream = await manager.getCameraStream();
-      expect(manager.getCurrentStream()).toBe(stream);
-    });
-
-    it("stops previous stream when acquiring a new one", async () => {
-      const track1 = createMockTrack("video");
-      const stream1 = createMockStream([track1]);
-      vi.mocked(navigator.mediaDevices.getUserMedia)
-        .mockResolvedValueOnce(stream1)
-        .mockResolvedValueOnce(createMockStream([createMockTrack("video")]));
-
-      await manager.getCameraStream("cam-1");
-      await manager.getCameraStream("cam-2");
-
-      expect(track1.stop).toHaveBeenCalled();
-    });
-  });
-
-  describe("stopCameraStream", () => {
-    it("stops all tracks on the current stream", async () => {
-      const track = createMockTrack("video");
-      const stream = createMockStream([track]);
-      vi.mocked(navigator.mediaDevices.getUserMedia).mockResolvedValueOnce(stream);
-
-      await manager.getCameraStream();
-      manager.stopCameraStream();
-
-      expect(track.stop).toHaveBeenCalled();
-      expect(manager.getCurrentStream()).toBeNull();
-    });
-
-    it("does nothing when no stream is active", () => {
-      // Should not throw
-      manager.stopCameraStream();
-      expect(manager.getCurrentStream()).toBeNull();
-    });
-  });
-
-  describe("onDeviceChange", () => {
-    it("registers a listener for device changes", () => {
-      expect(navigator.mediaDevices.addEventListener).toHaveBeenCalledWith(
-        "devicechange",
-        expect.any(Function),
-      );
-    });
-
-    it("notifies callbacks with only video devices on change", async () => {
-      const callback = vi.fn();
-      manager.onDeviceChange(callback);
-
-      // Trigger the device change event
-      for (const listener of deviceChangeListeners) {
-        listener();
-      }
-
-      // Wait for async enumeration
-      await vi.waitFor(() => expect(callback).toHaveBeenCalled());
-
-      const devices = callback.mock.calls[0]![0];
-      expect(devices).toHaveLength(2);
-      expect(devices.every((d: { kind: string }) => d.kind === "videoinput")).toBe(true);
-    });
-
-    it("returns an unsubscribe function", async () => {
-      const callback = vi.fn();
-      const unsub = manager.onDeviceChange(callback);
-      unsub();
-
-      for (const listener of deviceChangeListeners) {
-        listener();
-      }
-
-      // Give time for any async callback
-      await new Promise((r) => { setTimeout(r, 50); });
-      expect(callback).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("destroy", () => {
-    it("removes the devicechange event listener", () => {
-      manager.destroy();
-      expect(navigator.mediaDevices.removeEventListener).toHaveBeenCalledWith(
-        "devicechange",
-        expect.any(Function),
-      );
-    });
-
-    it("stops the current stream on destroy", async () => {
-      const track = createMockTrack("video");
-      const stream = createMockStream([track]);
-      vi.mocked(navigator.mediaDevices.getUserMedia).mockResolvedValueOnce(stream);
-
-      await manager.getCameraStream();
-      manager.destroy();
-
-      expect(track.stop).toHaveBeenCalled();
-    });
-
-    it("throws on enumerateDevices after destroy", async () => {
-      manager.destroy();
-      await expect(manager.enumerateDevices()).rejects.toThrow("VideoManager has been destroyed");
-    });
-
-    it("throws on getCameraStream after destroy", async () => {
-      manager.destroy();
-      await expect(manager.getCameraStream()).rejects.toThrow("VideoManager has been destroyed");
-    });
-  });
-});
diff --git a/Client/tauri-client/tests/unit/voice-callbacks.test.ts b/Client/tauri-client/tests/unit/voice-callbacks.test.ts
index 9af36030..f6f2cbe6 100644
--- a/Client/tauri-client/tests/unit/voice-callbacks.test.ts
+++ b/Client/tauri-client/tests/unit/voice-callbacks.test.ts
@@ -42,7 +42,7 @@ vi.mock("@stores/voice.store", () => ({
   setLocalScreenshare: mockSetLocalScreenshare,
 }));
 
-vi.mock("@lib/voiceSession", () => ({
+vi.mock("@lib/livekitSession", () => ({
   leaveVoice: mockVoiceSessionLeave,
   setMuted: mockSetMuted,
   setDeafened: mockSetDeafened,
diff --git a/Client/tauri-client/tests/unit/voice-session-video.test.ts b/Client/tauri-client/tests/unit/voice-session-video.test.ts
deleted file mode 100644
index bf2f4293..00000000
--- a/Client/tauri-client/tests/unit/voice-session-video.test.ts
+++ /dev/null
@@ -1,435 +0,0 @@
-/**
- * Unit tests for voice session camera (video) lifecycle:
- * enableCamera, disableCamera, setOnRemoteVideo, clearOnRemoteVideo.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mock helpers
-// ---------------------------------------------------------------------------
-
-function createMockTrack(kind: "video" | "audio"): MediaStreamTrack {
-  return {
-    kind,
-    stop: vi.fn(),
-    enabled: true,
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    getSettings: () => ({ deviceId: "cam-1", width: 1280, height: 720, frameRate: 30 }),
-  } as unknown as MediaStreamTrack;
-}
-
-function createMockStream(tracks: MediaStreamTrack[]): MediaStream {
-  return {
-    id: "mock-stream-1",
-    getTracks: () => [...tracks],
-    getVideoTracks: () => tracks.filter((t) => t.kind === "video"),
-    getAudioTracks: () => tracks.filter((t) => t.kind === "audio"),
-    onremovetrack: null,
-  } as unknown as MediaStream;
-}
-
-// ---------------------------------------------------------------------------
-// Track mock calls
-// ---------------------------------------------------------------------------
-
-const mockWsSend = vi.fn();
-const mockAddVideoTrack = vi.fn();
-const mockRemoveVideoTrack = vi.fn();
-const mockCreateOffer = vi.fn().mockResolvedValue("mock-sdp-offer");
-const mockSetLocalStream = vi.fn();
-const mockDestroy = vi.fn();
-const mockOnIceCandidate = vi.fn().mockReturnValue(() => {});
-const mockOnRemoteTrack = vi.fn().mockReturnValue(() => {});
-const mockOnStateChange = vi.fn().mockReturnValue(() => {});
-const mockOnIceStateChange = vi.fn().mockReturnValue(() => {});
-const mockCreateConnection = vi.fn();
-const mockGetCameraStream = vi.fn();
-const mockVideoManagerDestroy = vi.fn();
-
-const mockSender = { track: null } as unknown as RTCRtpSender;
-
-// Prefs storage for tests
-const testPrefs = new Map<string, unknown>();
-
-// ---------------------------------------------------------------------------
-// Module mocks
-// ---------------------------------------------------------------------------
-
-vi.mock("../../src/lib/webrtc", () => ({
-  createWebRtcService: () => ({
-    createConnection: mockCreateConnection,
-    createOffer: mockCreateOffer,
-    handleAnswer: vi.fn(),
-    handleServerOffer: vi.fn(),
-    handleIceCandidate: vi.fn(),
-    addVideoTrack: mockAddVideoTrack,
-    removeVideoTrack: mockRemoveVideoTrack,
-    setLocalStream: mockSetLocalStream,
-    replaceTrack: vi.fn(),
-    getRemoteStreams: () => [],
-    setMuted: vi.fn(),
-    setSilenced: vi.fn(),
-    onIceCandidate: mockOnIceCandidate,
-    onRemoteTrack: mockOnRemoteTrack,
-    onStateChange: mockOnStateChange,
-    onIceStateChange: mockOnIceStateChange,
-    destroy: mockDestroy,
-  }),
-}));
-
-vi.mock("../../src/lib/audio", () => ({
-  createAudioManager: () => ({
-    getUserMedia: vi.fn().mockResolvedValue(
-      createMockStream([createMockTrack("audio")]),
-    ),
-    destroy: vi.fn(),
-  }),
-}));
-
-vi.mock("../../src/lib/video", () => ({
-  createVideoManager: () => ({
-    getCameraStream: mockGetCameraStream,
-    stopCameraStream: vi.fn(),
-    getCurrentStream: () => null,
-    enumerateDevices: vi.fn().mockResolvedValue([]),
-    onDeviceChange: vi.fn().mockReturnValue(() => {}),
-    destroy: mockVideoManagerDestroy,
-  }),
-}));
-
-vi.mock("../../src/lib/vad", () => ({
-  createVadDetector: () => ({
-    start: vi.fn(),
-    destroy: vi.fn(),
-    onSpeakingChange: vi.fn().mockReturnValue(() => {}),
-    setThreshold: vi.fn(),
-  }),
-  sensitivityToThreshold: (s: number) => s,
-}));
-
-vi.mock("../../src/lib/noise-suppression", () => ({
-  createNoiseSuppressor: () => ({
-    process: vi.fn().mockImplementation((stream: MediaStream) => Promise.resolve(stream)),
-    destroy: vi.fn(),
-  }),
-}));
-
-vi.mock("../../src/components/settings/helpers", () => ({
-  STORAGE_PREFIX: "owncord:settings:",
-  loadPref: (key: string, fallback: unknown) => testPrefs.get(key) ?? fallback,
-  savePref: (key: string, value: unknown) => testPrefs.set(key, value),
-  THEMES: { dark: {}, midnight: {}, light: {} },
-  applyTheme: vi.fn(),
-}));
-
-vi.mock("../../src/lib/logger", () => ({
-  createLogger: () => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  }),
-}));
-
-// ---------------------------------------------------------------------------
-// Import the module under test (AFTER mocks are set up)
-// ---------------------------------------------------------------------------
-
-import {
-  setWsClient,
-  setOnError,
-  clearOnError,
-  joinVoice,
-  leaveVoice,
-  enableCamera,
-  disableCamera,
-  setOnRemoteVideo,
-  setOnRemoteVideoRemoved,
-  clearOnRemoteVideo,
-} from "../../src/lib/voiceSession";
-import type { WsClient } from "../../src/lib/ws";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-function createMockWs(): WsClient {
-  return {
-    send: mockWsSend,
-    close: vi.fn(),
-    onMessage: vi.fn().mockReturnValue(() => {}),
-    onOpen: vi.fn().mockReturnValue(() => {}),
-    onClose: vi.fn().mockReturnValue(() => {}),
-    onError: vi.fn().mockReturnValue(() => {}),
-    isConnected: vi.fn().mockReturnValue(true),
-  } as unknown as WsClient;
-}
-
-const DEFAULT_CONFIG = {
-  channel_id: 42,
-  quality: "medium" as const,
-  bitrate: 64000,
-  threshold_mode: "forwarding" as const,
-  mixing_threshold: 3,
-  top_speakers: 5,
-  max_users: 25,
-};
-
-/** Set up a joined voice session so enableCamera/disableCamera have context. */
-async function setupActiveSession(): Promise<void> {
-  const ws = createMockWs();
-  setWsClient(ws);
-  await joinVoice(42, DEFAULT_CONFIG);
-  // Clear setup-related mock calls so tests only see camera-related calls
-  mockWsSend.mockClear();
-  mockCreateOffer.mockClear();
-  mockAddVideoTrack.mockClear();
-  mockRemoveVideoTrack.mockClear();
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Voice session — camera lifecycle", () => {
-  let errorCb: ReturnType<typeof vi.fn>;
-
-  beforeEach(async () => {
-    testPrefs.clear();
-    mockWsSend.mockClear();
-    mockCreateOffer.mockClear();
-    mockAddVideoTrack.mockClear();
-    mockRemoveVideoTrack.mockClear();
-    mockGetCameraStream.mockReset();
-    mockGetCameraStream.mockResolvedValue(
-      createMockStream([createMockTrack("video")]),
-    );
-    mockAddVideoTrack.mockReturnValue(mockSender);
-    mockCreateOffer.mockResolvedValue("mock-sdp-offer");
-
-    errorCb = vi.fn();
-    setOnError(errorCb);
-  });
-
-  afterEach(() => {
-    clearOnError();
-    clearOnRemoteVideo();
-    // leaveVoice to reset singleton state
-    leaveVoice(false);
-  });
-
-  // -----------------------------------------------------------------------
-  // enableCamera
-  // -----------------------------------------------------------------------
-
-  describe("enableCamera", () => {
-    it("acquires camera stream and adds video track to WebRTC", async () => {
-      await setupActiveSession();
-      await enableCamera();
-
-      expect(mockGetCameraStream).toHaveBeenCalled();
-      expect(mockAddVideoTrack).toHaveBeenCalledTimes(1);
-      // The stream passed to addVideoTrack should be the camera stream
-      const passedStream = mockAddVideoTrack.mock.calls[0]![0] as MediaStream;
-      expect(passedStream.getVideoTracks()).toHaveLength(1);
-    });
-
-    it("sends voice_offer for renegotiation after adding track", async () => {
-      await setupActiveSession();
-      await enableCamera();
-
-      const offerMessages = mockWsSend.mock.calls.filter(
-        (c) => (c[0] as { type: string }).type === "voice_offer",
-      );
-      expect(offerMessages.length).toBeGreaterThanOrEqual(1);
-      expect(offerMessages[0]![0]).toEqual({
-        type: "voice_offer",
-        payload: { channel_id: 42, sdp: "mock-sdp-offer" },
-      });
-    });
-
-    it("sends voice_camera enabled=true AFTER successful track addition", async () => {
-      await setupActiveSession();
-      await enableCamera();
-
-      // voice_camera should be sent after addVideoTrack and voice_offer
-      const cameraMessages = mockWsSend.mock.calls.filter(
-        (c) => (c[0] as { type: string }).type === "voice_camera",
-      );
-      expect(cameraMessages).toHaveLength(1);
-      expect(cameraMessages[0]![0]).toEqual({
-        type: "voice_camera",
-        payload: { enabled: true },
-      });
-
-      // Verify ordering: voice_offer comes before voice_camera
-      const allTypes = mockWsSend.mock.calls.map(
-        (c) => (c[0] as { type: string }).type,
-      );
-      const offerIdx = allTypes.indexOf("voice_offer");
-      const cameraIdx = allTypes.indexOf("voice_camera");
-      expect(offerIdx).toBeLessThan(cameraIdx);
-    });
-
-    it("handles permission denied error with toast", async () => {
-      await setupActiveSession();
-      mockGetCameraStream.mockRejectedValue(
-        new DOMException("Permission denied", "NotAllowedError"),
-      );
-
-      await enableCamera();
-
-      expect(errorCb).toHaveBeenCalledWith("Camera permission denied");
-    });
-
-    it("handles no camera found error with toast", async () => {
-      await setupActiveSession();
-      mockGetCameraStream.mockRejectedValue(
-        new DOMException("No device found", "NotFoundError"),
-      );
-
-      await enableCamera();
-
-      expect(errorCb).toHaveBeenCalledWith("No camera found");
-    });
-
-    it("uses saved video device preference", async () => {
-      testPrefs.set("videoInputDevice", "cam-back");
-      await setupActiveSession();
-      await enableCamera();
-
-      expect(mockGetCameraStream).toHaveBeenCalledWith("cam-back");
-    });
-
-    it("does nothing when no active voice session", async () => {
-      // No joinVoice, so no webrtcService
-      await enableCamera();
-
-      expect(mockGetCameraStream).not.toHaveBeenCalled();
-      expect(errorCb).toHaveBeenCalledWith("Join a voice channel first");
-    });
-
-    it("does nothing when camera is already enabled", async () => {
-      await setupActiveSession();
-      await enableCamera();
-      mockGetCameraStream.mockClear();
-      mockWsSend.mockClear();
-
-      await enableCamera();
-
-      expect(mockGetCameraStream).not.toHaveBeenCalled();
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // disableCamera
-  // -----------------------------------------------------------------------
-
-  describe("disableCamera", () => {
-    it("stops camera tracks and removes video track from WebRTC", async () => {
-      const videoTrack = createMockTrack("video");
-      const cameraStream = createMockStream([videoTrack]);
-      mockGetCameraStream.mockResolvedValue(cameraStream);
-
-      await setupActiveSession();
-      await enableCamera();
-      mockWsSend.mockClear();
-
-      await disableCamera();
-
-      expect(videoTrack.stop).toHaveBeenCalled();
-      expect(mockRemoveVideoTrack).toHaveBeenCalledWith(mockSender);
-    });
-
-    it("sends voice_camera enabled=false", async () => {
-      await setupActiveSession();
-      await enableCamera();
-      mockWsSend.mockClear();
-
-      await disableCamera();
-
-      const cameraMessages = mockWsSend.mock.calls.filter(
-        (c) => (c[0] as { type: string }).type === "voice_camera",
-      );
-      expect(cameraMessages).toHaveLength(1);
-      expect(cameraMessages[0]![0]).toEqual({
-        type: "voice_camera",
-        payload: { enabled: false },
-      });
-    });
-
-    it("sends voice_offer for renegotiation after removing track", async () => {
-      await setupActiveSession();
-      await enableCamera();
-      mockWsSend.mockClear();
-
-      await disableCamera();
-
-      const offerMessages = mockWsSend.mock.calls.filter(
-        (c) => (c[0] as { type: string }).type === "voice_offer",
-      );
-      expect(offerMessages).toHaveLength(1);
-    });
-
-    it("is safe to call when camera is not enabled", async () => {
-      await setupActiveSession();
-
-      // Should not throw
-      await disableCamera();
-
-      expect(mockRemoveVideoTrack).not.toHaveBeenCalled();
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Remote video callbacks
-  // -----------------------------------------------------------------------
-
-  describe("setOnRemoteVideo / clearOnRemoteVideo", () => {
-    it("registers a remote video callback", () => {
-      const cb = vi.fn();
-      setOnRemoteVideo(cb);
-
-      // The callback is stored internally — we verify by clearing it
-      // (no public getter). This tests the registration path.
-      clearOnRemoteVideo();
-      // If clearOnRemoteVideo didn't throw and completed, registration succeeded.
-      expect(true).toBe(true);
-    });
-
-    it("registers a remote video removed callback", () => {
-      const cb = vi.fn();
-      setOnRemoteVideoRemoved(cb);
-      clearOnRemoteVideo();
-      expect(true).toBe(true);
-    });
-
-    it("clearOnRemoteVideo nullifies both callbacks", () => {
-      const videoCb = vi.fn();
-      const removedCb = vi.fn();
-
-      setOnRemoteVideo(videoCb);
-      setOnRemoteVideoRemoved(removedCb);
-      clearOnRemoteVideo();
-
-      // After clearing, new registrations should work without error
-      setOnRemoteVideo(vi.fn());
-      setOnRemoteVideoRemoved(vi.fn());
-      clearOnRemoteVideo();
-      expect(true).toBe(true);
-    });
-
-    it("can overwrite existing callbacks", () => {
-      const cb1 = vi.fn();
-      const cb2 = vi.fn();
-
-      setOnRemoteVideo(cb1);
-      setOnRemoteVideo(cb2);
-
-      // No throw — second registration overwrites the first
-      clearOnRemoteVideo();
-      expect(true).toBe(true);
-    });
-  });
-});
diff --git a/Client/tauri-client/tests/unit/webrtc.test.ts b/Client/tauri-client/tests/unit/webrtc.test.ts
deleted file mode 100644
index c361684d..00000000
--- a/Client/tauri-client/tests/unit/webrtc.test.ts
+++ /dev/null
@@ -1,247 +0,0 @@
-/**
- * Unit tests for WebRTC SDP munging (applyOpusSettings) and
- * replaceTrack logic via mocked RTCPeerConnection.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createWebRtcService } from "../../src/lib/webrtc";
-
-// The applyOpusSettings function is module-private, so we test the
-// SDP manipulation patterns it implements as string transformations.
-// This validates the core logic without needing a real PeerConnection.
-
-describe("SDP Opus settings", () => {
-  const baseSdp = [
-    "v=0",
-    "o=- 0 0 IN IP4 127.0.0.1",
-    "s=-",
-    "t=0 0",
-    "m=audio 9 UDP/TLS/RTP/SAVPF 111",
-    "a=rtpmap:111 opus/48000/2",
-    "a=fmtp:111 minptime=10;usedtx=1",
-    "a=mid:0",
-    "",
-  ].join("\r\n");
-
-  // Replicate applyOpusSettings logic for testing
-  function applyOpusSettings(sdp: string, bitrate: number | undefined): string {
-    const lines = sdp.split("\r\n");
-    const result: string[] = [];
-    let inAudioSection = false;
-    let bitrateInserted = false;
-
-    for (const line of lines) {
-      let out = line;
-      if (out.startsWith("m=audio")) {
-        inAudioSection = true;
-        bitrateInserted = false;
-      } else if (out.startsWith("m=")) {
-        inAudioSection = false;
-      }
-      if (out.startsWith("a=fmtp:111 ")) {
-        if (!out.includes("useinbandfec=")) {
-          out += ";useinbandfec=1";
-        }
-      }
-      result.push(out);
-      if (inAudioSection && !bitrateInserted && bitrate !== undefined && out.startsWith("m=audio")) {
-        result.push(`b=AS:${Math.round(bitrate / 1000)}`);
-        bitrateInserted = true;
-      }
-    }
-    return result.join("\r\n");
-  }
-
-  it("adds useinbandfec to Opus fmtp line", () => {
-    const result = applyOpusSettings(baseSdp, undefined);
-    expect(result).toContain("a=fmtp:111 minptime=10;usedtx=1;useinbandfec=1");
-  });
-
-  it("does not duplicate useinbandfec if already present", () => {
-    const sdpWithFec = baseSdp.replace(
-      "a=fmtp:111 minptime=10;usedtx=1",
-      "a=fmtp:111 minptime=10;usedtx=1;useinbandfec=1",
-    );
-    const result = applyOpusSettings(sdpWithFec, undefined);
-    const matches = result.match(/useinbandfec/g);
-    expect(matches).toHaveLength(1);
-  });
-
-  it("inserts b=AS bandwidth line after m=audio", () => {
-    const result = applyOpusSettings(baseSdp, 64000);
-    const lines = result.split("\r\n");
-    const mAudioIdx = lines.findIndex((l) => l.startsWith("m=audio"));
-    expect(lines[mAudioIdx + 1]).toBe("b=AS:64");
-  });
-
-  it("calculates b=AS correctly for different bitrates", () => {
-    expect(applyOpusSettings(baseSdp, 32000)).toContain("b=AS:32");
-    expect(applyOpusSettings(baseSdp, 128000)).toContain("b=AS:128");
-  });
-
-  it("does not insert b=AS when bitrate is undefined", () => {
-    const result = applyOpusSettings(baseSdp, undefined);
-    expect(result).not.toContain("b=AS:");
-  });
-
-  it("handles multi-section SDP (audio + video)", () => {
-    const multiSdp = [
-      "v=0",
-      "o=- 0 0 IN IP4 127.0.0.1",
-      "s=-",
-      "t=0 0",
-      "m=audio 9 UDP/TLS/RTP/SAVPF 111",
-      "a=fmtp:111 minptime=10",
-      "m=video 9 UDP/TLS/RTP/SAVPF 96",
-      "a=rtpmap:96 VP8/90000",
-      "",
-    ].join("\r\n");
-    const result = applyOpusSettings(multiSdp, 64000);
-    // b=AS should appear after m=audio, not after m=video
-    const lines = result.split("\r\n");
-    const audioIdx = lines.findIndex((l) => l.startsWith("m=audio"));
-    const videoIdx = lines.findIndex((l) => l.startsWith("m=video"));
-    const basIdx = lines.findIndex((l) => l.startsWith("b=AS:"));
-    expect(basIdx).toBeGreaterThan(audioIdx);
-    expect(basIdx).toBeLessThan(videoIdx);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// replaceTrack tests — uses mocked RTCPeerConnection
-// ---------------------------------------------------------------------------
-
-/** Create a minimal mock MediaStreamTrack. */
-function mockTrack(id = "track-1"): MediaStreamTrack {
-  return {
-    id,
-    kind: "audio",
-    enabled: true,
-    stop: vi.fn(),
-    readyState: "live",
-  } as unknown as MediaStreamTrack;
-}
-
-/** Create a minimal mock MediaStream. */
-function mockStream(tracks: MediaStreamTrack[] = [mockTrack()]): MediaStream {
-  return {
-    id: "stream-1",
-    getTracks: () => [...tracks],
-    getAudioTracks: () => tracks.filter((t) => t.kind === "audio"),
-    getVideoTracks: () => [],
-    addTrack: vi.fn(),
-    removeTrack: vi.fn(),
-    clone: vi.fn(),
-    active: true,
-  } as unknown as MediaStream;
-}
-
-describe("replaceTrack", () => {
-  let originalRTCPeerConnection: typeof RTCPeerConnection;
-  let mockReplaceTrack: ReturnType<typeof vi.fn>;
-  let mockAddTrack: ReturnType<typeof vi.fn>;
-  let mockRemoveTrack: ReturnType<typeof vi.fn>;
-  let mockSender: RTCRtpSender;
-
-  beforeEach(() => {
-    originalRTCPeerConnection = globalThis.RTCPeerConnection;
-
-    mockReplaceTrack = vi.fn().mockResolvedValue(undefined);
-    mockSender = {
-      track: mockTrack(),
-      replaceTrack: mockReplaceTrack,
-      getParameters: vi.fn().mockReturnValue({}),
-      setParameters: vi.fn(),
-    } as unknown as RTCRtpSender;
-
-    mockAddTrack = vi.fn().mockReturnValue(mockSender);
-    mockRemoveTrack = vi.fn();
-
-    const MockPeerConnection = vi.fn().mockImplementation(() => ({
-      addTrack: mockAddTrack,
-      removeTrack: mockRemoveTrack,
-      close: vi.fn(),
-      signalingState: "stable",
-      connectionState: "new",
-      iceConnectionState: "new",
-      addEventListener: vi.fn(),
-      removeEventListener: vi.fn(),
-      createOffer: vi.fn().mockResolvedValue({ type: "offer", sdp: "v=0\r\n" }),
-      createAnswer: vi.fn().mockResolvedValue({ type: "answer", sdp: "v=0\r\n" }),
-      setLocalDescription: vi.fn().mockResolvedValue(undefined),
-      setRemoteDescription: vi.fn().mockResolvedValue(undefined),
-      addIceCandidate: vi.fn().mockResolvedValue(undefined),
-    }));
-
-    globalThis.RTCPeerConnection = MockPeerConnection as unknown as typeof RTCPeerConnection;
-  });
-
-  afterEach(() => {
-    globalThis.RTCPeerConnection = originalRTCPeerConnection;
-  });
-
-  it("swaps track on existing sender via sender.replaceTrack", async () => {
-    const service = createWebRtcService();
-    const stream1 = mockStream();
-    service.createConnection({ iceServers: [] });
-
-    // Initial attach — sets up senders
-    service.setLocalStream(stream1);
-    expect(mockAddTrack).toHaveBeenCalledTimes(1);
-
-    // Replace with new stream — should use replaceTrack, NOT removeTrack+addTrack
-    const newTrack = mockTrack("track-2");
-    const stream2 = mockStream([newTrack]);
-    await service.replaceTrack(stream2);
-
-    expect(mockReplaceTrack).toHaveBeenCalledWith(newTrack);
-    expect(mockRemoveTrack).not.toHaveBeenCalled();
-    // addTrack should still be 1 (from initial setLocalStream, not from replaceTrack)
-    expect(mockAddTrack).toHaveBeenCalledTimes(1);
-
-    service.destroy();
-  });
-
-  it("falls back to addTrack when no senders exist", async () => {
-    const service = createWebRtcService();
-    service.createConnection({ iceServers: [] });
-
-    // No setLocalStream — no existing senders
-    const newTrack = mockTrack("track-new");
-    const stream = mockStream([newTrack]);
-    await service.replaceTrack(stream);
-
-    // Should fall back to addTrack
-    expect(mockAddTrack).toHaveBeenCalledTimes(1);
-    expect(mockReplaceTrack).not.toHaveBeenCalled();
-
-    service.destroy();
-  });
-
-  it("applies mute+silence state to new track after replaceTrack", async () => {
-    const service = createWebRtcService();
-    // Create a track that the mock sender will reference
-    const senderTrack = mockTrack("track-sender");
-    Object.defineProperty(mockSender, "track", { value: senderTrack, writable: true, configurable: true });
-
-    const stream1 = mockStream([mockTrack("track-1")]);
-    service.createConnection({ iceServers: [] });
-    service.setLocalStream(stream1);
-
-    // Mute the stream — operates on sender.track
-    service.setMuted(true);
-    expect(senderTrack.enabled).toBe(false);
-
-    // Replace track — the new track should also get mute state applied
-    const track2 = mockTrack("track-2");
-    track2.enabled = true; // starts enabled
-    const stream2 = mockStream([track2]);
-    // After replaceTrack, the sender's track reference updates
-    Object.defineProperty(mockSender, "track", { value: track2, writable: true, configurable: true });
-    await service.replaceTrack(stream2);
-
-    // applyTrackEnabled runs after replaceTrack — should mute the new track
-    expect(track2.enabled).toBe(false);
-
-    service.destroy();
-  });
-});