⬆️(mail) upgrade Node image for mails-install to align with the frontend

Node 18 is now legacy, and running `make mails-install` was failing
with a "bad engine" error against the current image.

Bump the Node image used for `mails-install` to a more recent
version, aligned with the one used by the frontend, so the make
target runs cleanly again.

Note: the Alpine variant cannot be used here, as `bash` is required
to build the mail templates.

CHANGELOG.md

@@ -8,56 +8,15 @@ and this project adheres to
 
 ## [Unreleased]
 
-## [1.29.0] - 2026-08-25
-
-### Added
-
-- ✨(any) let any authenticated user manage the lobby on trusted rooms
-
-### Changed
-
-- 📱(frontend) collapse mobile control bar items on narrow viewports
-- 📱(frontend) stack idle modal buttons in a column on mobile
-- 📱(frontend) improve feedback screen responsiveness on mobile
-- ⬆️(frontend) upgrade @fontsource-variable/atkinson-hyperlegible-next
-- ⬆️(frontend) upgrade i18next-resources-to-backend from 1.2.1 to 1.2.3
-- ⬆️(frontend) upgrade @tanstack/react-query from 5.101.1 to 5.101.4
-- ⬆️(frontend) upgrade @pandacss/preset-panda from 1.11.3 to 1.12.0
-- ⬆️(frontend) upgrade posthog-js from 1.404.1 to 1.409.5
-- ⚡️(frontend) apply frugal constraint to the active meeting audio track
-- ⚡️(backend) replace blocking Redis KEYS with cursor-based SCAN
-- ✨(summary) add hostname to analytics properties
-
-## [1.28.0] - 2026-08-24
-
-### Added
-
-- 📈(frontend) track errors when starting or stopping a recording
-- 🚸(frontend) explain camera-in-use failures on the join screen
-
 ### Changed
 
 - ✨(backend) accept form-urlencoded on the user token endpoint
-- ✨(summary) configurable s3 region
-- ⬆️(frontend) upgrade i18next and react-i18next patch versions
-- ⬆️(frontend) upgrade posthog-js from 1.395.0 to 1.404.1
-- ⬆️(frontend) upgrade livekit-client and @livekit/components-react
-- 💄(frontend) increase the blur intensity
 
 ### Fixed
 
 - 📝(docs) fix minor typos in comments and docstrings
 - ⬆️(backend) bump sqlparse from 0.5.5 to 0.6.0
 - ⬆️(mail) bump @html-to/text-cli from 0.6.0 to 0.6.1
-- 🐛(frontend) treat client-initiated connect aborts as events
-- 🐛(frontend) use state instead of a ref for MoreControls container
-- 🐛(frontend) stop init_virtual_background from firing on blur updates
-- 🐛(frontend) hoist mute confirmation dialog to VideoConference level
-- 🐛(frontend) fix joined notification tile no longer rendering properly
-- 🐛(frontend) handle device-in-use errors on Chrome / Windows 10
-- 🐛(frontend) handle Firefox/Windows AbortError on device start
-- 🐛(frontend) treat "Timeout starting source" AbortError as device-in-use
-- 🔇(frontend) suppress leaked WebSocket error events from livekit-client
 
 ## [1.27.0] - 2026-08-14
 

compose.yml

@@ -267,7 +267,6 @@ services:
     build:
       context: ./src/agents
       target: development
-    command: ["python", "multi_user_transcriber.py", "dev"]
     env_file:
       - env.d/development/multi_user_transcriber
     volumes:

env.d/development/multi_user_transcriber.dist

@@ -1,23 +1,14 @@
-AWS_S3_ENDPOINT_URL=minio:9000
-AWS_S3_ACCESS_KEY_ID=meet
-AWS_S3_SECRET_ACCESS_KEY=password
-
 LIVEKIT_URL=ws://livekit:7880
 LIVEKIT_API_KEY=devkey
 LIVEKIT_API_SECRET=secret
 
-STT_PROVIDER=voxtral-vllm # voxtral-vllm, kyutai, deepgram
+STT_PROVIDER=kyutai # kyutai, deepgram
 ENABLE_SILERO_VAD=False
 
-DEEPGRAM_API_KEY=your-deepgram-api-key
+DEEPGRAM_API_KEY=
 
-KYUTAI_STT_BASE_URL=url
-KYUTAI_API_KEY=your-kyutai-api-key
-
-VOXTRAL_VLLM_BASE_URL=wss://<host>/v1/realtime
-VOXTRAL_VLLM_MODEL=voxtral-mini-4b-realtime-2602
-VOXTRAL_VLLM_API_KEY=your-vllm-api-key
-VOXTRAL_VLLM_TARGET_STREAMING_DELAY_MS=480
+KYUTAI_STT_BASE_URL=
+KYUTAI_API_KEY=
 
 SENTRY_DSN=
 SENTRY_ENVIRONMENT=

src/agents/multi_user_transcriber.py

@@ -25,8 +25,6 @@ from livekit.agents import (
 )
 from livekit.plugins import deepgram, silero
 
-import voxtral_vllm_stt
-
 from observability import configure_sentry, set_job_context
 from tasks import done_callback
 
@@ -51,9 +49,6 @@ def create_stt_provider():
         )
     elif STT_PROVIDER == "kyutai":
         _stt_instance = kyutai.STT(base_url=os.getenv("KYUTAI_STT_BASE_URL"))
-    elif STT_PROVIDER == "voxtral-vllm":
-        # The plugin resolves base_url / model / api_key from the environment.
-        _stt_instance = voxtral_vllm_stt.STT()
     else:
         raise ValueError(f"Unknown STT_PROVIDER: {STT_PROVIDER}")
 

src/agents/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "agents"
-version = "1.29.0"
+version = "1.27.0"
 requires-python = ">=3.12"
 dependencies = [
     "livekit-agents==1.6.7",

src/agents/voxtral_vllm_stt.py

@@ -1,474 +0,0 @@
-"""LiveKit STT plugin for Voxtral Realtime served via vLLM (/v1/realtime).
-
-vLLM exposes Voxtral Realtime over a WebSocket that follows the OpenAI Realtime
-API protocol (not Mistral's proprietary realtime protocol).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import json
-import logging
-import os
-import weakref
-from collections import deque
-from dataclasses import dataclass, field
-
-import websockets
-from livekit.agents import (
-    DEFAULT_API_CONNECT_OPTIONS,
-    APIConnectionError,
-    APIConnectOptions,
-    APIStatusError,
-    stt,
-    utils,
-)
-from livekit.agents import (
-    vad as vad_module,
-)
-from livekit.agents.types import NOT_GIVEN, NotGivenOr
-from livekit.agents.utils import is_given
-
-logger = logging.getLogger("voxtral-vllm-stt")
-
-SAMPLE_RATE = 16000
-NUM_CHANNELS = 1
-CHUNK_SAMPLES = 1600  # 100 ms @ 16 kHz mono
-PREROLL_CHUNKS = 5  # keep 500 ms of audio before start of speech as detected by VAD
-
-# Reconnect policy: exponential backoff capped at MAX, give up after MAX_ATTEMPTS
-# consecutive failures (a successful handshake resets the counter).
-RECONNECT_BACKOFF_BASE_S = 0.5
-RECONNECT_BACKOFF_MAX_S = 8.0
-RECONNECT_MAX_ATTEMPTS = 5
-
-
-@dataclass
-class _STTOptions:
-    base_url: str
-    model: str
-    api_key: str | None
-    target_streaming_delay_ms: int | None
-
-
-@dataclass
-class _PendingUtterance:
-    """An utterance in flight on the shared websocket used for reconnect.
-
-    `sent_chunks` holds every chunk we have already enqueued for send on this
-    or a prior connection; on reconnect we replay them before resuming reads
-    from `queue`. vLLM concatenates `input_audio_buffer.append` events into a
-    single audio buffer per generation, so duplicates from a partial prior send
-    are harmless.
-    """
-
-    queue: asyncio.Queue[bytes | None]
-    sent_chunks: list[bytes] = field(default_factory=list)
-    ended: bool = False
-
-
-class STT(stt.STT):
-    """LiveKit STT speaking the OpenAI Realtime protocol served by vLLM."""
-
-    def __init__(
-        self,
-        *,
-        base_url: NotGivenOr[str] = NOT_GIVEN,
-        model: NotGivenOr[str] = NOT_GIVEN,
-        api_key: NotGivenOr[str] = NOT_GIVEN,
-        target_streaming_delay_ms: NotGivenOr[int] = NOT_GIVEN,
-        vad: vad_module.VAD | None = None,
-    ) -> None:
-        """Build the STT.
-
-        Args:
-            base_url: WebSocket URL of the vLLM realtime endpoint, e.g.
-                ws://example:8000/v1/realtime. Falls back to $VOXTRAL_VLLM_BASE_URL.
-            model: Model name exposed by vLLM, default
-                mistralai/Voxtral-Mini-4B-Realtime-2602.
-            api_key: Optional bearer token. Falls back to $VOXTRAL_VLLM_API_KEY.
-            target_streaming_delay_ms: Target streaming delay in ms forwarded to
-                vLLM via session.update. Falls back to
-                $VOXTRAL_VLLM_TARGET_STREAMING_DELAY_MS, else server default.
-            vad: Voice Activity Detector. If omitted, Silero VAD is loaded.
-        """
-        super().__init__(
-            capabilities=stt.STTCapabilities(streaming=True, interim_results=True)
-        )
-
-        resolved_url = (
-            base_url
-            if is_given(base_url)
-            else os.environ.get(
-                "VOXTRAL_VLLM_BASE_URL", "ws://127.0.0.1:8000/v1/realtime"
-            )
-        )
-        resolved_model = (
-            model
-            if is_given(model)
-            else os.environ.get(
-                "VOXTRAL_VLLM_MODEL", "mistralai/Voxtral-Mini-4B-Realtime-2602"
-            )
-        )
-        resolved_key = (
-            api_key if is_given(api_key) else os.environ.get("VOXTRAL_VLLM_API_KEY")
-        )
-        resolved_delay = (
-            target_streaming_delay_ms
-            if is_given(target_streaming_delay_ms)
-            else (
-                int(os.environ["VOXTRAL_VLLM_TARGET_STREAMING_DELAY_MS"])
-                if os.environ.get("VOXTRAL_VLLM_TARGET_STREAMING_DELAY_MS")
-                else None
-            )
-        )
-
-        if vad is None:
-            try:
-                from livekit.plugins.silero import VAD as SileroVAD  # noqa: PLC0415
-            except ImportError as exc:
-                raise ImportError(
-                    "livekit-plugins-silero is required for vLLM Voxtral realtime "
-                    "(no server-side endpointing)."
-                ) from exc
-            vad = SileroVAD.load()
-        self._vad = vad
-
-        self._opts = _STTOptions(
-            base_url=resolved_url,
-            model=resolved_model,
-            api_key=resolved_key,
-            target_streaming_delay_ms=resolved_delay,
-        )
-        self._streams: weakref.WeakSet[SpeechStream] = weakref.WeakSet()
-
-    @property
-    def model(self) -> str:
-        """Return the configured vLLM model name."""
-        return self._opts.model
-
-    @property
-    def provider(self) -> str:
-        """Return the provider identifier."""
-        return "vllm-voxtral-realtime"
-
-    async def _recognize_impl(self, *_args, **_kwargs) -> stt.SpeechEvent:
-        raise NotImplementedError(
-            "vLLM Voxtral Realtime STT only supports streaming recognition."
-        )
-
-    def stream(
-        self,
-        *,
-        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-    ) -> SpeechStream:
-        """Open a new streaming recognition stream."""
-        s = SpeechStream(
-            stt=self,
-            opts=self._opts,
-            vad_instance=self._vad,
-            conn_options=conn_options,
-        )
-        self._streams.add(s)
-        return s
-
-
-class SpeechStream(stt.RecognizeStream):
-    def __init__(
-        self,
-        *,
-        stt: STT,
-        opts: _STTOptions,
-        vad_instance: vad_module.VAD,
-        conn_options: APIConnectOptions,
-    ) -> None:
-        """Init the speech stream."""
-        super().__init__(stt=stt, conn_options=conn_options, sample_rate=SAMPLE_RATE)
-        self._opts = opts
-        self._vad = vad_instance
-        self._utterance_q: asyncio.Queue[bytes | None] | None = None
-        self._speaking = False
-        self._preroll: deque[bytes] = deque(maxlen=PREROLL_CHUNKS)
-        # Voxtral realtime is strictly sequential: only one generation runs at a
-        # time, and a new `commit` is ignored while the previous one is still
-        # producing. We queue per-utterance audio buffers here and let the
-        # pipeline process them one by one on the shared websocket.
-        self._utterance_chan: asyncio.Queue[asyncio.Queue[bytes | None] | None] = (
-            asyncio.Queue()
-        )
-
-    @utils.log_exceptions(logger=logger)
-    async def _run(self) -> None:
-        vad_stream = self._vad.stream()
-
-        bstream = utils.audio.AudioByteStream(
-            sample_rate=SAMPLE_RATE,
-            num_channels=NUM_CHANNELS,
-            samples_per_channel=CHUNK_SAMPLES,
-        )
-
-        async def input_task() -> None:
-            async for data in self._input_ch:
-                if isinstance(data, self._FlushSentinel):
-                    for frame in bstream.flush():
-                        self._handle_chunk(frame.data.tobytes())
-                    continue
-
-                vad_stream.push_frame(data)
-                for frame in bstream.write(data.data.tobytes()):
-                    self._handle_chunk(frame.data.tobytes())
-
-            vad_stream.end_input()
-
-        async def vad_task() -> None:
-            async for ev in vad_stream:
-                if ev.type == vad_module.VADEventType.START_OF_SPEECH:
-                    self._on_start_of_speech()
-                elif ev.type == vad_module.VADEventType.END_OF_SPEECH:
-                    self._on_end_of_speech()
-
-        pipeline_t = asyncio.create_task(self._utterance_pipeline())
-        try:
-            await asyncio.gather(input_task(), vad_task())
-            # signal end-of-stream; pipeline finishes pending utterances first
-            self._utterance_chan.put_nowait(None)
-            await pipeline_t
-        except (APIStatusError, APIConnectionError, asyncio.CancelledError):
-            raise
-        except Exception as exc:
-            logger.exception("vLLM realtime stream failed")
-            raise APIConnectionError() from exc
-        finally:
-            if not pipeline_t.done():
-                pipeline_t.cancel()
-            try:
-                await pipeline_t
-            except asyncio.CancelledError:
-                # CancelledError is the expected flow on cancel()
-                pass
-            except Exception:
-                logger.exception("utterance pipeline failed during finalize")
-            await vad_stream.aclose()
-
-    def _handle_chunk(self, chunk: bytes) -> None:
-        self._preroll.append(chunk)
-        if self._speaking and self._utterance_q is not None:
-            self._utterance_q.put_nowait(chunk)
-
-    def _on_start_of_speech(self) -> None:
-        if self._speaking:
-            return
-        self._speaking = True
-        q: asyncio.Queue[bytes | None] = asyncio.Queue()
-        for chunk in self._preroll:
-            q.put_nowait(chunk)
-        self._utterance_q = q
-        self._utterance_chan.put_nowait(q)
-        self._event_ch.send_nowait(
-            stt.SpeechEvent(type=stt.SpeechEventType.START_OF_SPEECH)
-        )
-
-    def _on_end_of_speech(self) -> None:
-        if not self._speaking:
-            return
-        self._speaking = False
-        if self._utterance_q is not None:
-            self._utterance_q.put_nowait(None)
-        self._utterance_q = None
-        self._event_ch.send_nowait(
-            stt.SpeechEvent(type=stt.SpeechEventType.END_OF_SPEECH)
-        )
-
-    async def _handshake(self, ws: websockets.ClientConnection) -> str:
-        created = json.loads(await ws.recv())
-        if created.get("type") != "session.created":
-            raise APIStatusError(
-                f"expected session.created, got {created}",
-                status_code=500,
-                body=created,
-            )
-        session_update: dict = {"type": "session.update", "model": self._opts.model}
-        if self._opts.target_streaming_delay_ms is not None:
-            session_update["target_streaming_delay_ms"] = (
-                self._opts.target_streaming_delay_ms
-            )
-        await ws.send(json.dumps(session_update))
-        return created.get("id", "")
-
-    def _auth_headers(self) -> dict[str, str]:
-        if self._opts.api_key:
-            return {"Authorization": f"Bearer {self._opts.api_key}"}
-        return {}
-
-    async def _utterance_pipeline(self) -> None:
-        # Owns the websocket lifecycle. On drop, reopens and resumes the
-        # in-flight utterance (if any) by replaying its already-sent chunks.
-        pending: _PendingUtterance | None = None
-        attempt = 0
-        while True:
-            try:
-                async with websockets.connect(
-                    self._opts.base_url,
-                    additional_headers=self._auth_headers(),
-                    open_timeout=self._conn_options.timeout,
-                ) as ws:
-                    request_id = await self._handshake(ws)
-                    attempt = 0
-                    while True:
-                        if pending is None:
-                            q = await self._utterance_chan.get()
-                            if q is None:
-                                return
-                            pending = _PendingUtterance(queue=q)
-                        await self._process_utterance(ws, pending, request_id)
-                        pending = None
-            except (websockets.WebSocketException, OSError, TimeoutError) as exc:
-                attempt += 1
-                if attempt > RECONNECT_MAX_ATTEMPTS:
-                    logger.exception(
-                        "vLLM realtime: giving up after %d reconnect attempts",
-                        RECONNECT_MAX_ATTEMPTS,
-                    )
-                    raise APIConnectionError() from exc
-                backoff = min(
-                    RECONNECT_BACKOFF_BASE_S * (2 ** (attempt - 1)),
-                    RECONNECT_BACKOFF_MAX_S,
-                )
-                if pending is None:
-                    logger.warning(
-                        "vLLM WS connection lost between utterances "
-                        "(attempt %d/%d): %s; retrying in %.1fs",
-                        attempt,
-                        RECONNECT_MAX_ATTEMPTS,
-                        exc,
-                        backoff,
-                    )
-                else:
-                    logger.warning(
-                        "vLLM WS dropped mid-utterance (%d chunks buffered, "
-                        "ended=%s, attempt %d/%d): %s; retrying in %.1fs",
-                        len(pending.sent_chunks),
-                        pending.ended,
-                        attempt,
-                        RECONNECT_MAX_ATTEMPTS,
-                        exc,
-                        backoff,
-                    )
-                await asyncio.sleep(backoff)
-
-    async def _process_utterance(
-        self,
-        ws: websockets.ClientConnection,
-        pending: _PendingUtterance,
-        request_id: str,
-    ) -> None:
-        # Start a fresh generation. Safe to send here: the previous utterance's
-        # transcription.done has already been received (we await it below), so
-        # the server-side generation_task is done and won't ignore this commit.
-        await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
-        send_t = asyncio.create_task(self._send_audio(ws, pending))
-        try:
-            await self._receive_one_transcription(ws, request_id)
-        finally:
-            if not send_t.done():
-                send_t.cancel()
-            try:
-                await send_t
-            except (asyncio.CancelledError, websockets.WebSocketException):
-                pass
-            except Exception:
-                logger.exception("send-audio task failed during finalize")
-
-    @staticmethod
-    async def _send_audio(
-        ws: websockets.ClientConnection, pending: _PendingUtterance
-    ) -> None:
-        # Replay anything already sent on a previous (now-dead) connection.
-        # sent_chunks is appended before send, so a chunk that failed to send
-        # last time is still present and gets retried here.
-        for chunk in pending.sent_chunks:
-            await ws.send(
-                json.dumps(
-                    {
-                        "type": "input_audio_buffer.append",
-                        "audio": base64.b64encode(chunk).decode("ascii"),
-                    }
-                )
-            )
-        if pending.ended:
-            await ws.send(
-                json.dumps({"type": "input_audio_buffer.commit", "final": True})
-            )
-            return
-        while True:
-            chunk = await pending.queue.get()
-            if chunk is None:
-                pending.ended = True
-                await ws.send(
-                    json.dumps({"type": "input_audio_buffer.commit", "final": True})
-                )
-                return
-            pending.sent_chunks.append(chunk)
-            await ws.send(
-                json.dumps(
-                    {
-                        "type": "input_audio_buffer.append",
-                        "audio": base64.b64encode(chunk).decode("ascii"),
-                    }
-                )
-            )
-
-    async def _receive_one_transcription(
-        self, ws: websockets.ClientConnection, request_id: str
-    ) -> None:
-        # Use recv() rather than `async for`: the latter swallows
-        # ConnectionClosed on close-mid-iteration, which would let a dropped
-        # WS look like a clean "no transcription" return.
-        current_text = ""
-        while True:
-            raw = await ws.recv()
-            data = json.loads(raw)
-            event_type = data.get("type")
-
-            if event_type == "transcription.delta":
-                delta = data.get("delta", "")
-                if not delta:
-                    continue
-                current_text += delta
-                self._event_ch.send_nowait(
-                    stt.SpeechEvent(
-                        type=stt.SpeechEventType.INTERIM_TRANSCRIPT,
-                        request_id=request_id,
-                        alternatives=[stt.SpeechData(text=current_text, language="")],
-                    )
-                )
-            elif event_type == "transcription.done":
-                final_text = data.get("text") or current_text
-                self._event_ch.send_nowait(
-                    stt.SpeechEvent(
-                        type=stt.SpeechEventType.FINAL_TRANSCRIPT,
-                        request_id=request_id,
-                        alternatives=[stt.SpeechData(text=final_text, language="")],
-                    )
-                )
-                usage = data.get("usage") or {}
-                self._event_ch.send_nowait(
-                    stt.SpeechEvent(
-                        type=stt.SpeechEventType.RECOGNITION_USAGE,
-                        request_id=request_id,
-                        recognition_usage=stt.RecognitionUsage(
-                            audio_duration=float(
-                                usage.get("audio_seconds")
-                                or usage.get("prompt_audio_seconds")
-                                or 0
-                            ),
-                            input_tokens=int(usage.get("prompt_tokens") or 0),
-                            output_tokens=int(usage.get("completion_tokens") or 0),
-                        ),
-                    )
-                )
-                return
-            elif event_type == "error":
-                err = data.get("error")
-                raise APIStatusError(str(err), status_code=500, body=data)

src/backend/core/api/permissions.py

@@ -5,7 +5,7 @@ from django.http import Http404
 
 from rest_framework import permissions
 
-from ..models import RoleChoices, RoomAccessLevel
+from ..models import RoleChoices
 from ..services.participants_management import (
     ParticipantNotFoundException,
     ParticipantsManagement,
@@ -198,48 +198,3 @@ class IsPresentInMeeting(permissions.BasePermission):
             return False
         except ParticipantsManagementException:
             return False
-
-
-class CanManageLobby(permissions.BasePermission):
-    """Grant lobby management (list/accept/deny waiting participants).
-
-    - Room admins/owners can always manage the lobby.
-    - When the room access level is TRUSTED, any authenticated user who is
-      currently connected to the meeting can manage the lobby. Presence is
-      verified cache-first (Redis), falling back to the LiveKit API.
-
-    Access level is always read fresh from the DB; only presence is cached,
-    so changing the room to RESTRICTED takes effect immediately.
-    """
-
-    message = "You are not allowed to manage this room's lobby."
-
-    # pylint: disable=too-many-return-statements
-    def has_object_permission(self, request, view, obj):  # noqa: PLR0911
-        """Check privileges first, then the trusted-room presence path."""
-        user = request.user
-
-        if not user or not user.is_authenticated:
-            return False
-
-        # Product choice: lobby management is reserved for session-authenticated
-        # users with a real account, not holders of a LiveKit room token.
-        if request.auth and hasattr(request.auth, "video"):
-            return False
-
-        if obj.is_administrator_or_owner(user):
-            return True
-
-        if obj.access_level != RoomAccessLevel.TRUSTED:
-            return False
-
-        self.message = "You must be connected to the meeting to manage its lobby."
-
-        try:
-            return ParticipantsManagement().check_if_in_meeting_cached(
-                room_name=str(obj.pk), identity=str(user.sub)
-            )
-        except ParticipantNotFoundException:
-            return False
-        except ParticipantsManagementException:
-            return False

src/backend/core/api/viewsets.py

@@ -536,7 +536,7 @@ class RoomViewSet(
         methods=["post"],
         url_path="enter",
         permission_classes=[
-            permissions.CanManageLobby,
+            permissions.HasPrivilegesOnRoom,
         ],
     )
     def allow_participant_to_enter(self, request, pk=None):  # pylint: disable=unused-argument
@@ -574,7 +574,7 @@ class RoomViewSet(
         methods=["GET"],
         url_path="waiting-participants",
         permission_classes=[
-            permissions.CanManageLobby,
+            permissions.HasPrivilegesOnRoom,
         ],
     )
     def list_waiting_participants(self, request, pk=None):  # pylint: disable=unused-argument

src/backend/core/services/livekit_events.py

@@ -23,7 +23,6 @@ from core.recording.services.recording_events import (
 )
 
 from .lobby import LobbyService
-from .presence import PresenceCache
 from .room_management import (
     RoomManagement,
     RoomManagementException,
@@ -100,7 +99,6 @@ class LiveKitEventsService:
             "egress_ended": self._handle_egress_ended,
             "room_started": self._handle_room_started,
             "room_finished": self._handle_room_finished,
-            "participant_left": self._handle_participant_left,
         }
 
         token_verifier = api.TokenVerifier(
@@ -109,7 +107,6 @@ class LiveKitEventsService:
         )
         self.webhook_receiver = api.WebhookReceiver(token_verifier)
         self.lobby_service = LobbyService()
-        self.presence_cache = PresenceCache()
         self.sip_management = SIPManagement()
         self.recording_events = RecordingEventsService()
 
@@ -288,31 +285,9 @@ class LiveKitEventsService:
                     f"Failed to delete sip dispatch rule for room {room_id}"
                 ) from e
 
-        self.presence_cache.clear_room(room_id)
-
         try:
             self.lobby_service.clear_room_cache(room_id)
         except Exception as e:
             raise ActionFailedError(
                 f"Failed to clear room cache for room {room_id}"
             ) from e
-
-    def _handle_participant_left(self, data):
-        """Handle 'participant_left': invalidate the presence cache.
-
-        Presence entries are created lazily (only for users who administrate
-        the lobby of a trusted room), so for most participants this delete is
-        a no-op DEL on a key that never existed. Eager invalidation shrinks
-        the window during which a departed participant could still act on a
-        trusted room's lobby (cache hit until TTL expiry). It is gated behind
-        `PRESENCE_CLEAR_ON_PARTICIPANT_LEFT` so its production impact can be
-        measured and the behaviour reverted independently of the feature.
-        When disabled, invalidation relies on `room_finished` and the TTL.
-        """
-        if not settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT:
-            return
-
-        identity = data.participant.identity
-        if not identity:
-            return
-        self.presence_cache.clear(data.room.name, identity)

src/backend/core/services/lobby.py

@@ -270,7 +270,7 @@ class LobbyService:
         """List all waiting participants for a room."""
 
         pattern = self._get_cache_key(room_id, "*")
-        keys = list(cache.iter_keys(pattern, itersize=utils.CACHE_SCAN_ITERSIZE))
+        keys = cache.keys(pattern)
 
         if not keys:
             return []
@@ -345,9 +345,13 @@ class LobbyService:
     def clear_room_cache(self, room_id: UUID) -> None:
         """Clear all participant entries from the cache for a specific room."""
 
-        cache.delete_pattern(
-            self._get_cache_key(room_id, "*"), itersize=utils.CACHE_SCAN_ITERSIZE
-        )
+        pattern = self._get_cache_key(room_id, "*")
+        keys = cache.keys(pattern)
+
+        if not keys:
+            return
+
+        cache.delete_many(keys)
 
     def clear_participant_cache(self, room_id: UUID, participant_id: str) -> None:
         """Clear a given participant entry from the cache for a specific room."""

src/backend/core/services/participants_management.py

@@ -20,7 +20,6 @@ from livekit.protocol.models import ParticipantInfo
 from core import utils
 
 from .lobby import LobbyService
-from .presence import PresenceCache
 
 logger = getLogger(__name__)
 
@@ -73,9 +72,7 @@ class ParticipantsManagement:
 
     @async_to_sync
     async def remove(self, room_name: str, identity: str):
-        """Remove a participant from a room and clear their lobby/presence cache."""
-
-        PresenceCache().clear(room_name, identity)
+        """Remove a participant from a room and clear their lobby cache."""
 
         try:
             LobbyService().clear_participant_cache(
@@ -159,30 +156,6 @@ class ParticipantsManagement:
         finally:
             await lkapi.aclose()
 
-    def check_if_in_meeting_cached(self, room_name: str, identity: str) -> bool:
-        """Cache-first variant of `check_if_in_meeting`.
-
-        Cache hit  -> True without touching LiveKit.
-        Cache miss -> ask LiveKit; memoize only positive answers.
-
-        Raises the same exceptions as `check_if_in_meeting` so callers keep
-        failing closed the same way.
-        """
-        if not room_name or not identity:
-            return False
-
-        presence_cache = PresenceCache()
-
-        if presence_cache.is_marked_present(room_name, identity):
-            return True
-
-        present = self.check_if_in_meeting(room_name=room_name, identity=identity)
-
-        if present:
-            presence_cache.mark_present(room_name, identity)
-
-        return present
-
     @async_to_sync
     async def check_if_in_meeting(self, room_name: str, identity: str) -> bool:
         """Check whether `identity` is currently a participant in `room_name`.

src/backend/core/services/presence.py

@@ -1,52 +0,0 @@
-"""Presence cache.
-
-Redis-backed memo of "this identity is currently connected to this room".
-
-This module is intentionally a *pure cache store* with no dependency on other
-services, so that `participants_management` (which talks to LiveKit) can
-import it without creating an import cycle. The composition of "check cache,
-fall back to LiveKit" lives in
-`ParticipantsManagement.check_if_in_meeting_cached`.
-
-Only positive answers are stored: a sticky negative would lock out someone
-who joins right after a miss for the whole TTL. The TTL is a safety net in
-case an invalidation webhook is lost.
-"""
-
-from uuid import UUID
-
-from django.conf import settings
-from django.core.cache import cache
-
-from core.utils import CACHE_SCAN_ITERSIZE
-
-
-class PresenceCache:
-    """Store and invalidate (room, identity) presence entries."""
-
-    @staticmethod
-    def _get_cache_key(room_id: UUID | str, identity: str) -> str:
-        """Cache key for a (room, identity) presence entry."""
-        return f"{settings.PRESENCE_KEY_PREFIX}_{room_id!s}_{identity}"
-
-    def is_marked_present(self, room_id: UUID | str, identity: str) -> bool:
-        """Return True if a positive presence entry exists in cache."""
-        return bool(cache.get(self._get_cache_key(room_id, identity)))
-
-    def mark_present(self, room_id: UUID | str, identity: str) -> None:
-        """Record that `identity` is in `room_id`."""
-        cache.set(
-            self._get_cache_key(room_id, identity),
-            True,
-            timeout=settings.PRESENCE_CACHE_TIMEOUT,
-        )
-
-    def clear(self, room_id: UUID | str, identity: str) -> None:
-        """Forget presence for one participant (e.g. on participant_left)."""
-        cache.delete(self._get_cache_key(room_id, identity))
-
-    def clear_room(self, room_id: UUID | str) -> None:
-        """Forget presence for every participant of a room (on room_finished)."""
-        cache.delete_pattern(
-            self._get_cache_key(room_id, "*"), itersize=CACHE_SCAN_ITERSIZE
-        )

src/backend/core/tests/rooms/test_api_rooms_lobby.py

@@ -389,7 +389,7 @@ def test_allow_participant_to_enter_anonymous():
 
 def test_allow_participant_to_enter_non_owner():
     """Non-privileged users should not be allowed to manage entry requests."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory()
     user = UserFactory()
     client = APIClient()
     client.force_login(user)
@@ -522,7 +522,7 @@ def test_list_waiting_participants_anonymous():
 
 def test_list_waiting_participants_non_owner():
     """Non-privileged users should not be allowed to list waiting participants."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory()
     user = UserFactory()
     client = APIClient()
     client.force_login(user)

src/backend/core/tests/rooms/test_api_rooms_lobby_trusted.py

@@ -1,106 +0,0 @@
-"""Trusted rooms: any authenticated participant present in the meeting can manage the lobby."""
-
-from unittest import mock
-
-import pytest
-from rest_framework.test import APIClient
-
-from core.factories import RoomFactory, UserFactory
-from core.models import RoomAccessLevel
-from core.services.presence import PresenceCache
-
-pytestmark = pytest.mark.django_db
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_trusted_room_present_user_can_list_waiting(mock_check):
-    """Authenticated + present in a trusted room -> 200, LiveKit asked once then cached."""
-    mock_check.return_value = True
-    user = UserFactory()
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    client = APIClient()
-    client.force_login(user)
-
-    url = f"/api/v1.0/rooms/{room.id}/waiting-participants/"
-    assert client.get(url).status_code == 200
-    assert client.get(url).status_code == 200
-    assert mock_check.call_count == 1
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_trusted_room_absent_user_forbidden(mock_check):
-    """Authenticated but not connected to the meeting -> 403."""
-    mock_check.return_value = False
-    user = UserFactory()
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-    assert response.status_code == 403
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_restricted_room_present_user_forbidden(mock_check):
-    """Presence is not enough on a restricted room; LiveKit must not even be asked."""
-    user = UserFactory()
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-    assert response.status_code == 403
-    mock_check.assert_not_called()
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_trusted_room_presence_cleared_after_leave(mock_check):
-    """Once the presence cache is cleared (participant_left), LiveKit is re-checked."""
-    mock_check.return_value = True
-    user = UserFactory()
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    client = APIClient()
-    client.force_login(user)
-    url = f"/api/v1.0/rooms/{room.id}/waiting-participants/"
-
-    assert client.get(url).status_code == 200
-    PresenceCache().clear(room.id, str(user.sub))
-
-    mock_check.return_value = False
-    assert client.get(url).status_code == 403
-    assert mock_check.call_count == 2
-
-
-def test_trusted_room_anonymous_forbidden():
-    """Anonymous users never manage the lobby."""
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    response = APIClient().get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-    assert response.status_code == 401
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_trusted_room_present_user_can_accept_entry(mock_check):
-    """Authenticated + present in a trusted room can accept a waiting participant."""
-    mock_check.return_value = True
-    user = UserFactory()
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {"participant_id": "2f7f162f-e7d1-421b-90e7-02bfbfbf8def", "allow_entry": True},
-    )
-    # Permission passed; 404 because that participant isn't actually waiting.
-    assert response.status_code == 404
-    assert response.json() == {"message": "Participant not found."}

src/backend/core/tests/services/test_livekit_events.py

@@ -854,31 +854,3 @@ def test_receive_ignores_connection_test_room(
 
     mock_handle_room_started.assert_not_called()
     mock_handle_room_finished.assert_not_called()
-
-
-@mock.patch("core.services.presence.cache.delete")
-def test_participant_left_clearing_gated_by_setting(mock_delete, service, settings):
-    """PRESENCE_CLEAR_ON_PARTICIPANT_LEFT toggles eager presence invalidation."""
-    data = mock.Mock()
-    data.room.name = "room-name"
-    data.participant.identity = "user-sub"
-
-    settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = False
-    service._handle_participant_left(data)  # pylint: disable=protected-access
-    mock_delete.assert_not_called()
-
-    settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = True
-    service._handle_participant_left(data)  # pylint: disable=protected-access
-    mock_delete.assert_called_once()
-
-
-@mock.patch("core.services.presence.cache.delete")
-def test_participant_left_without_identity_is_ignored(mock_delete, service, settings):
-    """No cache operation when the webhook carries no identity."""
-    settings.PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = True
-    data = mock.Mock()
-    data.room.name = "room-name"
-    data.participant.identity = ""
-
-    service._handle_participant_left(data)  # pylint: disable=protected-access
-    mock_delete.assert_not_called()

src/backend/core/tests/services/test_lobby.py

@@ -24,7 +24,6 @@ from core.services.lobby import (
     LobbyParticipantStatus,
     LobbyService,
 )
-from core.services.presence import CACHE_SCAN_ITERSIZE
 from core.utils import NotificationError
 
 pytestmark = pytest.mark.django_db
@@ -579,14 +578,14 @@ def test_get_participant_parsing_error(
 @mock.patch("core.services.lobby.cache")
 def test_list_waiting_participants_empty(mock_cache, lobby_service):
     """Test listing waiting participants when none exist."""
-    mock_cache.iter_keys.return_value = []
+    mock_cache.keys.return_value = []
 
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
     result = lobby_service.list_waiting_participants(room.id)
 
     assert result == []
     pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
+    mock_cache.keys.assert_called_once_with(pattern)
     mock_cache.get_many.assert_not_called()
 
 
@@ -595,7 +594,7 @@ def test_list_waiting_participants(mock_cache, lobby_service, participant_dict):
     """Test listing waiting participants with valid data."""
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
     cache_key = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    mock_cache.iter_keys.return_value = [cache_key]
+    mock_cache.keys.return_value = [cache_key]
     mock_cache.get_many.return_value = {cache_key: participant_dict}
 
     result = lobby_service.list_waiting_participants(room.id)
@@ -604,7 +603,7 @@ def test_list_waiting_participants(mock_cache, lobby_service, participant_dict):
     assert result[0]["status"] == "waiting"
     assert result[0]["username"] == "test-username"
     pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
+    mock_cache.keys.assert_called_once_with(pattern)
     mock_cache.get_many.assert_called_once_with([cache_key])
 
 
@@ -629,7 +628,7 @@ def test_list_waiting_participants_multiple(mock_cache, lobby_service):
         "color": "#654321",
     }
 
-    mock_cache.iter_keys.return_value = [cache_key1, cache_key2]
+    mock_cache.keys.return_value = [cache_key1, cache_key2]
     mock_cache.get_many.return_value = {
         cache_key1: participant1,
         cache_key2: participant2,
@@ -647,7 +646,7 @@ def test_list_waiting_participants_multiple(mock_cache, lobby_service):
     assert all(p["status"] == "waiting" for p in result)
 
     pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
+    mock_cache.keys.assert_called_once_with(pattern)
     mock_cache.get_many.assert_called_once_with([cache_key1, cache_key2])
 
 
@@ -656,7 +655,7 @@ def test_list_waiting_participants_corrupted_data(mock_cache, lobby_service):
     """Test listing waiting participants with corrupted data."""
     room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
     cache_key = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    mock_cache.iter_keys.return_value = [cache_key]
+    mock_cache.keys.return_value = [cache_key]
     mock_cache.get_many.return_value = {cache_key: {"invalid": "data"}}
 
     result = lobby_service.list_waiting_participants(room.id)
@@ -681,7 +680,7 @@ def test_list_waiting_participants_partially_corrupted(mock_cache, lobby_service
 
     corrupted_participant = {"invalid": "data"}
 
-    mock_cache.iter_keys.return_value = [cache_key1, cache_key2]
+    mock_cache.keys.return_value = [cache_key1, cache_key2]
     mock_cache.get_many.return_value = {
         cache_key1: corrupted_participant,
         cache_key2: valid_participant,
@@ -700,7 +699,7 @@ def test_list_waiting_participants_partially_corrupted(mock_cache, lobby_service
 
     # Verify both cache keys were queried
     pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
+    mock_cache.keys.assert_called_once_with(pattern)
     mock_cache.get_many.assert_called_once_with([cache_key1, cache_key2])
 
 
@@ -724,7 +723,7 @@ def test_list_waiting_participants_non_waiting(mock_cache, lobby_service):
         "color": "#654321",
     }
 
-    mock_cache.iter_keys.return_value = [cache_key1, cache_key2]
+    mock_cache.keys.return_value = [cache_key1, cache_key2]
     mock_cache.get_many.return_value = {
         cache_key1: participant1,
         cache_key2: participant2,

src/backend/core/tests/services/test_presence.py

@@ -1,108 +0,0 @@
-"""Tests for the presence cache and the cached presence check."""
-
-# pylint: disable=W0212
-
-from unittest import mock
-from uuid import uuid4
-
-from django.core.cache import cache
-
-import pytest
-
-from core.services.participants_management import (
-    ParticipantNotFoundException,
-    ParticipantsManagement,
-    ParticipantsManagementException,
-)
-from core.services.presence import PresenceCache
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_presence_cache_hit_skips_livekit(mock_check):
-    """A cached positive answer must not call LiveKit."""
-    room_id, identity = str(uuid4()), "user-sub"
-    PresenceCache().mark_present(room_id, identity)
-
-    assert (
-        ParticipantsManagement().check_if_in_meeting_cached(room_id, identity) is True
-    )
-    mock_check.assert_not_called()
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_presence_cache_miss_calls_livekit_and_caches_positive(mock_check):
-    """On a miss, LiveKit is asked once and a positive answer is memoized."""
-    mock_check.return_value = True
-    room_id, identity = str(uuid4()), "user-sub"
-    service = ParticipantsManagement()
-
-    assert service.check_if_in_meeting_cached(room_id, identity) is True
-    assert service.check_if_in_meeting_cached(room_id, identity) is True
-    assert mock_check.call_count == 1
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_presence_negative_not_cached(mock_check):
-    """Negative answers are never memoized."""
-    mock_check.return_value = False
-    room_id, identity = str(uuid4()), "user-sub"
-    service = ParticipantsManagement()
-
-    assert service.check_if_in_meeting_cached(room_id, identity) is False
-    assert service.check_if_in_meeting_cached(room_id, identity) is False
-    assert mock_check.call_count == 2
-
-
-@mock.patch(
-    "core.services.participants_management.ParticipantsManagement.check_if_in_meeting"
-)
-def test_presence_errors_propagate_and_cache_nothing(mock_check):
-    """LiveKit errors propagate to the caller (which fails closed); nothing cached."""
-    room_id, identity = str(uuid4()), "user-sub"
-
-    for exc in (ParticipantNotFoundException(), ParticipantsManagementException()):
-        mock_check.side_effect = exc
-        with pytest.raises(type(exc)):
-            ParticipantsManagement().check_if_in_meeting_cached(room_id, identity)
-        assert cache.get(PresenceCache._get_cache_key(room_id, identity)) is None
-
-
-def test_presence_clear_and_clear_room():
-    """clear() removes one entry, clear_room() removes all entries of a room."""
-    room_id, other_room = str(uuid4()), str(uuid4())
-    presence = PresenceCache()
-    presence.mark_present(room_id, "a")
-    presence.mark_present(room_id, "b")
-    presence.mark_present(other_room, "a")
-
-    presence.clear(room_id, "a")
-    assert presence.is_marked_present(room_id, "a") is False
-    assert presence.is_marked_present(room_id, "b") is True
-
-    presence.clear_room(room_id)
-    assert presence.is_marked_present(room_id, "b") is False
-    assert presence.is_marked_present(other_room, "a") is True
-
-
-def test_presence_clear_room_scans_in_pages():
-    """clear_room removes every match, even across several SCAN pages,
-    and only within the room."""
-    room_id, other_room = str(uuid4()), str(uuid4())
-    presence = PresenceCache()
-    for i in range(7):
-        presence.mark_present(room_id, f"user-{i}")
-    presence.mark_present(other_room, "user-0")
-
-    # An itersize smaller than the match count forces delete_pattern to
-    # page through several SCAN cursors rather than finish in one pass.
-    with mock.patch("core.utils.CACHE_SCAN_ITERSIZE", 3):
-        presence.clear_room(room_id)
-
-    assert all(not presence.is_marked_present(room_id, f"user-{i}") for i in range(7))
-    assert presence.is_marked_present(other_room, "user-0") is True

src/backend/core/utils.py

@@ -512,6 +512,3 @@ def build_telephony_config():
         "default_country": country,
         "international_phone_number": international,
     }
-
-
-CACHE_SCAN_ITERSIZE = 500

src/backend/meet/settings.py

@@ -856,15 +856,6 @@ class Base(Configuration):
     )
 
     # Lobby configurations
-    PRESENCE_KEY_PREFIX = values.Value(
-        "room_presence", environ_name="PRESENCE_KEY_PREFIX", environ_prefix=None
-    )
-    PRESENCE_CACHE_TIMEOUT = values.PositiveIntegerValue(
-        3600, environ_name="PRESENCE_CACHE_TIMEOUT", environ_prefix=None
-    )
-    PRESENCE_CLEAR_ON_PARTICIPANT_LEFT = values.BooleanValue(
-        True, environ_name="PRESENCE_CLEAR_ON_PARTICIPANT_LEFT", environ_prefix=None
-    )
     LOBBY_KEY_PREFIX = values.Value(
         "room_lobby", environ_name="LOBBY_KEY_PREFIX", environ_prefix=None
     )

src/backend/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "uv_build"
 
 [project]
 name = "meet"
-version = "1.29.0"
+version = "1.27.0"
 authors = [{ "name" = "DINUM", "email" = "dev@mail.numerique.gouv.fr" }]
 classifiers = [
     "Development Status :: 5 - Production/Stable",

src/backend/uv.lock

@@ -1187,7 +1187,7 @@ wheels = [
 
 [[package]]
 name = "meet"
-version = "1.29.0"
+version = "1.27.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/frontend/package-lock.json

@@ -1,40 +1,40 @@
 {
   "name": "meet",
-  "version": "1.29.0",
+  "version": "1.27.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "meet",
-      "version": "1.29.0",
+      "version": "1.27.0",
       "dependencies": {
-        "@fontsource-variable/atkinson-hyperlegible-next": "5.3.0",
+        "@fontsource-variable/atkinson-hyperlegible-next": "5.2.6",
         "@fontsource-variable/lexend": "5.2.11",
         "@fontsource/opendyslexic": "5.2.5",
         "@libreaudio/la-call": "0.1.4",
-        "@livekit/components-react": "2.9.23",
+        "@livekit/components-react": "2.9.21",
         "@livekit/components-styles": "1.2.0",
         "@livekit/track-processors": "0.7.2",
         "@mediapipe/tasks-vision": "0.10.14",
-        "@pandacss/preset-panda": "1.12.0",
+        "@pandacss/preset-panda": "1.11.3",
         "@react-types/overlays": "3.10.0",
         "@remixicon/react": "4.9.0",
-        "@tanstack/react-query": "5.101.4",
+        "@tanstack/react-query": "5.101.1",
         "@timephy/rnnoise-wasm": "1.0.0",
         "crisp-sdk-web": "1.1.2",
         "hoofd": "1.7.3",
         "humanize-duration": "3.33.2",
-        "i18next": "26.3.6",
+        "i18next": "26.3.1",
         "i18next-browser-languagedetector": "8.2.1",
         "i18next-parser": "9.4.0",
-        "i18next-resources-to-backend": "1.2.3",
-        "livekit-client": "2.21.0",
-        "posthog-js": "1.409.5",
+        "i18next-resources-to-backend": "1.2.1",
+        "livekit-client": "2.20.0",
+        "posthog-js": "1.395.0",
         "react": "18.3.1",
         "react-aria": "3.50.0",
         "react-aria-components": "1.19.0",
         "react-dom": "18.3.1",
-        "react-i18next": "17.0.10",
+        "react-i18next": "17.0.8",
         "react-stately": "3.48.0",
         "use-sound": "5.0.0",
         "valtio": "2.3.2",
@@ -742,34 +742,34 @@
       }
     },
     "node_modules/@floating-ui/core": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.8.0.tgz",
-      "integrity": "sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ==",
+      "version": "1.7.5",
+      "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz",
+      "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==",
       "license": "MIT",
       "dependencies": {
-        "@floating-ui/utils": "^0.2.12"
-      }
-    },
-    "node_modules/@floating-ui/dom": {
-      "version": "1.7.6",
-      "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.6.tgz",
-      "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@floating-ui/core": "^1.7.5",
         "@floating-ui/utils": "^0.2.11"
       }
     },
+    "node_modules/@floating-ui/dom": {
+      "version": "1.7.4",
+      "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.4.tgz",
+      "integrity": "sha512-OOchDgh4F2CchOX94cRVqhvy7b3AFb+/rQXyswmzmGakRfkMgoWVjfnLWkRirfLEfuD4ysVW16eXzwt3jHIzKA==",
+      "license": "MIT",
+      "dependencies": {
+        "@floating-ui/core": "^1.7.3",
+        "@floating-ui/utils": "^0.2.10"
+      }
+    },
     "node_modules/@floating-ui/utils": {
-      "version": "0.2.12",
-      "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.12.tgz",
-      "integrity": "sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww==",
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.11.tgz",
+      "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==",
       "license": "MIT"
     },
     "node_modules/@fontsource-variable/atkinson-hyperlegible-next": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/@fontsource-variable/atkinson-hyperlegible-next/-/atkinson-hyperlegible-next-5.3.0.tgz",
-      "integrity": "sha512-UnLzNUy1RWoLDfydAatP4NaRm99X/WbQEph7q/PymJnCFIOOwKOx3pBmp5ys8trO0dM+CKGuJgeZP9fAR4mQpA==",
+      "version": "5.2.6",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/atkinson-hyperlegible-next/-/atkinson-hyperlegible-next-5.2.6.tgz",
+      "integrity": "sha512-D0Z8peFkRGYACvmWp8Sl8YPGYLBEJbzqapugtsMEYSUUtpQDiZVDHjk9s7bqB4hSCRYCrKuW6V1V+mnHybVnPw==",
       "license": "OFL-1.1",
       "funding": {
         "url": "https://github.com/sponsors/ayuhito"
@@ -966,12 +966,12 @@
       "license": "GPL-3.0+"
     },
     "node_modules/@livekit/components-core": {
-      "version": "0.12.14",
-      "resolved": "https://registry.npmjs.org/@livekit/components-core/-/components-core-0.12.14.tgz",
-      "integrity": "sha512-6OKP/1Ok2fCZewDLKd3SzaTb7KvfZl/6hjggI+TgUdhp0Y7HBg3+tHA7YmhZRc0BO8wIyVy4VgTPn7qkLHt2nQ==",
+      "version": "0.12.13",
+      "resolved": "https://registry.npmjs.org/@livekit/components-core/-/components-core-0.12.13.tgz",
+      "integrity": "sha512-DQmi84afHoHjZ62wm8y+XPNIDHTwFHAltjd3lmyXj8UZHOY7wcza4vFt1xnghJOD5wLRY58L1dkAgAw59MgWvw==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@floating-ui/dom": "1.7.6",
+        "@floating-ui/dom": "1.7.4",
         "loglevel": "1.9.1",
         "rxjs": "7.8.2"
       },
@@ -979,17 +979,17 @@
         "node": ">=18"
       },
       "peerDependencies": {
-        "livekit-client": "^2.20.1",
+        "livekit-client": "^2.17.2",
         "tslib": "^2.6.2"
       }
     },
     "node_modules/@livekit/components-react": {
-      "version": "2.9.23",
-      "resolved": "https://registry.npmjs.org/@livekit/components-react/-/components-react-2.9.23.tgz",
-      "integrity": "sha512-clO+0g/u3YBpuOvnAjUSAJBH/o7w+RpUAseswjiSML9rHrXlTUhwBNm8LPk+qN5GOU3A6lzsNnFYVpUHUBVOkg==",
+      "version": "2.9.21",
+      "resolved": "https://registry.npmjs.org/@livekit/components-react/-/components-react-2.9.21.tgz",
+      "integrity": "sha512-6hU9VucJJL+gAhilNGe4MBCDCZVk64qyjP9Ck86krvOIdVU76WeWksddg1MYUP10AlUwwrfD7davz41pJTcMJw==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@livekit/components-core": "0.12.14",
+        "@livekit/components-core": "0.12.13",
         "clsx": "2.1.1",
         "events": "^3.3.0",
         "jose": "^6.0.12",
@@ -999,8 +999,8 @@
         "node": ">=18"
       },
       "peerDependencies": {
-        "@livekit/krisp-noise-filter": "^0.2.12 || ^0.3.0 || ^0.4.0",
-        "livekit-client": "^2.20.1",
+        "@livekit/krisp-noise-filter": "^0.2.12 || ^0.3.0",
+        "livekit-client": "^2.18.2",
         "react": ">=18",
         "react-dom": ">=18",
         "tslib": "^2.6.2"
@@ -1027,9 +1027,9 @@
       "license": "Apache-2.0"
     },
     "node_modules/@livekit/protocol": {
-      "version": "1.50.4",
-      "resolved": "https://registry.npmjs.org/@livekit/protocol/-/protocol-1.50.4.tgz",
-      "integrity": "sha512-L1uggNQAqyY21smQY8AllyOYbcv9Me9TaxwuLytL1R8ck9nbYPmQLNwEDi3pOFGAMa5F8I2nUi2Jc59W5awxlA==",
+      "version": "1.46.6",
+      "resolved": "https://registry.npmjs.org/@livekit/protocol/-/protocol-1.46.6.tgz",
+      "integrity": "sha512-upzlHP1vi/kZ/QqALZTFskQ0ifqc2f15RKucHYOsIHJsaXvEYanG75mAb7o+Yomfs4XhQ4BaRsdY+TFHXpaqrg==",
       "license": "Apache-2.0",
       "dependencies": {
         "@bufbuild/protobuf": "^1.10.0"
@@ -1642,21 +1642,21 @@
       }
     },
     "node_modules/@pandacss/preset-panda": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/@pandacss/preset-panda/-/preset-panda-1.12.0.tgz",
-      "integrity": "sha512-jhzhAmtGY34b1FlMJGEAh/IkfU4WyTNT2mpJfcBUPBi1rZLHSTcs0aqedRmMdwM4tTT43XFOXMiazbztKME60A==",
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@pandacss/preset-panda/-/preset-panda-1.11.3.tgz",
+      "integrity": "sha512-IHeRQyIYeGKpQl78A/oI9fGg8MHQiOX/HttH+iQNaRU/MbGN6JsPe/N0ekQC6QY8iiKtLhqR+SRc455SN6JVWw==",
       "license": "MIT",
       "dependencies": {
-        "@pandacss/types": "1.12.0"
+        "@pandacss/types": "1.11.3"
       },
       "engines": {
         "node": ">=20"
       }
     },
     "node_modules/@pandacss/preset-panda/node_modules/@pandacss/types": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/@pandacss/types/-/types-1.12.0.tgz",
-      "integrity": "sha512-PtlEIOBEV3RzWffeu1zH+/YFmP+fn24M63STGEbgTwjEBMhyo/FfT2sfZGB8oWAbWUBKBp69OMg25E+/rY3klQ==",
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@pandacss/types/-/types-1.11.3.tgz",
+      "integrity": "sha512-tUbxa3WzoCuulP6kcMn7f0uNgLBvu81JAg4sfoUpz6PZE36VHA3k9n6ROEwziTbr7vqgeCj5DYQCUldrVNbEGQ==",
       "license": "MIT",
       "engines": {
         "node": ">=20"
@@ -1719,29 +1719,19 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@posthog/browser-common": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/@posthog/browser-common/-/browser-common-0.3.1.tgz",
-      "integrity": "sha512-1nhMVY1wnHADTg8tR9yvm+lPAz5ROxznfQlBtLzB2FFo4lp/LU8lk9KyFPsARDkBxCfYachsJfvRjocL1G/AJQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@posthog/core": "^1.46.0",
-        "@posthog/types": "^1.399.0"
-      }
-    },
     "node_modules/@posthog/core": {
-      "version": "1.48.3",
-      "resolved": "https://registry.npmjs.org/@posthog/core/-/core-1.48.3.tgz",
-      "integrity": "sha512-kwVDVvwtCTXctApA2tpnwDjDDan8LrkwCW1Wv6PABaVs/s5ahbQ9W3pvdXcqr71HCuqukSA1jp7MySczebubGg==",
+      "version": "1.39.5",
+      "resolved": "https://registry.npmjs.org/@posthog/core/-/core-1.39.5.tgz",
+      "integrity": "sha512-M8Imv7ZmmrT6derMOFXhX3c5VKKO2oG6OX70ozLnNpKJV73sNIhYmRX/raa90saF7OA0YmWWJlpKje3irGAyQQ==",
       "license": "MIT",
       "dependencies": {
-        "@posthog/types": "^1.405.0"
+        "@posthog/types": "^1.392.0"
       }
     },
     "node_modules/@posthog/types": {
-      "version": "1.405.0",
-      "resolved": "https://registry.npmjs.org/@posthog/types/-/types-1.405.0.tgz",
-      "integrity": "sha512-4rZ/taVXKQxs9Jrf7ZjlCRgrOSL69oKAgIWJQa5kRNJ6wll1UANbrJTSY+Su1e88LIG4zZVjKKKjyQHCkHdHcw==",
+      "version": "1.392.0",
+      "resolved": "https://registry.npmjs.org/@posthog/types/-/types-1.392.0.tgz",
+      "integrity": "sha512-nctNujXL3FC1v99FktaTMSugSD9ZOZekEpahUSafkU2TSvW+XGKNkQZbokuJtiWvPBK208dwMJva8UfBkChqpw==",
       "license": "MIT"
     },
     "node_modules/@react-aria/overlays": {
@@ -2424,9 +2414,9 @@
       }
     },
     "node_modules/@tanstack/query-core": {
-      "version": "5.101.4",
-      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.101.4.tgz",
-      "integrity": "sha512-gNwcvOJcRbLWPOLG/2OBm+zM+Yv+MKsXKEOWC57USuZDEsI71hEErQsiEGx5wX9rzWWkfwM0fVSPoiIFSsxfiw==",
+      "version": "5.101.1",
+      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.101.1.tgz",
+      "integrity": "sha512-Y6Y92dkXtNqx67m2pMSxUsA3zOCwv862JexZRP8/EPwvKXMPu9m8rv43spiXWzOUIggQ3SQApttALStzhA8B4g==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -2445,12 +2435,12 @@
       }
     },
     "node_modules/@tanstack/react-query": {
-      "version": "5.101.4",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.101.4.tgz",
-      "integrity": "sha512-yRg2pfOCxIs4ZJW3XYYHU/WgtD04FHSnfHlpRT7h7pR77hwkdRG4wxbKe4aq6P0RvXUTBSQpQeadS1SUYUe+KA==",
+      "version": "5.101.1",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.101.1.tgz",
+      "integrity": "sha512-ZnONUuQKJe1bJMStXUL1s5uKN9FcfC28j5cK+iDZcdSHtUv1wtin1cGc/Oewhf2Oc4eKY7lggtpvT/AbMmhHew==",
       "license": "MIT",
       "dependencies": {
-        "@tanstack/query-core": "5.101.4"
+        "@tanstack/query-core": "5.101.1"
       },
       "funding": {
         "type": "github",
@@ -4403,14 +4393,11 @@
       }
     },
     "node_modules/core-js": {
-      "version": "3.50.0",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.50.0.tgz",
-      "integrity": "sha512-BRWgOLKkFeCgRudR6zrs8p9XJZcE14grzKMMssoYrk6krtuEZ7MTKPIY5RzOnqsEKIR9kst7wNzphttraT+Yqw==",
+      "version": "3.39.0",
+      "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.39.0.tgz",
+      "integrity": "sha512-raM0ew0/jJUqkJ0E6e8UDtl+y/7ktFivgWvqw8dNSQeNWoSDLvQ1H/RN3aPXB9tBd4/FhyR4RDPGhsNIMsAn7g==",
       "hasInstallScript": true,
       "license": "MIT",
-      "engines": {
-        "node": "*"
-      },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/core-js"
@@ -6413,9 +6400,9 @@
       }
     },
     "node_modules/i18next": {
-      "version": "26.3.6",
-      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.6.tgz",
-      "integrity": "sha512-Bu5Z2nAXgfVyM8xvW3jk9EKRIuX37PudsrBViThNFx7CR7aaYTpP01cxNB/E4c4UUzTDiAZRstEhsRfPOL/8xA==",
+      "version": "26.3.1",
+      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.1.tgz",
+      "integrity": "sha512-txQqd5EULsqEh9OJqRH15aCaOuy/nLJyhw5EHCSKLKJE1aBbb3Zve2+uQIxgWhPm1QqUQoWyQBm2kfmmIrzkcQ==",
       "funding": [
         {
           "type": "individual",
@@ -6432,7 +6419,7 @@
       ],
       "license": "MIT",
       "peerDependencies": {
-        "typescript": "^5 || ^6 || ^7"
+        "typescript": "^5 || ^6"
       },
       "peerDependenciesMeta": {
         "typescript": {
@@ -6985,10 +6972,9 @@
       }
     },
     "node_modules/i18next-resources-to-backend": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/i18next-resources-to-backend/-/i18next-resources-to-backend-1.2.3.tgz",
-      "integrity": "sha512-8Y/LLAm5fqZc2ckQxtTWbu75ndjNLzF7mcYl6rhc4g+WBopIsG3YhdYqF5qhJy64tlYhlU2KSSnEgW3gGHLqwg==",
-      "license": "MIT",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/i18next-resources-to-backend/-/i18next-resources-to-backend-1.2.1.tgz",
+      "integrity": "sha512-okHbVA+HZ7n1/76MsfhPqDou0fptl2dAlhRDu2ideXloRRduzHsqDOznJBef+R3DFZnbvWoBW+KxJ7fnFjd6Yw==",
       "dependencies": {
         "@babel/runtime": "^7.23.2"
       }
@@ -8123,20 +8109,20 @@
       "license": "MIT"
     },
     "node_modules/livekit-client": {
-      "version": "2.21.0",
-      "resolved": "https://registry.npmjs.org/livekit-client/-/livekit-client-2.21.0.tgz",
-      "integrity": "sha512-RBUhPkV/sl1nzl8lokVlK5uATPwn0AlsudCBZXissw/kDl9yz8ac4pNJ43iPpMVoHOeBYH/BZ3vUC1adqa/zFQ==",
+      "version": "2.20.0",
+      "resolved": "https://registry.npmjs.org/livekit-client/-/livekit-client-2.20.0.tgz",
+      "integrity": "sha512-RIJcpvBmOmwz3jTj3rmdY6Dzr55HrhcaJjMgY+HSmoEM+yIRyA40m7r8UKv0hnZWM3z/AYhP1q8C8ciz5UWFKQ==",
       "license": "Apache-2.0",
       "dependencies": {
         "@livekit/mutex": "1.1.1",
-        "@livekit/protocol": "1.50.4",
+        "@livekit/protocol": "1.46.6",
         "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.6"
+        "webrtc-adapter": "9.0.5"
       },
       "peerDependencies": {
         "@types/dom-mediacapture-record": "^1"
@@ -9134,18 +9120,17 @@
       "license": "MIT"
     },
     "node_modules/posthog-js": {
-      "version": "1.409.5",
-      "resolved": "https://registry.npmjs.org/posthog-js/-/posthog-js-1.409.5.tgz",
-      "integrity": "sha512-s1iJz+vq0YAluUD4OwLjUFIJt/9pqiiB6MITvHWIS16a7pqTJqbSLXsd5/8kJcIgfrOSZHe+mdYAXLYcJCS4LQ==",
-      "license": "(Apache-2.0 AND MIT)",
+      "version": "1.395.0",
+      "resolved": "https://registry.npmjs.org/posthog-js/-/posthog-js-1.395.0.tgz",
+      "integrity": "sha512-5iTb00CGt2eQUUiBQysQiX89RAbCN6wK2sDNzvs9zv0alaY8mJ0ZySrUD3LQ+XyLhgM5pCpacBuUwChqiYDLDw==",
+      "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
-        "@posthog/browser-common": "^0.3.1",
-        "@posthog/core": "^1.46.1",
-        "@posthog/types": "^1.399.0",
-        "core-js": "^3.49.0",
+        "@posthog/core": "^1.38.0",
+        "@posthog/types": "^1.391.1",
+        "core-js": "^3.38.1",
         "dompurify": "^3.3.2",
         "fflate": "^0.4.8",
-        "preact": "^10.29.3",
+        "preact": "^10.29.2",
         "query-selector-shadow-dom": "^1.0.1",
         "web-vitals": "^5.3.0"
       }
@@ -9437,9 +9422,9 @@
       }
     },
     "node_modules/react-i18next": {
-      "version": "17.0.10",
-      "resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.10.tgz",
-      "integrity": "sha512-XneHftyYA774MJkkccSkZ5oKrUpCnXIPmxio3wemqrVzCRLWiGXOMbIzObrer03fNDEnm8g8R5yYls4HcE+esg==",
+      "version": "17.0.8",
+      "resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.8.tgz",
+      "integrity": "sha512-0ooKbGLU8JXhe1zwpQUWIeXSgLPOfwJmgheWRIUpcoA0CpyabpGhayjdG+/eA5esC1AQ8h2jWpXjJfzQzeDOCw==",
       "license": "MIT",
       "dependencies": {
         "@babel/runtime": "^7.29.2",
@@ -9449,7 +9434,7 @@
       "peerDependencies": {
         "i18next": ">= 26.2.0",
         "react": ">= 16.8.0",
-        "typescript": "^5 || ^6 || ^7"
+        "typescript": "^5 || ^6"
       },
       "peerDependenciesMeta": {
         "react-dom": {
@@ -11660,9 +11645,9 @@
       "license": "Apache-2.0"
     },
     "node_modules/webrtc-adapter": {
-      "version": "9.0.6",
-      "resolved": "https://registry.npmjs.org/webrtc-adapter/-/webrtc-adapter-9.0.6.tgz",
-      "integrity": "sha512-CHbl2ZQbxx164IgWRgzJno4hWtM4tFbRam1QfI3Yxhs3w/DvqluVxVWeXs3oL5/fbGkSNLKo0Ty5MgUWceNhog==",
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/webrtc-adapter/-/webrtc-adapter-9.0.5.tgz",
+      "integrity": "sha512-U9vjByy/sK2OMXu5mmfuZFKTMIUQe34c0JXRO+oDrxJTsntdYT2iIFwYMOV7HhMTuktcZLGf2W1N/OcSf9ssWg==",
       "license": "BSD-3-Clause",
       "dependencies": {
         "sdp": "^3.2.0"

src/frontend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "meet",
   "private": true,
-  "version": "1.29.0",
+  "version": "1.27.0",
   "type": "module",
   "scripts": {
     "dev": "panda codegen && vite",
@@ -15,33 +15,33 @@
     "check": "prettier --check ./src"
   },
   "dependencies": {
-    "@fontsource-variable/atkinson-hyperlegible-next": "5.3.0",
+    "@fontsource-variable/atkinson-hyperlegible-next": "5.2.6",
     "@fontsource-variable/lexend": "5.2.11",
     "@fontsource/opendyslexic": "5.2.5",
     "@libreaudio/la-call": "0.1.4",
-    "@livekit/components-react": "2.9.23",
+    "@livekit/components-react": "2.9.21",
     "@livekit/components-styles": "1.2.0",
     "@livekit/track-processors": "0.7.2",
     "@mediapipe/tasks-vision": "0.10.14",
-    "@pandacss/preset-panda": "1.12.0",
+    "@pandacss/preset-panda": "1.11.3",
     "@react-types/overlays": "3.10.0",
     "@remixicon/react": "4.9.0",
-    "@tanstack/react-query": "5.101.4",
+    "@tanstack/react-query": "5.101.1",
     "@timephy/rnnoise-wasm": "1.0.0",
     "crisp-sdk-web": "1.1.2",
     "hoofd": "1.7.3",
     "humanize-duration": "3.33.2",
-    "i18next": "26.3.6",
+    "i18next": "26.3.1",
     "i18next-browser-languagedetector": "8.2.1",
     "i18next-parser": "9.4.0",
-    "i18next-resources-to-backend": "1.2.3",
-    "livekit-client": "2.21.0",
-    "posthog-js": "1.409.5",
+    "i18next-resources-to-backend": "1.2.1",
+    "livekit-client": "2.20.0",
+    "posthog-js": "1.395.0",
     "react": "18.3.1",
     "react-aria": "3.50.0",
     "react-aria-components": "1.19.0",
     "react-dom": "18.3.1",
-    "react-i18next": "17.0.10",
+    "react-i18next": "17.0.8",
     "react-stately": "3.48.0",
     "use-sound": "5.0.0",
     "valtio": "2.3.2",

src/frontend/src/features/analytics/exceptionFilters.ts

@@ -2,12 +2,6 @@ import type { CaptureResult } from 'posthog-js'
 
 const IGNORED_EXCEPTION_PATTERNS = [
   /ResizeObserver loop (completed with undelivered notifications|limit exceeded)/,
-  // livekit-client leaks the raw WebSocket error Event as an unhandled
-  // rejection when the signal ws errors after connect (Firefox-heavy,
-  // coincides with signal reconnects). Carries zero diagnostic content —
-  // the close reason is already logged by the SDK.
-  // See: https://github.com/livekit/client-sdk-js/issues/2062
-  /^Event captured as exception with keys: isTrusted$/,
 ]
 
 const shouldIgnoreException = (value: unknown): boolean =>

src/frontend/src/features/analytics/telemetry.ts

@@ -137,7 +137,6 @@ export const captureMediaEvent = async (
     | 'media-device-topology'
     | 'media-device-success'
     | 'device-not-found'
-    | 'device-in-use'
     | 'permissions-denied'
     | 'screen-share-permission-denied'
     | 'silent-mic-detected'

src/frontend/src/features/layout/components/ControlBarRegion.tsx

@@ -13,7 +13,7 @@ const controlBarRegion = cva({
     mobile: {
       true: {
         justifyContent: 'center',
-        width: '100%',
+        width: '330px',
       },
     },
   },

src/frontend/src/features/notifications/components/ToastJoined.tsx

@@ -1,5 +1,5 @@
 import { useToast } from 'react-aria'
-import { useMemo, useRef } from 'react'
+import { useRef } from 'react'
 import { Button as RACButton } from 'react-aria-components'
 import { Track } from 'livekit-client'
 import Source = Track.Source
@@ -11,7 +11,6 @@ import { Div } from '@/primitives'
 import { useTranslation } from 'react-i18next'
 import { StyledToastContainer } from './StyledToastContainer'
 import { setPinnedTrack } from '@/stores/layout'
-import { useParticipantTracks } from '@livekit/components-react'
 
 const ClickableToast = styled(RACButton, {
   base: {
@@ -31,18 +30,14 @@ export function ToastJoined({ state, ...props }: Readonly<ToastProps>) {
   )
   const participant = props.toast.content.participant
 
-  const [cameraTrack] = useParticipantTracks(
-    [Source.Camera],
-    participant?.identity
-  )
-
-  const trackReference = useMemo(
-    () => cameraTrack ?? { participant, source: Source.Camera },
-    [cameraTrack, participant]
-  )
-
   if (!participant) return
 
+  const trackReference = {
+    participant,
+    publication: participant.getTrackPublication(Source.Camera),
+    source: Source.Camera,
+  }
+
   return (
     <StyledToastContainer {...toastProps} ref={ref}>
       <ClickableToast

src/frontend/src/features/participantTile/components/participantTileFocus/MuteButton.tsx

@@ -1,9 +1,11 @@
 import { Participant, Track } from 'livekit-client'
 import { useTranslation } from 'react-i18next'
 import { useTrackMutedIndicator } from '@livekit/components-react'
+import { useMuteParticipant } from '@/features/rooms/api/muteParticipant'
+import { useState } from 'react'
 import { Button } from '@/primitives'
 import { RiMicLine, RiMicOffLine } from '@remixicon/react'
-import { openMuteDialog } from '@/stores/muteDialog'
+import { MuteAlertDialog } from '@/features/rooms/livekit/components/MuteAlertDialog'
 
 export const MuteButton = ({ participant }: { participant: Participant }) => {
   const { t } = useTranslation('rooms', { keyPrefix: 'participantTileFocus' })
@@ -13,18 +15,31 @@ export const MuteButton = ({ participant }: { participant: Participant }) => {
     source: Track.Source.Microphone,
   })
 
+  const { muteParticipant } = useMuteParticipant()
+  const [isAlertOpen, setIsAlertOpen] = useState(false)
+
   const name = participant.name || participant.identity
 
   return (
-    <Button
-      isDisabled={isMuted}
-      size={'sm'}
-      variant={'primaryTextDark'}
-      square
-      onPress={() => openMuteDialog(participant)}
-      tooltip={t('muteParticipant', { name })}
-    >
-      {!isMuted ? <RiMicLine /> : <RiMicOffLine />}
-    </Button>
+    <>
+      <Button
+        isDisabled={isMuted}
+        size={'sm'}
+        variant={'primaryTextDark'}
+        square
+        onPress={() => setIsAlertOpen(true)}
+        tooltip={t('muteParticipant', { name })}
+      >
+        {!isMuted ? <RiMicLine /> : <RiMicOffLine />}
+      </Button>
+      <MuteAlertDialog
+        isOpen={isAlertOpen}
+        onSubmit={() =>
+          muteParticipant(participant).then(() => setIsAlertOpen(false))
+        }
+        onClose={() => setIsAlertOpen(false)}
+        name={name}
+      />
+    </>
   )
 }

src/frontend/src/features/participants/components/ParticipantRow.tsx

@@ -19,11 +19,13 @@ import {
 import Source = Track.Source
 import { RiMicFill, RiMicOffFill } from '@remixicon/react'
 import { Button } from '@/primitives'
+import { useState } from 'react'
+import { useMuteParticipant } from '@/features/rooms/api/muteParticipant'
 import { useCanMute } from '@/features/rooms/livekit/hooks/useCanMute'
 import { ParticipantMenuButton } from './menu/ParticipantMenuButton'
 import { PinBadge } from './PinBadge'
 import { UnauthenticatedBadge } from './UnauthenticatedBadge'
-import { openMuteDialog } from '@/stores/muteDialog'
+import { MuteAlertDialog } from '@/features/rooms/livekit/components/MuteAlertDialog'
 import { ParticipantName } from './ParticipantName'
 
 type MicIndicatorProps = {
@@ -32,6 +34,7 @@ type MicIndicatorProps = {
 
 const MicIndicator = ({ participant }: MicIndicatorProps) => {
   const { t } = useTranslation('rooms')
+  const { muteParticipant } = useMuteParticipant()
   const { isMuted } = useTrackMutedIndicator({
     participant: participant,
     source: Source.Microphone,
@@ -39,6 +42,7 @@ const MicIndicator = ({ participant }: MicIndicatorProps) => {
 
   const canMute = useCanMute(participant)
   const isSpeaking = useIsSpeaking(participant)
+  const [isAlertOpen, setIsAlertOpen] = useState(false)
   const name = participant.name || participant.identity
 
   const label = isLocal(participant)
@@ -48,34 +52,46 @@ const MicIndicator = ({ participant }: MicIndicatorProps) => {
       })
 
   return (
-    <Button
-      square
-      variant="greyscale"
-      size="sm"
-      tooltip={label}
-      aria-label={label}
-      isDisabled={isMuted || !canMute}
-      onPress={async () =>
-        !isMuted && isLocal(participant)
-          ? await (participant as LocalParticipant)?.setMicrophoneEnabled(false)
-          : openMuteDialog(participant)
-      }
-      data-attr="participants-mute"
-    >
-      {isMuted ? (
-        <RiMicOffFill color={'gray'} aria-hidden={true} />
-      ) : (
-        <RiMicFill
-          className={css({
-            color: isSpeaking ? 'primaryDark.300' : 'primaryDark.50',
-            animation: isSpeaking
-              ? 'pulse_background 800ms infinite'
-              : undefined,
-          })}
-          aria-hidden={true}
-        />
-      )}
-    </Button>
+    <>
+      <Button
+        square
+        variant="greyscale"
+        size="sm"
+        tooltip={label}
+        aria-label={label}
+        isDisabled={isMuted || !canMute}
+        onPress={async () =>
+          !isMuted && isLocal(participant)
+            ? await (participant as LocalParticipant)?.setMicrophoneEnabled(
+                false
+              )
+            : setIsAlertOpen(true)
+        }
+        data-attr="participants-mute"
+      >
+        {isMuted ? (
+          <RiMicOffFill color={'gray'} aria-hidden={true} />
+        ) : (
+          <RiMicFill
+            className={css({
+              color: isSpeaking ? 'primaryDark.300' : 'primaryDark.50',
+              animation: isSpeaking
+                ? 'pulse_background 800ms infinite'
+                : undefined,
+            })}
+            aria-hidden={true}
+          />
+        )}
+      </Button>
+      <MuteAlertDialog
+        isOpen={isAlertOpen}
+        onSubmit={() =>
+          muteParticipant(participant).then(() => setIsAlertOpen(false))
+        }
+        onClose={() => setIsAlertOpen(false)}
+        name={name}
+      />
+    </>
   )
 }
 

src/frontend/src/features/participants/hooks/useWaitingParticipants.ts

@@ -1,31 +1,61 @@
-import { useMemo } from 'react'
-
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useRoomContext } from '@livekit/components-react'
+import { RoomEvent } from 'livekit-client'
 import { useRoomData } from '@/features/rooms/livekit/hooks/useRoomData'
-import { useCanManageLobby } from '@/features/rooms/livekit/hooks/useCanManageLobby'
+import { useIsAdminOrOwner } from '@/features/rooms/livekit/hooks/useIsAdminOrOwner'
 import { useEnterRoom } from '../api/enterRoom'
 import {
   useListWaitingParticipants,
   type WaitingParticipant,
 } from '../../participants/api/listWaitingParticipants'
+import { decodeNotificationDataReceived } from '@/features/notifications/utils'
+import { NotificationType } from '@/features/notifications/NotificationType'
 import { reportError } from '@/features/analytics/telemetry'
 
+export const POLL_INTERVAL_MS = 1000
+
 export const useWaitingParticipants = () => {
+  const [listEnabled, setListEnabled] = useState(true)
+
   const roomData = useRoomData()
   const roomId = roomData?.id || '' // FIXME - bad practice
 
-  const canManageLobby = useCanManageLobby()
+  const room = useRoomContext()
+  const isAdminOrOwner = useIsAdminOrOwner()
+
+  const handleDataReceived = useCallback((payload: Uint8Array) => {
+    const notification = decodeNotificationDataReceived(payload)
+    if (notification?.type === NotificationType.ParticipantWaiting) {
+      setListEnabled(true)
+    }
+  }, [])
+
+  useEffect(() => {
+    if (isAdminOrOwner) {
+      room.on(RoomEvent.DataReceived, handleDataReceived)
+    }
+    return () => {
+      room.off(RoomEvent.DataReceived, handleDataReceived)
+    }
+  }, [isAdminOrOwner, room, handleDataReceived])
 
   const { data: waitingData, refetch: refetchWaiting } =
     useListWaitingParticipants(roomId, {
       retry: false,
-      enabled: false,
+      enabled: listEnabled && isAdminOrOwner,
+      refetchInterval: POLL_INTERVAL_MS,
+      refetchIntervalInBackground: true,
     })
 
   const waitingParticipants = useMemo(
-    () => (canManageLobby ? waitingData?.participants || [] : []),
-    [waitingData, canManageLobby]
+    () => waitingData?.participants || [],
+    [waitingData]
   )
 
+  useEffect(() => {
+    if (!waitingParticipants.length) setListEnabled(false)
+  }, [waitingParticipants])
+
   const { mutateAsync: enterRoom } = useEnterRoom()
 
   const handleParticipantEntry = async (
@@ -44,6 +74,8 @@ export const useWaitingParticipants = () => {
     allowEntry: boolean
   ): Promise<void> => {
     try {
+      setListEnabled(false)
+
       await Promise.all(
         waitingParticipants.map((participant) =>
           enterRoom({
@@ -57,6 +89,7 @@ export const useWaitingParticipants = () => {
       await refetchWaiting()
     } catch (e) {
       reportError('generic_failure', e)
+      setListEnabled(true)
     }
   }
 

src/frontend/src/features/reactions/components/ReactionsToggle.tsx

@@ -1,3 +1,4 @@
+import { useCallback } from 'react'
 import { useTranslation } from 'react-i18next'
 import { RiEmotionLine } from '@remixicon/react'
 import { ToggleButton } from '@/primitives'
@@ -6,8 +7,6 @@ import { useRegisterKeyboardShortcut } from '@/features/shortcuts/useRegisterKey
 import { REACTIONS_TOOLBAR_ID } from '../constants'
 import { useReactionsToolbar } from '../hooks/useReactionsToolbar'
 import { layoutStore } from '@/stores/layout'
-import { type ButtonRecipeProps } from '@/primitives/buttonRecipe'
-import { ToggleButtonProps } from '@/primitives/ToggleButton'
 
 const focusReactionsToolbar = () => {
   document
@@ -18,44 +17,35 @@ const focusReactionsToolbar = () => {
 
 export const REACTIONS_TOGGLE_ID = 'reactions-toggle'
 
-/* eslint-disable react-refresh/only-export-components */
-export const reactionShortcutHandler = () => {
-  if (layoutStore.showReactionsToolbar) {
-    focusReactionsToolbar()
-  } else {
-    layoutStore.showReactionsToolbar = true
-  }
-}
-
-type Props = Pick<NonNullable<ButtonRecipeProps>, 'variant'> & ToggleButtonProps
-
-export const ReactionsToggle = ({
-  variant = 'primaryDark',
-  onPress,
-  ...props
-}: Props) => {
+export const ReactionsToggle = () => {
   const { t } = useTranslation('rooms', { keyPrefix: 'controls.reactions' })
 
   const { isOpen, toggle } = useReactionsToolbar()
 
+  const handleShortcut = useCallback(() => {
+    if (layoutStore.showReactionsToolbar) {
+      focusReactionsToolbar()
+    } else {
+      layoutStore.showReactionsToolbar = true
+    }
+  }, [])
+
   useRegisterKeyboardShortcut({
     id: 'reaction',
-    handler: reactionShortcutHandler,
+    handler: handleShortcut,
   })
 
   return (
     <ToggleButton
-      {...props}
       id={REACTIONS_TOGGLE_ID}
       data-attr="reactions-toggle"
       square
-      variant={variant}
+      variant="primaryDark"
       aria-label={t('button')}
       aria-expanded={isOpen}
       tooltip={t('button')}
       isSelected={isOpen}
       onChange={toggle}
-      onPress={onPress}
     >
       <RiEmotionLine />
     </ToggleButton>

src/frontend/src/features/recording/hooks/useMutateRecording.ts

@@ -1,20 +1,17 @@
 import { useStartRecording, useStopRecording } from '@/features/recording'
 import { recordingStore } from '@/stores/recording'
-import { captureEvent } from '@/features/analytics/telemetry'
 
 export const useMutateRecording = () => {
   const { mutateAsync: startRecording, isPending: isPendingToStart } =
     useStartRecording({
       onError: () => {
         recordingStore.isErrorDialogOpen = 'start'
-        captureEvent('error-starting-recording')
       },
     })
   const { mutateAsync: stopRecording, isPending: isPendingToStop } =
     useStopRecording({
       onError: () => {
         recordingStore.isErrorDialogOpen = 'stop'
-        captureEvent('error-stopping-recording')
       },
     })
 

src/frontend/src/features/rooms/components/Conference.tsx

@@ -6,15 +6,12 @@ import {
   usePersistentUserChoices,
 } from '@livekit/components-react'
 import {
-  ConnectionError,
-  ConnectionErrorReason,
   DisconnectReason,
   MediaDeviceFailure,
   Room,
   type RoomOptions,
   VideoPresets,
 } from 'livekit-client'
-import { getMediaDeviceFailure } from '@/features/rooms/livekit/utils/mediaPermissions'
 import { keys } from '@/api/queryKeys'
 import { queryClient } from '@/api/queryClient'
 import { Screen } from '@/layout/Screen'
@@ -28,11 +25,7 @@ import { VideoConference } from '../livekit/prefabs/VideoConference'
 import { css } from '@/styled-system/css'
 import { BackgroundProcessorFactory } from '../livekit/components/blur'
 import { LocalUserChoices } from '@/stores/userChoices'
-import {
-  captureEvent,
-  captureMediaEvent,
-  reportError,
-} from '@/features/analytics/telemetry'
+import { captureMediaEvent, reportError } from '@/features/analytics/telemetry'
 import { useConfig } from '@/api/useConfig'
 import { isFireFox } from '@/utils/livekit'
 import { useIsMobile } from '@/utils/useIsMobile'
@@ -43,7 +36,6 @@ import { useSnapshot } from 'valtio'
 import { userPreferencesStore } from '@/stores/userPreferences'
 import { userStore } from '@/stores/user'
 import { WatchMediaDeviceErrors } from './WatchMediaDeviceErrors'
-import { VOICE_AUDIO_CONSTRAINTS } from '@/features/rooms/livekit/utils/constants'
 
 export const Conference = ({
   roomId,
@@ -116,7 +108,6 @@ export const Conference = ({
       },
       audioCaptureDefaults: {
         deviceId: userConfig.audioDeviceId ?? undefined,
-        ...VOICE_AUDIO_CONSTRAINTS,
       },
       audioOutput: {
         deviceId: userConfig.audioOutputDeviceId ?? undefined,
@@ -234,18 +225,8 @@ export const Conference = ({
             backgroundColor: 'primaryDark.50 !important',
           })}
           onError={(e) => {
-            const failure = getMediaDeviceFailure(e)
+            const failure = MediaDeviceFailure.getFailure(e)
             if (failure && failure !== MediaDeviceFailure.Other) return
-
-            // connect() was aborted by a disconnect() before the join completed
-            if (
-              e instanceof ConnectionError &&
-              e.reason === ConnectionErrorReason.Cancelled
-            ) {
-              void captureEvent('connection-cancelled')
-              return
-            }
-
             reportError('livekit_room_error', e, {
               path: 'connect_publish',
             })

src/frontend/src/features/rooms/components/Join.tsx

@@ -28,7 +28,6 @@ import {
   userChoicesStore,
 } from '@/stores/userChoices'
 import { useCannotUseDevice } from '../livekit/hooks/useCannotUseDevice'
-import { useDeviceInUse } from '../livekit/hooks/useDeviceInUse'
 import { useDeviceMissing } from '../livekit/hooks/useDeviceMissing'
 import { useJoinTracks } from '../livekit/hooks/useJoinTracks'
 import { SilentMicDetector } from './SilentMicDetector'
@@ -219,14 +218,12 @@ const switchTrackDevice =
 function getPreviewMessages({
   cameraFound,
   cameraDenied,
-  cameraInUse,
   micDenied,
   videoEnabled,
   videoStarted,
 }: {
   cameraFound: boolean
   cameraDenied: boolean
-  cameraInUse: boolean
   micDenied: boolean
   videoEnabled: boolean
   videoStarted: boolean
@@ -238,9 +235,6 @@ function getPreviewMessages({
     const key = micDenied ? 'cameraAndMicNotGranted' : 'cameraNotGranted'
     return { hint: key, permissionsButtonLabel: key }
   }
-  if (cameraInUse) {
-    return { hint: 'cameraInUse', permissionsButtonLabel: null }
-  }
   if (!videoEnabled) {
     return { hint: 'cameraDisabled', permissionsButtonLabel: null }
   }
@@ -334,20 +328,18 @@ const VideoPreview = ({
   const cameraDenied = useCannotUseDevice('videoinput')
   const micDenied = useCannotUseDevice('audioinput')
   const cameraMissing = useDeviceMissing('videoinput')
-  const cameraInUse = useDeviceInUse('videoinput')
 
   const { videoEl, videoStarted } = useAttachedVideo(videoTrack, videoEnabled)
 
   const { hint, permissionsButtonLabel } = getPreviewMessages({
     cameraFound: !cameraMissing,
     cameraDenied,
-    cameraInUse,
     micDenied,
     videoEnabled,
     videoStarted,
   })
 
-  const isError = cameraMissing || cameraDenied || cameraInUse
+  const isError = cameraMissing || cameraDenied
 
   return (
     <div className={styles.previewFrame}>

src/frontend/src/features/rooms/components/LobbyProvider.tsx

@@ -1,114 +0,0 @@
-import { useCallback, useEffect } from 'react'
-import { useConnectionState, useRoomContext } from '@livekit/components-react'
-import { ConnectionState, RoomEvent } from 'livekit-client'
-import { useCanManageLobby } from '@/features/rooms/livekit/hooks/useCanManageLobby'
-import { useRoomData } from '@/features/rooms/livekit/hooks/useRoomData'
-import { useListWaitingParticipants } from '@/features/participants/api/listWaitingParticipants'
-import { useSidePanel } from '@/features/rooms/livekit/hooks/useSidePanel'
-import { decodeNotificationDataReceived } from '@/features/notifications/utils'
-import { NotificationType } from '@/features/notifications'
-import { usePrevious } from '@/hooks/usePrevious'
-import { keys } from '@/api/queryKeys'
-import { queryClient } from '@/api/queryClient'
-import { ApiError } from '@/api/ApiError'
-
-export const POLL_INTERVAL_MS = 1000
-export const LAZY_POLL_INTERVAL_MS = 10_000
-
-export const LobbyProvider = () => {
-  const room = useRoomContext()
-
-  const canManageLobby = useCanManageLobby()
-  const roomData = useRoomData()
-  const { isParticipantsOpen } = useSidePanel()
-  const isConnected = useConnectionState(room) === ConnectionState.Connected
-
-  const roomId = roomData?.id || '' // FIXME - bad practice
-
-  const { error: waitingError, refetch: refetchWaiting } =
-    useListWaitingParticipants(roomId, {
-      retry: false,
-      enabled: canManageLobby && isConnected && !!roomId,
-      refetchOnMount: false,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      refetchInterval: (query) => {
-        if (!query.state.data?.participants?.length) return false
-        if (isParticipantsOpen) return POLL_INTERVAL_MS
-        return LAZY_POLL_INTERVAL_MS
-      },
-      refetchIntervalInBackground: true,
-    })
-
-  // Triggers: each one-shot, idempotent, deduped by React Query if
-  // concurrent. The interval takes over whenever a fetch finds waiters.
-  const fetchIfManager = useCallback(() => {
-    if (canManageLobby) refetchWaiting()
-  }, [canManageLobby, refetchWaiting])
-
-  // 1. Connection established (join or reconnect)
-  useEffect(() => {
-    room.on(RoomEvent.Connected, fetchIfManager)
-    room.on(RoomEvent.Reconnected, fetchIfManager)
-    return () => {
-      room.off(RoomEvent.Connected, fetchIfManager)
-      room.off(RoomEvent.Reconnected, fetchIfManager)
-    }
-  }, [room, fetchIfManager])
-
-  // 2. Someone started waiting (LiveKit broadcast).
-  const handleDataReceived = useCallback(
-    (payload: Uint8Array) => {
-      const notification = decodeNotificationDataReceived(payload)
-      if (notification?.type === NotificationType.ParticipantWaiting) {
-        fetchIfManager()
-      }
-    },
-    [fetchIfManager]
-  )
-
-  useEffect(() => {
-    if (canManageLobby) {
-      room.on(RoomEvent.DataReceived, handleDataReceived)
-    }
-    return () => {
-      room.off(RoomEvent.DataReceived, handleDataReceived)
-    }
-  }, [canManageLobby, room, handleDataReceived])
-
-  // 3. Rights regained.
-  const prevCanManageLobby = usePrevious(canManageLobby)
-  useEffect(() => {
-    if (!prevCanManageLobby && canManageLobby && isConnected) {
-      fetchIfManager()
-    }
-  }, [
-    prevCanManageLobby,
-    canManageLobby,
-    isParticipantsOpen,
-    fetchIfManager,
-    isConnected,
-  ])
-
-  const clearWaitingList = useCallback(() => {
-    const queryKey = [keys.waitingParticipants, roomId]
-    queryClient.cancelQueries({ queryKey })
-    queryClient.setQueryData(queryKey, { participants: [] })
-  }, [roomId])
-
-  // Rights lost mid-meeting (covers trusted -> restricted/public).
-  useEffect(() => {
-    if (prevCanManageLobby && !canManageLobby) clearWaitingList()
-  }, [prevCanManageLobby, canManageLobby, clearWaitingList])
-
-  useEffect(() => {
-    if (
-      waitingError instanceof ApiError &&
-      [401, 403].includes(waitingError.statusCode)
-    ) {
-      clearWaitingList()
-    }
-  }, [waitingError, clearWaitingList])
-
-  return null
-}

src/frontend/src/features/rooms/components/Rating.tsx

@@ -15,8 +15,7 @@ const Card = styled('div', {
     marginTop: '1.5rem',
     borderRadius: '0.25rem',
     boxShadow: '',
-    width: '100%',
-    maxWidth: '380px',
+    minWidth: '380px',
     minHeight: '196px',
   },
 })
@@ -38,11 +37,8 @@ const ratingButtonRecipe = cva({
     color: 'initial',
     border: 'none',
     borderRadius: 0,
-    padding: { base: '0.5rem 0.25rem', xsm: '0.5rem 0.85rem' },
+    padding: '0.5rem 0.85rem',
     flexGrow: '1',
-    flexBasis: 0,
-    minWidth: 0,
-    textAlign: 'center',
     cursor: 'pointer',
   },
   variants: {
@@ -103,9 +99,7 @@ const OpenFeedback = ({
 
   return (
     <Card>
-      <H lvl={3} centered>
-        {t('question')}
-      </H>
+      <H lvl={3}>{t('question')}</H>
       <TextArea
         id="feedbackInput"
         name="feedback"
@@ -174,9 +168,7 @@ const RateQuality = ({
 
   return (
     <Card>
-      <H lvl={3} centered>
-        {t('question')}
-      </H>
+      <H lvl={3}>{t('question')}</H>
       <Bar>
         {[...Array(maxRating)].map((_, index) => (
           <RACButton
@@ -236,9 +228,7 @@ const ConfirmationMessage = ({ onNext }: { onNext: () => void }) => {
       }}
     >
       <VStack gap={0}>
-        <H lvl={3} centered>
-          {t('heading')}
-        </H>
+        <H lvl={3}>{t('heading')}</H>
         <Text as="p" variant="paragraph" centered>
           {t('body')}
         </Text>

src/frontend/src/features/rooms/hooks/useWatchDeviceReleased.ts

@@ -1,53 +0,0 @@
-import { useEffect } from 'react'
-import { useSnapshot } from 'valtio'
-import {
-  clearDeviceInUseForOtherDevice,
-  deviceAvailabilityStore,
-} from '@/stores/deviceAvailability'
-import { userChoicesStore } from '@/stores/userChoices'
-import { probeDeviceReleased } from '../livekit/utils/mediaPermissions'
-import type { PermissionKind } from '@/stores/permissions'
-
-const RETRY_INTERVAL_MS = 30_000
-
-/**
- * There is no browser event for "another app released the device", so
- * while a device is flagged in use, re-probe it periodically. The probe
- * targets the currently selected device (the flag is about what the app
- * would acquire, not about any device of the kind). Only clears the flag
- * (the toggle becomes usable again); it never re-enables the device on
- * the user's behalf.
- */
-export function useWatchDeviceReleased() {
-  const { cameraInUse, microphoneInUse } = useSnapshot(deviceAvailabilityStore)
-  const { audioDeviceId, videoDeviceId } = useSnapshot(userChoicesStore)
-  useWatchKind('camera', cameraInUse, videoDeviceId)
-  useWatchKind('microphone', microphoneInUse, audioDeviceId)
-}
-
-function useWatchKind(
-  kind: PermissionKind,
-  inUse: boolean,
-  selectedDeviceId?: string
-) {
-  useEffect(() => {
-    if (inUse) clearDeviceInUseForOtherDevice(kind, selectedDeviceId)
-  }, [kind, inUse, selectedDeviceId])
-
-  useEffect(() => {
-    if (!inUse) return
-    let stopped = false
-    let timer: number | undefined
-    const tick = async () => {
-      await probeDeviceReleased(kind, selectedDeviceId || undefined)
-      if (!stopped) {
-        timer = window.setTimeout(tick, RETRY_INTERVAL_MS)
-      }
-    }
-    timer = window.setTimeout(tick, RETRY_INTERVAL_MS)
-    return () => {
-      stopped = true
-      window.clearTimeout(timer)
-    }
-  }, [kind, inUse, selectedDeviceId])
-}

src/frontend/src/features/rooms/livekit/components/IsIdleDisconnectModal.tsx

@@ -3,7 +3,7 @@ import { useTranslation } from 'react-i18next'
 import { css } from '@/styled-system/css'
 import { useSnapshot } from 'valtio'
 import { connectionObserverStore } from '@/stores/connectionObserver'
-import { Stack } from '@/styled-system/jsx'
+import { HStack } from '@/styled-system/jsx'
 import { useEffect, useRef, useState } from 'react'
 import { navigateTo } from '@/navigation/navigateTo'
 import { useScreenReaderAnnounce } from '@/hooks/useScreenReaderAnnounce'
@@ -134,11 +134,7 @@ export const IsIdleDisconnectModal = () => {
             </H>
             <Description />
             <Settings />
-            <Stack
-              direction={{ base: 'column', xsm: 'row' }}
-              align={{ base: 'stretch', xsm: 'center' }}
-              marginTop="2rem"
-            >
+            <HStack marginTop="2rem">
               <Button
                 onPress={() => {
                   connectionObserverStore.isIdleDisconnectModalOpen = false
@@ -152,7 +148,7 @@ export const IsIdleDisconnectModal = () => {
               <Button onPress={close} size="sm" variant="primary">
                 {t('stayButton')}
               </Button>
-            </Stack>
+            </HStack>
           </div>
         )
       }}

src/frontend/src/features/rooms/livekit/components/MuteAlertDialogProvider.tsx

@@ -1,28 +0,0 @@
-import { useRef } from 'react'
-import { useSnapshot } from 'valtio'
-import { useMuteParticipant } from '@/features/rooms/api/muteParticipant'
-import { closeMuteDialog, muteDialogStore } from '@/stores/muteDialog'
-import { MuteAlertDialog } from './MuteAlertDialog'
-
-export const MuteAlertDialogProvider = () => {
-  const { participant } = useSnapshot(muteDialogStore)
-  const { muteParticipant } = useMuteParticipant()
-
-  const lastNameRef = useRef('')
-  if (participant) {
-    lastNameRef.current = participant.name || participant.identity
-  }
-
-  return (
-    <MuteAlertDialog
-      isOpen={!!participant}
-      name={lastNameRef.current}
-      onClose={closeMuteDialog}
-      onSubmit={() => {
-        const target = muteDialogStore.participant
-        if (!target) return
-        muteParticipant(target).then(closeMuteDialog)
-      }}
-    />
-  )
-}

src/frontend/src/features/rooms/livekit/components/blur/BackgroundCustomProcessor.ts

@@ -105,7 +105,9 @@ export class BackgroundCustomProcessor implements BackgroundProcessorInterface {
 
   _initVirtualBackgroundImage() {
     if (this.options.type !== 'virtual') {
-      return
+      throw new Error(
+        'Virtual background is only supported for virtual background'
+      )
     }
 
     const needsUpdate =

src/frontend/src/features/rooms/livekit/components/controls/Device/PermissionNeededButton.tsx

@@ -5,18 +5,16 @@ import { css } from '@/styled-system/css'
 import { useTranslation } from 'react-i18next'
 
 type PermissionNeededButtonProps = {
-  tooltip?: string | null
-  onPress?: (() => void) | null
-  ariaLabel?: string
+  tooltip?: string
+  onPress?: () => void
 }
 
 export const PermissionNeededButton = ({
   tooltip,
   onPress,
-  ariaLabel,
 }: PermissionNeededButtonProps) => {
   const { t } = useTranslation('rooms', { keyPrefix: 'permissionsButton' })
-  const label = tooltip === undefined ? t('tooltip') : tooltip
+  const label = tooltip ?? t('tooltip')
   return (
     <div
       className={css({
@@ -28,13 +26,9 @@ export const PermissionNeededButton = ({
       })}
     >
       <Button
-        aria-label={ariaLabel ?? label ?? t('ariaLabel')}
-        tooltip={label ?? undefined}
-        onPress={
-          onPress === undefined
-            ? () => openPermissionsDialog()
-            : (onPress ?? undefined)
-        }
+        aria-label={tooltip ? label : t('ariaLabel')}
+        tooltip={label}
+        onPress={onPress ?? (() => openPermissionsDialog())}
         variant="permission"
       >
         <div

src/frontend/src/features/rooms/livekit/components/controls/Device/ToggleDevice.tsx

@@ -20,10 +20,8 @@ import { openPermissionsDialog } from '@/stores/permissions'
 import { openSilentMicDialog, silentMicStore } from '@/stores/silentMic'
 import { useSnapshot } from 'valtio'
 import { useCannotUseDevice } from '../../../hooks/useCannotUseDevice'
-import { useDeviceInUse } from '../../../hooks/useDeviceInUse'
 import { useDeviceMissing } from '../../../hooks/useDeviceMissing'
-import { requestDevicePermission } from '../../../utils/mediaPermissions'
-import { userChoicesStore } from '@/stores/userChoices'
+import { requestDevicePermission } from '../../../hooks/useJoinTracks'
 import { useDeviceIcons } from '../../../hooks/useDeviceIcons'
 import { useDeviceShortcut } from '../../../hooks/useDeviceShortcut'
 import type {
@@ -99,51 +97,38 @@ export const ToggleDevice = <T extends ToggleSource>({
   const deviceIcons = useDeviceIcons(kind)
   const cannotUseDevice = useCannotUseDevice(kind)
   const deviceMissing = useDeviceMissing(kind)
-  const deviceInUse = useDeviceInUse(kind)
-  const explainDeviceInUse = deviceInUse && context === 'room'
   const { status: silentMicStatus } = useSnapshot(silentMicStore)
   const silentMicWarning =
     kind === 'audioinput' &&
     silentMicStatus === 'silent' &&
     !cannotUseDevice &&
-    !deviceMissing &&
-    !deviceInUse
+    !deviceMissing
   const deviceShortcut = useDeviceShortcut(kind)
   const announce = useScreenReaderAnnounce()
 
   const isRequestingPermission = useRef(false)
-  const [alertError, setAlertError] = useState<MediaDeviceFailure | null>(null)
-
-  const mediaPath = context === 'join' ? 'join_preview' : 'room'
+  const [showDeviceNotFound, setShowDeviceNotFound] = useState(false)
 
   const onPress = async () => {
     if (!enabled && deviceMissing) {
-      setAlertError(MediaDeviceFailure.NotFound)
+      setShowDeviceNotFound(true)
       return
     }
-    if (!cannotUseDevice && !deviceInUse) {
+    if (!cannotUseDevice) {
       toggle()
       return
     }
     if (isRequestingPermission.current) return
     isRequestingPermission.current = true
     try {
-      const selectedDeviceId = cannotUseDevice
-        ? undefined
-        : kind === 'videoinput'
-          ? userChoicesStore.videoDeviceId
-          : userChoicesStore.audioDeviceId
-      const acquired = await requestDevicePermission(
+      const granted = await requestDevicePermission(
         kind,
-        mediaPath,
-        selectedDeviceId || undefined
+        context === 'join' ? 'join_preview' : 'room'
       )
-      if (acquired) {
+      if (granted) {
         toggle()
-      } else if (cannotUseDevice) {
+      } else {
         openPermissionsDialog(kind)
-      } else if (explainDeviceInUse) {
-        setAlertError(MediaDeviceFailure.DeviceInUse)
       }
     } finally {
       isRequestingPermission.current = false
@@ -194,34 +179,13 @@ export const ToggleDevice = <T extends ToggleSource>({
     return <ActiveSpeakerWrapper />
   }
 
-  const getToggleTooltip = () => {
-    if (deviceMissing) return t(`deviceNotFound.${kind}`)
-    if (explainDeviceInUse) return t(`deviceInUse.${kind}`)
-    if (cannotUseDevice) return t('tooltip', { keyPrefix: 'permissionsButton' })
-    return toggleLabel
-  }
-  const toggleTooltip = getToggleTooltip()
-
   return (
     <div style={{ position: 'relative' }}>
       {(cannotUseDevice || deviceMissing) && (
         <PermissionNeededButton
           tooltip={deviceMissing ? t(`deviceNotFound.${kind}`) : undefined}
           onPress={
-            deviceMissing
-              ? () => setAlertError(MediaDeviceFailure.NotFound)
-              : undefined
-          }
-        />
-      )}
-      {deviceInUse && (
-        <PermissionNeededButton
-          tooltip={explainDeviceInUse ? t(`deviceInUse.${kind}`) : null}
-          ariaLabel={t(`deviceInUse.${kind}`)}
-          onPress={
-            explainDeviceInUse
-              ? () => setAlertError(MediaDeviceFailure.DeviceInUse)
-              : null
+            deviceMissing ? () => setShowDeviceNotFound(true) : undefined
           }
         />
       )}
@@ -240,16 +204,22 @@ export const ToggleDevice = <T extends ToggleSource>({
         shySelected
         onPress={onPress}
         aria-label={toggleLabel}
-        tooltip={toggleTooltip}
+        tooltip={
+          deviceMissing
+            ? t(`deviceNotFound.${kind}`)
+            : cannotUseDevice
+              ? t('tooltip', { keyPrefix: 'permissionsButton' })
+              : toggleLabel
+        }
         {...computedToggleButtonProps}
         {...overrideToggleButtonProps}
       >
         <Icon />
       </ToggleButton>
       <MediaDeviceErrorAlert
-        error={alertError}
+        error={showDeviceNotFound ? MediaDeviceFailure.NotFound : null}
         kind={kind}
-        onClose={() => setAlertError(null)}
+        onClose={() => setShowDeviceNotFound(false)}
       />
     </div>
   )

src/frontend/src/features/rooms/livekit/components/controls/HandToggle.tsx

@@ -10,18 +10,10 @@ import {
   showLowerHandToast,
 } from '@/features/notifications/utils'
 import { useRegisterKeyboardShortcut } from '@/features/shortcuts/useRegisterKeyboardShortcut'
-import { type ButtonRecipeProps } from '@/primitives/buttonRecipe'
-import { ToggleButtonProps } from '@/primitives/ToggleButton'
 
 const SPEAKING_DETECTION_DELAY = 3000
 
-type Props = Pick<NonNullable<ButtonRecipeProps>, 'variant'> & ToggleButtonProps
-
-export const HandToggle = ({
-  variant = 'primaryDark',
-  onPress,
-  ...props
-}: Props) => {
+export const HandToggle = () => {
   const { t } = useTranslation('rooms', { keyPrefix: 'controls.hand' })
 
   const room = useRoomContext()
@@ -82,16 +74,12 @@ export const HandToggle = ({
       })}
     >
       <ToggleButton
-        {...props}
         square
-        variant={variant}
+        variant="primaryDark"
         aria-label={t(tooltipLabel)}
         tooltip={t(tooltipLabel)}
         isSelected={isHandRaised}
-        onPress={(e) => {
-          handleToggle()
-          onPress?.(e)
-        }}
+        onPress={handleToggle}
         data-attr={`controls-hand-${tooltipLabel}`}
       >
         <RiHand />

src/frontend/src/features/rooms/livekit/components/effects/EffectsConfiguration.tsx

@@ -37,8 +37,8 @@ import { reportError } from '@/features/analytics/telemetry'
 
 enum BlurRadius {
   NONE = 0,
-  LIGHT = 10,
-  NORMAL = 20,
+  LIGHT = 5,
+  NORMAL = 10,
 }
 
 const isSupported = BackgroundProcessorFactory.isSupported()

src/frontend/src/features/rooms/livekit/hooks/useCanManageLobby.ts

@@ -1,17 +0,0 @@
-import { useUser } from '@/features/auth/api/useUser'
-import { ApiAccessLevel } from '@/features/rooms/api/ApiRoom'
-import { useIsAdminOrOwner } from './useIsAdminOrOwner'
-import { useRoomData } from './useRoomData'
-
-export const useCanManageLobby = () => {
-  const isAdminOrOwner = useIsAdminOrOwner()
-  const { isLoggedIn } = useUser()
-  const roomData = useRoomData()
-
-  return (
-    (isAdminOrOwner ||
-      (isLoggedIn === true &&
-        roomData?.access_level === ApiAccessLevel.TRUSTED)) &&
-    roomData?.access_level !== ApiAccessLevel.PUBLIC
-  )
-}

src/frontend/src/features/rooms/livekit/hooks/useDeviceInUse.ts

@@ -1,21 +0,0 @@
-import { useSnapshot } from 'valtio'
-import { deviceAvailabilityStore } from '@/stores/deviceAvailability'
-import { useCannotUseDevice } from './useCannotUseDevice'
-import { useDeviceMissing } from './useDeviceMissing'
-
-export const useDeviceInUse = (kind: MediaDeviceKind): boolean => {
-  const { cameraInUse, microphoneInUse } = useSnapshot(deviceAvailabilityStore)
-  const cannotUseDevice = useCannotUseDevice(kind)
-  const deviceMissing = useDeviceMissing(kind)
-
-  if (cannotUseDevice || deviceMissing) return false
-
-  switch (kind) {
-    case 'videoinput':
-      return cameraInUse
-    case 'audioinput':
-      return microphoneInUse
-    default:
-      return false
-  }
-}

src/frontend/src/features/rooms/livekit/hooks/useJoinTracks.ts

@@ -10,15 +10,16 @@ import {
 } from 'livekit-client'
 import { BackgroundProcessorFactory } from '../components/blur'
 import {
+  classifyPermissionError,
+  isLikelySystemNotFound,
   isSystemPermissionError,
+  noteGumSuccess,
+  notePermissionDeniedFromGum,
+  noteSystemPermissionDenied,
   type PermissionKind,
 } from '@/stores/permissions'
-import {
-  getMediaDeviceFailure,
-  noteDeviceReady,
-  onMediaPermissionError,
-} from '../utils/mediaPermissions'
-import { VOICE_AUDIO_CONSTRAINTS } from '../utils/constants'
+import { getOS } from '@/utils/os'
+import { captureMediaEvent, reportError } from '@/features/analytics/telemetry'
 import {
   saveAudioInputDeviceId,
   saveAudioInputEnabled,
@@ -28,6 +29,74 @@ import {
 } from '@/stores/userChoices'
 import { useSyncTrackDeviceId } from './useSyncTrackDeviceId'
 
+const VOICE_AUDIO_CONSTRAINTS = {
+  noiseSuppression: true,
+  echoCancellation: true,
+  autoGainControl: true,
+  voiceIsolation: false,
+  sampleRate: 48000,
+  channelCount: 1,
+  sampleSize: 16,
+} as const
+
+const PERMISSION_KIND: Record<'audioinput' | 'videoinput', PermissionKind> = {
+  audioinput: 'microphone',
+  videoinput: 'camera',
+}
+
+type MediaPath = 'join_preview' | 'room'
+
+const onMediaPermissionError = (
+  e: Error,
+  kind?: PermissionKind,
+  path: MediaPath = 'join_preview'
+) => {
+  if (
+    MediaDeviceFailure.getFailure(e) === MediaDeviceFailure.PermissionDenied
+  ) {
+    void classifyPermissionError(e, kind).then((scope) => {
+      if (scope === 'system') {
+        noteSystemPermissionDenied(kind)
+      } else {
+        notePermissionDeniedFromGum(kind)
+      }
+      captureMediaEvent('permissions-denied', {
+        path,
+        kind,
+        denied_scope: scope,
+        os: getOS(),
+      })
+    })
+    return
+  }
+
+  if (MediaDeviceFailure.getFailure(e) === MediaDeviceFailure.NotFound) {
+    // Firefox reports OS-level blocks as NotFoundError (macOS privacy
+    // settings, missing Android app permissions).
+    void isLikelySystemNotFound(e, kind).then((system) => {
+      if (system) {
+        noteSystemPermissionDenied(kind)
+        captureMediaEvent('permissions-denied', {
+          path,
+          kind,
+          denied_scope: 'system',
+          os: getOS(),
+        })
+        return
+      }
+      captureMediaEvent('device-not-found', { path, kind })
+    })
+    return
+  }
+
+  // "Other" and "Device in use" are still reported as errors, as they are not handled on the join screen.
+  reportError(
+    path === 'room' ? 'room_media_failure' : 'join_preview_failure',
+    e,
+    { path, kind }
+  )
+}
+
 // Module-level: effect dependencies, must be referentially stable.
 const disableAudio = () => saveAudioInputEnabled(false)
 const disableVideo = () => saveVideoInputEnabled(false)
@@ -35,6 +104,24 @@ const disableVideo = () => saveVideoInputEnabled(false)
 const stopAll = (stream: MediaStream) =>
   stream.getTracks().forEach((track) => track.stop())
 
+export const requestDevicePermission = async (
+  kind: 'audioinput' | 'videoinput',
+  path: MediaPath = 'join_preview'
+): Promise<boolean> => {
+  try {
+    const track =
+      kind === 'audioinput'
+        ? await createLocalAudioTrack()
+        : await createLocalVideoTrack()
+    track.stop()
+    noteGumSuccess(PERMISSION_KIND[kind])
+    return true
+  } catch (error) {
+    onMediaPermissionError(error as Error, PERMISSION_KIND[kind], path)
+    return false
+  }
+}
+
 type WarmupState = {
   audioReady: boolean
   videoReady: boolean
@@ -71,11 +158,11 @@ function useWarmupPermissions(): WarmupState {
             video: true,
           })
         )
-        noteDeviceReady()
+        noteGumSuccess()
         bothReady()
       } catch (error) {
         if (
-          getMediaDeviceFailure(error as Error) ===
+          MediaDeviceFailure.getFailure(error as Error) ===
             MediaDeviceFailure.PermissionDenied &&
           !isSystemPermissionError(error)
         ) {
@@ -93,7 +180,7 @@ function useWarmupPermissions(): WarmupState {
           .getUserMedia({ audio: true })
           .then((stream) => {
             stopAll(stream)
-            noteDeviceReady('microphone')
+            noteGumSuccess('microphone')
           })
           .catch((e) => onMediaPermissionError(e as Error, 'microphone'))
           .finally(() =>
@@ -103,7 +190,7 @@ function useWarmupPermissions(): WarmupState {
           .getUserMedia({ video: true })
           .then((stream) => {
             stopAll(stream)
-            noteDeviceReady('camera')
+            noteGumSuccess('camera')
           })
           .catch((e) => onMediaPermissionError(e as Error, 'camera'))
           .finally(() =>
@@ -122,14 +209,12 @@ function useLocalTrack<T extends LocalAudioTrack | LocalVideoTrack>({
   enabled,
   create,
   permissionKind,
-  deviceId,
   onFailure,
 }: {
   ready: boolean
   enabled: boolean
   create: () => Promise<T>
   permissionKind: PermissionKind
-  deviceId?: string
   onFailure: () => void
 }): T | null {
   const [track, setTrack] = useState<T | null>(null)
@@ -142,27 +227,21 @@ function useLocalTrack<T extends LocalAudioTrack | LocalVideoTrack>({
     let cancelled = false
     create()
       .then((newTrack) => {
+        noteGumSuccess(permissionKind)
         if (cancelled) {
           newTrack.stop()
           return
         }
-        noteDeviceReady(permissionKind)
         setTrack(newTrack)
       })
       .catch((error) => {
-        if (cancelled) return
-        onMediaPermissionError(
-          error as Error,
-          permissionKind,
-          'join_preview',
-          deviceId
-        )
+        onMediaPermissionError(error as Error, permissionKind)
         onFailure()
       })
     return () => {
       cancelled = true
     }
-  }, [ready, enabled, track, create, permissionKind, deviceId, onFailure])
+  }, [ready, enabled, track, create, permissionKind, onFailure])
 
   // Release on toggle-off so the LED turns off.
   useEffect(() => {
@@ -236,7 +315,6 @@ export function useJoinTracks(): {
     enabled: audioEnabled,
     create: createAudio,
     permissionKind: 'microphone',
-    deviceId: audioDeviceId,
     onFailure: disableAudio,
   })
 
@@ -245,7 +323,6 @@ export function useJoinTracks(): {
     enabled: videoEnabled,
     create: createVideo,
     permissionKind: 'camera',
-    deviceId: videoDeviceId,
     onFailure: disableVideo,
   })
 

src/frontend/src/features/rooms/livekit/hooks/useWatchMediaDeviceErrors.ts

@@ -1,11 +1,6 @@
 import { useCallback, useEffect, useState } from 'react'
 import { useRoomContext } from '@livekit/components-react'
-import {
-  type LocalTrackPublication,
-  MediaDeviceFailure,
-  RoomEvent,
-  Track,
-} from 'livekit-client'
+import { MediaDeviceFailure, RoomEvent } from 'livekit-client'
 import {
   PERMISSION_BY_DEVICE_KIND,
   type PermissionDeniedScope,
@@ -15,13 +10,8 @@ import {
   notePermissionDeniedFromGum,
   noteSystemPermissionDenied,
 } from '@/stores/permissions'
-import {
-  clearDeviceInUse,
-  noteDeviceInUse,
-  syncDeviceAvailability,
-} from '@/stores/deviceAvailability'
+import { syncDeviceAvailability } from '@/stores/deviceAvailability'
 import { captureMediaEvent } from '@/features/analytics/telemetry'
-import { getMediaDeviceFailure } from '../utils/mediaPermissions'
 import { getOS } from '@/utils/os'
 
 type MediaDeviceAlert = {
@@ -31,11 +21,6 @@ type MediaDeviceAlert = {
 
 const NO_ALERT: MediaDeviceAlert = { error: null, kind: null }
 
-const PERMISSION_BY_SOURCE: Partial<Record<Track.Source, PermissionKind>> = {
-  [Track.Source.Camera]: 'camera',
-  [Track.Source.Microphone]: 'microphone',
-}
-
 const capturePermissionsDenied = (
   scope: PermissionDeniedScope,
   kind?: PermissionKind
@@ -64,7 +49,7 @@ export const useWatchMediaDeviceErrors = (): MediaDeviceAlert & {
 
   useEffect(() => {
     const onDeviceError = (error: Error, kind?: MediaDeviceKind) => {
-      const failure = getMediaDeviceFailure(error)
+      const failure = MediaDeviceFailure.getFailure(error)
       if (!failure) return
       if (failure != MediaDeviceFailure.Other) {
         void captureMediaEvent('media-device-error', {
@@ -78,7 +63,6 @@ export const useWatchMediaDeviceErrors = (): MediaDeviceAlert & {
       const permissionKind = PERMISSION_BY_DEVICE_KIND[kind]
       switch (failure) {
         case MediaDeviceFailure.DeviceInUse:
-          if (permissionKind) noteDeviceInUse(permissionKind)
           setAlert({ error: failure, kind })
           break
         case MediaDeviceFailure.NotFound:
@@ -108,16 +92,9 @@ export const useWatchMediaDeviceErrors = (): MediaDeviceAlert & {
           break
       }
     }
-    const onTrackPublished = (publication: LocalTrackPublication) => {
-      const permissionKind = PERMISSION_BY_SOURCE[publication.source]
-      if (permissionKind) clearDeviceInUse(permissionKind)
-    }
     room.on(RoomEvent.MediaDevicesError, onDeviceError)
-    room.on(RoomEvent.LocalTrackPublished, onTrackPublished)
     return () => {
       room.off(RoomEvent.MediaDevicesError, onDeviceError)
-      room.off(RoomEvent.LocalTrackPublished, onTrackPublished)
-      clearDeviceInUse()
     }
   }, [room])
 

src/frontend/src/features/rooms/livekit/prefabs/ControlBar/DesktopControlBar.tsx

@@ -9,7 +9,7 @@ import { SubtitlesToggle } from '../../components/controls/SubtitlesToggle'
 import { OptionsButton } from '../../components/controls/Options/OptionsButton'
 import { StartMediaButton } from '../../components/controls/StartMediaButton'
 import { MoreOptions } from './MoreOptions'
-import { RefObject, useMemo, useState } from 'react'
+import { useRef } from 'react'
 import { useRegisterKeyboardShortcut } from '@/features/shortcuts/useRegisterKeyboardShortcut'
 import { useFullScreen } from '../../hooks/useFullScreen'
 import { VideoDeviceControl } from '../../components/controls/Device/VideoDeviceControl'
@@ -21,14 +21,7 @@ export function DesktopControlBar({
   onDeviceError,
 }: Readonly<ControlBarAuxProps>) {
   const browserSupportsScreenSharing = supportsScreenSharing()
-
-  const [controlBarElement, setControlBarElement] =
-    useState<HTMLDivElement | null>(null)
-
-  const desktopControlBarEl = useMemo<RefObject<HTMLDivElement>>(
-    () => ({ current: controlBarElement }),
-    [controlBarElement]
-  )
+  const desktopControlBarEl = useRef<HTMLDivElement>(null)
 
   const { toggleFullScreen, isFullscreenAvailable } = useFullScreen({})
 
@@ -52,7 +45,7 @@ export function DesktopControlBar({
 
   return (
     <div
-      ref={setControlBarElement}
+      ref={desktopControlBarEl}
       className={css({
         width: '100vw',
         display: 'flex',

src/frontend/src/features/rooms/livekit/prefabs/ControlBar/MobileControlBar.tsx

@@ -1,7 +1,7 @@
 import { supportsScreenSharing } from '@livekit/components-core'
 import { useTranslation } from 'react-i18next'
 import type { ControlBarAuxProps } from './ControlBar'
-import React, { useLayoutEffect, useRef, useState } from 'react'
+import React from 'react'
 import { css } from '@/styled-system/css'
 import { LeaveButton } from '../../components/controls/LeaveButton'
 import { Track } from 'livekit-client'
@@ -26,26 +26,7 @@ import { AudioDevicesControl } from '../../components/controls/Device/AudioDevic
 import { VideoDeviceControl } from '../../components/controls/Device/VideoDeviceControl'
 import { openSettingsDialog } from '@/stores/settings'
 import { ControlBarRegion } from '@/features/layout/components/ControlBarRegion'
-import {
-  ReactionsToggle,
-  reactionShortcutHandler,
-} from '@/features/reactions/components/ReactionsToggle'
-import { useSize } from '../../hooks/useResizeObserver'
-import { useRegisterKeyboardShortcut } from '@/features/shortcuts/useRegisterKeyboardShortcut'
-import { useRaisedHand } from '@/features/rooms/livekit/hooks/useRaisedHand'
-import { useRoomContext } from '@livekit/components-react'
-
-// Hand collapses first, then reactions; hidden toggles move into the menu.
-const COLLAPSIBLE_COUNT = 2
-
-// Layout-neutral measuring wrapper: inherits the region's gap and refuses to
-// flex-shrink so measured widths are natural content widths.
-const measuredRow = css({
-  display: 'inline-flex',
-  alignItems: 'center',
-  gap: 'inherit',
-  flexShrink: 0,
-})
+import { ReactionsToggle } from '@/features/reactions/components/ReactionsToggle'
 
 export function MobileControlBar({
   onDeviceError,
@@ -55,107 +36,50 @@ export function MobileControlBar({
   const browserSupportsScreenSharing = supportsScreenSharing()
   const { toggleEffects } = useSidePanel()
 
-  const containerRef = useRef<HTMLDivElement>(null)
-  const { width } = useSize(containerRef)
-  const barRef = useRef<HTMLDivElement>(null)
-  const { width: barWidth } = useSize(barRef)
-  const collapsibleRef = useRef<HTMLDivElement>(null)
-  const { width: collapsibleWidth } = useSize(collapsibleRef)
-
-  const [hiddenCount, setHiddenCount] = useState(0)
-  const calibration = useRef<{ essential: number; slot: number }>()
-
-  useLayoutEffect(() => {
-    if (hiddenCount === 0 && collapsibleWidth > 0 && barRef.current) {
-      const gap = parseFloat(getComputedStyle(barRef.current).columnGap) || 0
-      calibration.current = {
-        essential: barWidth - collapsibleWidth - gap,
-        slot: (collapsibleWidth + gap) / COLLAPSIBLE_COUNT,
-      }
-    }
-    if (!calibration.current || width <= 0) return
-    const { essential, slot } = calibration.current
-    const fits = Math.floor((width - essential) / slot)
-    const next = Math.min(
-      COLLAPSIBLE_COUNT,
-      Math.max(0, COLLAPSIBLE_COUNT - fits)
-    )
-    if (next !== hiddenCount) setHiddenCount(next)
-  }, [barWidth, collapsibleWidth, hiddenCount, width, setHiddenCount])
-
-  const hideHand = hiddenCount >= 1
-  const hideReactions = hiddenCount >= 2
-
-  const room = useRoomContext()
-  const { toggleRaisedHand } = useRaisedHand({
-    participant: room.localParticipant,
-  })
-  useRegisterKeyboardShortcut({
-    id: 'raise-hand',
-    handler: toggleRaisedHand,
-  })
-  useRegisterKeyboardShortcut({
-    id: 'reaction',
-    handler: reactionShortcutHandler,
-  })
-
   const { data } = useConfig()
 
-  const closeMenu = () => setIsMenuOpened(false)
-
   return (
     <>
       <div
         className={css({
           width: '100vw',
+          display: 'flex',
           padding: '1.125rem',
+          justifyContent: 'center',
         })}
       >
-        <div
-          ref={containerRef}
-          className={css({
-            width: '100%',
-            display: 'flex',
-            justifyContent: 'center',
-          })}
-        >
-          <ControlBarRegion mobile>
-            <div ref={barRef} className={measuredRow}>
-              <LeaveButton />
-              <AudioDevicesControl
-                onDeviceError={(error) =>
-                  onDeviceError?.({ source: Track.Source.Microphone, error })
-                }
-                hideMenu={true}
-              />
-              <VideoDeviceControl
-                onDeviceError={(error) =>
-                  onDeviceError?.({ source: Track.Source.Camera, error })
-                }
-                hideMenu={true}
-              />
-              {/* Unmounted when empty so it doesn't leave a stray gap. */}
-              {!hideReactions && (
-                <div ref={collapsibleRef} className={measuredRow}>
-                  <ReactionsToggle />
-                  {!hideHand && <HandToggle />}
-                </div>
-              )}
-              <Button
-                id="room-options-trigger"
-                square
-                variant="primaryDark"
-                aria-label={t('options.buttonLabel')}
-                tooltip={t('options.buttonLabel')}
-                onPress={() => setIsMenuOpened(true)}
-              >
-                <RiMore2Line />
-              </Button>
-            </div>
-          </ControlBarRegion>
-        </div>
+        <ControlBarRegion mobile>
+          <LeaveButton />
+          <AudioDevicesControl
+            onDeviceError={(error) =>
+              onDeviceError?.({ source: Track.Source.Microphone, error })
+            }
+            hideMenu={true}
+          />
+          <VideoDeviceControl
+            onDeviceError={(error) =>
+              onDeviceError?.({ source: Track.Source.Camera, error })
+            }
+            hideMenu={true}
+          />
+          <ReactionsToggle />
+          <HandToggle />
+          <Button
+            id="room-options-trigger"
+            square
+            variant="primaryDark"
+            aria-label={t('options.buttonLabel')}
+            tooltip={t('options.buttonLabel')}
+            onPress={() => setIsMenuOpened(true)}
+          >
+            <RiMore2Line />
+          </Button>
+        </ControlBarRegion>
       </div>
-      <ResponsiveMenu isOpened={isMenuOpened} onClosed={closeMenu}>
+      <ResponsiveMenu
+        isOpened={isMenuOpened}
+        onClosed={() => setIsMenuOpened(false)}
+      >
         <div
           className={css({
             display: 'flex',
@@ -174,20 +98,6 @@ export function MobileControlBar({
               },
             })}
           >
-            {hideReactions && (
-              <ReactionsToggle
-                variant="primaryTextDark"
-                description={true}
-                onPress={closeMenu}
-              />
-            )}
-            {hideHand && (
-              <HandToggle
-                variant="primaryTextDark"
-                description={true}
-                onPress={closeMenu}
-              />
-            )}
             {browserSupportsScreenSharing && (
               <ScreenShareToggle
                 onDeviceError={(error) =>
@@ -195,16 +105,25 @@ export function MobileControlBar({
                 }
                 variant="primaryTextDark"
                 description={true}
-                onPress={closeMenu}
+                onPress={() => setIsMenuOpened(false)}
               />
             )}
-            <ChatToggle description={true} onPress={closeMenu} />
-            <ParticipantsToggle description={true} onPress={closeMenu} />
-            <ToolsToggle description={true} onPress={closeMenu} />
+            <ChatToggle
+              description={true}
+              onPress={() => setIsMenuOpened(false)}
+            />
+            <ParticipantsToggle
+              description={true}
+              onPress={() => setIsMenuOpened(false)}
+            />
+            <ToolsToggle
+              description={true}
+              onPress={() => setIsMenuOpened(false)}
+            />
             <Button
               onPress={() => {
                 toggleEffects()
-                closeMenu()
+                setIsMenuOpened(false)
               }}
               variant="primaryTextDark"
               aria-label={t('options.items.effects')}
@@ -221,7 +140,7 @@ export function MobileControlBar({
                 aria-label={t('options.items.feedback')}
                 description={true}
                 target="_blank"
-                onPress={closeMenu}
+                onPress={() => setIsMenuOpened(false)}
               >
                 <RiMegaphoneLine size={20} />
               </LinkButton>
@@ -229,7 +148,7 @@ export function MobileControlBar({
             <Button
               onPress={() => {
                 openSettingsDialog()
-                closeMenu()
+                setIsMenuOpened(false)
               }}
               variant="primaryTextDark"
               aria-label={t('options.items.settings')}
@@ -238,7 +157,7 @@ export function MobileControlBar({
             >
               <RiSettings3Line size={20} />
             </Button>
-            <CameraSwitchButton onPress={closeMenu} />
+            <CameraSwitchButton onPress={() => setIsMenuOpened(false)} />
           </div>
         </div>
       </ResponsiveMenu>

src/frontend/src/features/rooms/livekit/prefabs/VideoConference.tsx

@@ -1,6 +1,5 @@
 import { isWeb } from '@livekit/components-core'
-import { MediaDeviceFailure, Track } from 'livekit-client'
-import { getMediaDeviceFailure } from '../utils/mediaPermissions'
+import { Track } from 'livekit-client'
 import React, { useState } from 'react'
 import {
   ConnectionStateToast,
@@ -20,7 +19,6 @@ import { RoomMetadataSynchronizer } from '../components/RoomMetadataSynchronizer
 import { useNoiseReduction } from '../hooks/useNoiseReduction'
 import { VideoResolutionSubscription } from '../components/VideoResolutionSubscription'
 import { SettingsDialogProvider } from '@/features/settings/components/SettingsDialogProvider'
-import { MuteAlertDialogProvider } from '@/features/rooms/livekit/components/MuteAlertDialogProvider'
 import { IsIdleDisconnectModal } from '../components/IsIdleDisconnectModal'
 import { ReactionPortals } from '@/features/reactions/components/ReactionPortals'
 import { RoomContentArea } from '@/features/layout/components/RoomContentArea'
@@ -31,7 +29,6 @@ import { PinAnnouncer } from '@/features/layout/components/PinAnnouncer'
 import { ChatProvider } from '@/features/chat/components/ChatProvider'
 import { SyncDevicePreferences } from '@/features/rooms/livekit/components/SyncDevicePreferences'
 import { RoomSilentMicDetector } from '@/features/rooms/components/SilentMicDetector'
-import { LobbyProvider } from '@/features/rooms/components/LobbyProvider'
 
 /**
  * @public
@@ -102,11 +99,6 @@ export function VideoConference({ ...props }: VideoConferenceProps) {
         return
       }
     }
-
-    if (getMediaDeviceFailure(error) !== MediaDeviceFailure.Other) {
-      return
-    }
-
     reportError('device_switch_failure', error, {
       at: 'ControlBar.onDeviceError',
       source,
@@ -121,7 +113,6 @@ export function VideoConference({ ...props }: VideoConferenceProps) {
       <RoomSilentMicDetector />
       <MediaStateObserver />
       <ChatProvider />
-      <LobbyProvider />
       <VideoResolutionSubscription />
       <div
         className="lk-video-conference"
@@ -153,7 +144,6 @@ export function VideoConference({ ...props }: VideoConferenceProps) {
         <ConnectionStateToast />
         <RecordingProvider />
         <SettingsDialogProvider />
-        <MuteAlertDialogProvider />
         <ReactionPortals />
       </div>
     </>

src/frontend/src/features/rooms/livekit/utils/constants.ts

@@ -1,9 +0,0 @@
-export const VOICE_AUDIO_CONSTRAINTS = {
-  noiseSuppression: true,
-  echoCancellation: true,
-  autoGainControl: true,
-  voiceIsolation: false,
-  sampleRate: 48000,
-  channelCount: 1,
-  sampleSize: 16,
-} as const

src/frontend/src/features/rooms/livekit/utils/mediaPermissions.ts

@@ -1,168 +0,0 @@
-import {
-  createLocalAudioTrack,
-  createLocalVideoTrack,
-  MediaDeviceFailure,
-} from 'livekit-client'
-import {
-  classifyPermissionError,
-  isLikelySystemNotFound,
-  noteGumSuccess,
-  notePermissionDeniedFromGum,
-  noteSystemPermissionDenied,
-  type PermissionKind,
-} from '@/stores/permissions'
-import { clearDeviceInUse, noteDeviceInUse } from '@/stores/deviceAvailability'
-import { captureMediaEvent, reportError } from '@/features/analytics/telemetry'
-import { getOS } from '@/utils/os'
-
-/**
- * Shared handling of getUserMedia() outcomes, used by both:
- * - the join preview (`useJoinTracks`: warmup + local track acquisition)
- * - the in-room device toggle (`ToggleDevice`, when permission is missing)
- */
-export type MediaPath = 'join_preview' | 'room'
-
-const DEVICE_START_FAILURE =
-  /^(Starting (video|audio)input failed|Timeout starting (video|audio) source)/i
-
-/**
- * LiveKit only maps NotReadableError/TrackStartError to DeviceInUse.
- * Firefox reports a device held by another app as
- * `AbortError: Starting videoinput failed` (or audioinput), which LiveKit
- * classifies as Other. Normalise it here; every classification in the app
- * should go through this instead of MediaDeviceFailure.getFailure.
- */
-export const getMediaDeviceFailure = (
-  error: Error
-): MediaDeviceFailure | undefined => {
-  const failure = MediaDeviceFailure.getFailure(error)
-  if (
-    failure === MediaDeviceFailure.Other &&
-    error.name === 'AbortError' &&
-    DEVICE_START_FAILURE.test(error.message)
-  ) {
-    return MediaDeviceFailure.DeviceInUse
-  }
-  return failure
-}
-
-export const PERMISSION_KIND: Record<
-  'audioinput' | 'videoinput',
-  PermissionKind
-> = {
-  audioinput: 'microphone',
-  videoinput: 'camera',
-}
-
-export const noteDeviceReady = (kind?: PermissionKind) => {
-  noteGumSuccess(kind)
-  clearDeviceInUse(kind)
-}
-
-export const onMediaPermissionError = (
-  e: Error,
-  kind?: PermissionKind,
-  path: MediaPath = 'join_preview',
-  deviceId?: string
-) => {
-  const failure = getMediaDeviceFailure(e)
-
-  if (failure === MediaDeviceFailure.PermissionDenied) {
-    void classifyPermissionError(e, kind).then((scope) => {
-      if (scope === 'system') {
-        noteSystemPermissionDenied(kind)
-      } else {
-        notePermissionDeniedFromGum(kind)
-      }
-      captureMediaEvent('permissions-denied', {
-        path,
-        kind,
-        denied_scope: scope,
-        os: getOS(),
-      })
-    })
-    return
-  }
-
-  if (failure === MediaDeviceFailure.NotFound) {
-    // Firefox reports OS-level blocks as NotFoundError (macOS privacy
-    // settings, missing Android app permissions).
-    void isLikelySystemNotFound(e, kind).then((system) => {
-      if (system) {
-        noteSystemPermissionDenied(kind)
-        captureMediaEvent('permissions-denied', {
-          path,
-          kind,
-          denied_scope: 'system',
-          os: getOS(),
-        })
-        return
-      }
-      captureMediaEvent('device-not-found', { path, kind })
-    })
-    return
-  }
-
-  if (failure === MediaDeviceFailure.DeviceInUse) {
-    noteDeviceInUse(kind, deviceId)
-    void captureMediaEvent('device-in-use', { path, kind, os: getOS() })
-    return
-  }
-
-  // "Other" is still reported as an error.
-  reportError(
-    path === 'room' ? 'room_media_failure' : 'join_preview_failure',
-    e,
-    { path, kind }
-  )
-}
-
-/**
- * Silent availability check for a device that was reported "in use":
- * acquires and releases it without any error reporting, so it can be
- * polled. Clears the in-use flag on success.
- */
-export const probeDeviceReleased = async (
-  kind: PermissionKind,
-  deviceId?: string
-): Promise<boolean> => {
-  try {
-    const constraint = deviceId ? { deviceId: { exact: deviceId } } : true
-    const stream = await navigator.mediaDevices.getUserMedia(
-      kind === 'camera' ? { video: constraint } : { audio: constraint }
-    )
-    stream.getTracks().forEach((track) => track.stop())
-    noteDeviceReady(kind)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Triggers the browser permission prompt for one device kind by acquiring
- * and immediately releasing a track. Resolves to whether access was granted.
- */
-export const requestDevicePermission = async (
-  kind: 'audioinput' | 'videoinput',
-  path: MediaPath = 'join_preview',
-  deviceId?: string
-): Promise<boolean> => {
-  try {
-    const track =
-      kind === 'audioinput'
-        ? await createLocalAudioTrack({ deviceId })
-        : await createLocalVideoTrack({ deviceId })
-    track.stop()
-    noteDeviceReady(PERMISSION_KIND[kind])
-    return true
-  } catch (error) {
-    onMediaPermissionError(
-      error as Error,
-      PERMISSION_KIND[kind],
-      path,
-      deviceId
-    )
-    return false
-  }
-}

src/frontend/src/features/rooms/routes/Feedback.tsx

@@ -1,8 +1,7 @@
 import { useTranslation } from 'react-i18next'
 import { Button } from '@/primitives'
 import { Screen } from '@/layout/Screen'
-import { Center, Stack, styled, VStack } from '@/styled-system/jsx'
-import { css } from '@/styled-system/css'
+import { Center, HStack, styled, VStack } from '@/styled-system/jsx'
 import { Rating } from '@/features/rooms/components/Rating.tsx'
 import { useLocation } from 'wouter'
 import { useMemo } from 'react'
@@ -15,18 +14,14 @@ const Heading = styled('h1', {
     fontStyle: 'normal',
     fontStretch: 'normal',
     fontOpticalSizing: 'auto',
-    fontSize: { base: '1.75rem', xsm: '2.3rem' },
-    lineHeight: { base: '2.125rem', xsm: '2.5rem' },
+    fontSize: '2.3rem',
+    lineHeight: '2.5rem',
     letterSpacing: '0',
-    paddingBottom: { base: '1.5rem', xsm: '2rem' },
+    paddingBottom: '2rem',
     textAlign: 'center',
   },
 })
 
-const buttonClass = css({
-  width: { base: '100%', xsm: 'auto' },
-})
-
 enum DisconnectReasonKey {
   DuplicateIdentity = 'duplicateIdentity',
   ParticipantRemoved = 'participantRemoved',
@@ -59,31 +54,19 @@ const FeedbackRoute = () => {
 
   return (
     <Screen layout="centered" footer={false}>
-      <Center width="100%">
-        <VStack width="100%" paddingX="1rem">
+      <Center>
+        <VStack>
           <Heading>{t(`feedback.heading.${reasonKey || 'normal'}`)}</Heading>
-          <Stack
-            direction={{ base: 'column', xsm: 'row' }}
-            width={{ base: '100%', xsm: 'auto' }}
-            maxWidth="380px"
-          >
+          <HStack>
             {showBackButton && (
-              <Button
-                variant="secondary"
-                className={buttonClass}
-                onPress={() => window.history.back()}
-              >
+              <Button variant="secondary" onPress={() => window.history.back()}>
                 {t('feedback.back')}
               </Button>
             )}
-            <Button
-              variant="primary"
-              className={buttonClass}
-              onPress={() => setLocation('/')}
-            >
+            <Button variant="primary" onPress={() => setLocation('/')}>
               {t('feedback.home')}
             </Button>
-          </Stack>
+          </HStack>
           <Rating metadata={metadata} />
         </VStack>
       </Center>

src/frontend/src/features/rooms/routes/Room.tsx

@@ -16,7 +16,6 @@ import {
 import { useConfig } from '@/api/useConfig.ts'
 import { LogLevel, setLogLevel } from 'livekit-client'
 import { useWatchDeviceAvailability } from '@/features/rooms/hooks/useWatchDeviceAvailability'
-import { useWatchDeviceReleased } from '@/features/rooms/hooks/useWatchDeviceReleased'
 import { useRoomPageTitle } from '@/features/rooms/livekit/hooks/useRoomPageTitle'
 
 const BaseRoom = ({ children }: { children: ReactNode }) => {
@@ -50,7 +49,6 @@ const Room = () => {
 
   useKeyboardShortcuts()
   useWatchDeviceAvailability()
-  useWatchDeviceReleased()
 
   const clearRouterState = () => {
     if (window?.history?.state) {

src/frontend/src/features/subtitle/component/Subtitles.tsx

@@ -75,15 +75,15 @@ const useTranscriptionState = () => {
     const segment = segments[0]
 
     setTranscriptionSegments((prevSegments) => {
-      const existingIndex = prevSegments.findIndex(
-        (s: TranscriptionSegmentWithParticipant) => s.id === segment.id
-      )
-      if (existingIndex === -1) {
-        return [...prevSegments, { participant, ...segment }]
-      }
-      const next = prevSegments.slice()
-      next[existingIndex] = { ...next[existingIndex], ...segment }
-      return next
+      const existingSegmentIds = new Set(prevSegments.map((s) => s.id))
+      if (existingSegmentIds.has(segment.id)) return prevSegments
+      return [
+        ...prevSegments,
+        {
+          participant: participant,
+          ...segment,
+        },
+      ]
     })
   }
 

src/frontend/src/locales/de/rooms.json

@@ -16,10 +16,6 @@
       "videoinput": "Keine Kamera erkannt. Prüfe, ob sie richtig angeschlossen ist.",
       "audioinput": "Kein Mikrofon erkannt. Prüfe, ob es richtig angeschlossen ist."
     },
-    "deviceInUse": {
-      "videoinput": "Kamera nicht verfügbar: Sie wird wahrscheinlich von einer anderen App oder einem anderen Tab verwendet.",
-      "audioinput": "Mikrofon nicht verfügbar: Es wird wahrscheinlich von einer anderen App oder einem anderen Tab verwendet."
-    },
     "settings": {
       "audio": "Audioeinstellungen",
       "video": "Videoeinstellungen"
@@ -71,7 +67,6 @@
     },
     "cameraDisabled": "Kamera ist deaktiviert.",
     "cameraNotFound": "Keine Kamera erkannt. Prüfe, ob sie richtig angeschlossen ist.",
-    "cameraInUse": "Deine Kamera ist nicht verfügbar. Sie wird wahrscheinlich von einer anderen App oder einem anderen Tab verwendet.",
     "cameraStarting": "Kamera wird gestartet…",
     "cameraNotGranted": "Möchtest du, dass andere dich während des Meetings sehen können?",
     "cameraAndMicNotGranted": "Möchtest du, dass andere dich während des Meetings sehen und hören können?",

src/frontend/src/locales/en/rooms.json

@@ -16,10 +16,6 @@
       "videoinput": "No camera detected. Check that it is properly wired.",
       "audioinput": "No microphone detected. Check that it is properly wired."
     },
-    "deviceInUse": {
-      "videoinput": "Camera unavailable: it is probably in use by another application or browser tab.",
-      "audioinput": "Microphone unavailable: it is probably in use by another application or browser tab."
-    },
     "settings": {
       "audio": "Audio settings",
       "video": "Video settings"
@@ -71,7 +67,6 @@
     },
     "cameraDisabled": "Camera is disabled.",
     "cameraNotFound": "No camera detected. Check that it is properly plugged in.",
-    "cameraInUse": "Your camera is unavailable. It is probably being used by another application or browser tab.",
     "cameraStarting": "Camera is starting…",
     "cameraNotGranted": "Would you like others to be able to see you during the meeting?",
     "cameraAndMicNotGranted": "Would you like others to be able to see and hear you during the meeting?",

src/frontend/src/locales/fr/rooms.json

@@ -16,10 +16,6 @@
       "videoinput": "Aucune caméra détectée. Vérifiez qu'elle est bien branchée.",
       "audioinput": "Aucun microphone détecté. Vérifiez qu'il est bien branché."
     },
-    "deviceInUse": {
-      "videoinput": "Caméra indisponible : elle est probablement utilisée par une autre application ou un autre onglet.",
-      "audioinput": "Microphone indisponible : il est probablement utilisé par une autre application ou un autre onglet."
-    },
     "settings": {
       "audio": "Paramètres audio",
       "video": "Paramètres video"
@@ -71,7 +67,6 @@
     },
     "cameraDisabled": "La caméra est désactivée.",
     "cameraNotFound": "Aucune caméra détectée. Vérifiez qu'elle est bien branchée.",
-    "cameraInUse": "Votre caméra n'est pas disponible. Elle est probablement utilisée par une autre application ou un autre onglet.",
     "cameraStarting": "La caméra va démarrer…",
     "cameraNotGranted": "Souhaitez-vous que les autres puissent vous voir pendant la réunion ?",
     "cameraAndMicNotGranted": "Souhaitez-vous que les autres puissent vous voir et vous entendre pendant la réunion ?",

src/frontend/src/locales/nl/rooms.json

@@ -16,10 +16,6 @@
       "videoinput": "Geen camera gedetecteerd. Controleer of deze goed is aangesloten.",
       "audioinput": "Geen microfoon gedetecteerd. Controleer of deze goed is aangesloten."
     },
-    "deviceInUse": {
-      "videoinput": "Camera niet beschikbaar: deze wordt waarschijnlijk gebruikt door een andere toepassing of een ander tabblad.",
-      "audioinput": "Microfoon niet beschikbaar: deze wordt waarschijnlijk gebruikt door een andere toepassing of een ander tabblad."
-    },
     "settings": {
       "audio": "Audio-instellingen",
       "video": "Video-instellingen"
@@ -71,7 +67,6 @@
     },
     "cameraDisabled": "Camera is uitgeschakeld.",
     "cameraNotFound": "Geen camera gedetecteerd. Controleer of deze goed is aangesloten.",
-    "cameraInUse": "Je camera is niet beschikbaar. Deze wordt waarschijnlijk gebruikt door een andere toepassing of een ander tabblad.",
     "cameraStarting": "Camera wordt ingeschakeld…",
     "cameraNotGranted": "Wilt u dat anderen u tijdens de vergadering kunnen zien?",
     "cameraAndMicNotGranted": "Wilt u dat anderen u tijdens de vergadering kunnen zien en horen?",

src/frontend/src/stores/deviceAvailability.ts

@@ -1,68 +1,14 @@
 import { proxy } from 'valtio'
 import { captureMediaEvent, reportError } from '@/features/analytics/telemetry'
-import type { PermissionKind } from './permissions'
 
-// Device availability (not permission):
-// - presence: enumerateDevices() exposes kinds before any grant.
-//   Optimistic defaults until the first sync.
-// - in use: the device exists and is allowed, but getUserMedia() failed
-//   because another application or tab is holding it. The id of the
-//   affected device is kept (when known) so that a selection change can
-//   invalidate a flag that no longer concerns the selected device.
-export const deviceAvailabilityStore = proxy<{
-  hasCamera: boolean
-  hasMicrophone: boolean
-  cameraInUse: boolean
-  microphoneInUse: boolean
-  cameraInUseDeviceId?: string
-  microphoneInUseDeviceId?: string
-  synced: boolean
-}>({
+// Device presence (not permission): enumerateDevices() exposes kinds
+// before any grant. Optimistic defaults until the first sync.
+export const deviceAvailabilityStore = proxy({
   hasCamera: true,
   hasMicrophone: true,
-  cameraInUse: false,
-  microphoneInUse: false,
   synced: false,
 })
 
-const IN_USE_KEY: Record<PermissionKind, 'cameraInUse' | 'microphoneInUse'> = {
-  camera: 'cameraInUse',
-  microphone: 'microphoneInUse',
-}
-
-const IN_USE_DEVICE_KEY: Record<
-  PermissionKind,
-  'cameraInUseDeviceId' | 'microphoneInUseDeviceId'
-> = {
-  camera: 'cameraInUseDeviceId',
-  microphone: 'microphoneInUseDeviceId',
-}
-
-const ALL_KINDS: PermissionKind[] = ['camera', 'microphone']
-
-export const noteDeviceInUse = (kind?: PermissionKind, deviceId?: string) => {
-  for (const k of kind ? [kind] : ALL_KINDS) {
-    deviceAvailabilityStore[IN_USE_KEY[k]] = true
-    deviceAvailabilityStore[IN_USE_DEVICE_KEY[k]] = deviceId
-  }
-}
-
-export const clearDeviceInUse = (kind?: PermissionKind) => {
-  for (const k of kind ? [kind] : ALL_KINDS) {
-    deviceAvailabilityStore[IN_USE_KEY[k]] = false
-    deviceAvailabilityStore[IN_USE_DEVICE_KEY[k]] = undefined
-  }
-}
-
-export const clearDeviceInUseForOtherDevice = (
-  kind: PermissionKind,
-  selectedDeviceId?: string
-) => {
-  const affected = deviceAvailabilityStore[IN_USE_DEVICE_KEY[kind]]
-  if (!affected || !selectedDeviceId || affected === selectedDeviceId) return
-  clearDeviceInUse(kind)
-}
-
 export const syncDeviceAvailability = async (): Promise<void> => {
   try {
     const devices = await navigator.mediaDevices.enumerateDevices()

src/frontend/src/stores/muteDialog.ts

@@ -1,18 +0,0 @@
-import { proxy, ref } from 'valtio'
-import type { Participant } from 'livekit-client'
-
-type State = {
-  participant: Participant | null
-}
-
-export const muteDialogStore = proxy<State>({
-  participant: null,
-})
-
-export const openMuteDialog = (participant: Participant) => {
-  muteDialogStore.participant = ref(participant)
-}
-
-export const closeMuteDialog = () => {
-  muteDialogStore.participant = null
-}

src/frontend/vite.config.ts

@@ -5,25 +5,15 @@ import { visualizer } from 'rollup-plugin-visualizer'
 import svgr from 'vite-plugin-svgr'
 import { viteStaticCopy } from 'vite-plugin-static-copy'
 
-const readPackageJson = (path: string) =>
-  JSON.parse(readFileSync(new URL(path, import.meta.url), 'utf-8'))
-
-const mediapipeVersion: string = readPackageJson(
-  './node_modules/@mediapipe/tasks-vision/package.json'
-).version
-
-const livekitMediapipeVersion: string = readPackageJson(
-  './node_modules/@livekit/track-processors/package.json'
-).dependencies['@mediapipe/tasks-vision']
-
-if (mediapipeVersion !== livekitMediapipeVersion) {
-  throw new Error(
-    `@mediapipe/tasks-vision@${mediapipeVersion} is installed, but ` +
-      `@livekit/track-processors declares "${livekitMediapipeVersion}". ` +
-      `The two must stay in sync: pin "@mediapipe/tasks-vision" to ` +
-      `"${livekitMediapipeVersion}" in package.json.`
+const mediapipeVersion: string = JSON.parse(
+  readFileSync(
+    new URL(
+      './node_modules/@mediapipe/tasks-vision/package.json',
+      import.meta.url
+    ),
+    'utf-8'
   )
-}
+).version
 
 // https://vitejs.dev/config/
 export default defineConfig(({ mode }) => {

src/mail/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "mail_mjml",
-  "version": "1.29.0",
+  "version": "1.27.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "mail_mjml",
-      "version": "1.29.0",
+      "version": "1.27.0",
       "license": "MIT",
       "dependencies": {
         "@html-to/text-cli": "0.6.1",

src/mail/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mail_mjml",
-  "version": "1.29.0",
+  "version": "1.27.0",
   "description": "An util to generate html and text django's templates from mjml templates",
   "type": "module",
   "dependencies": {

src/sdk/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "sdk",
-  "version": "1.29.0",
+  "version": "1.27.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "sdk",
-      "version": "1.29.0",
+      "version": "1.27.0",
       "license": "ISC",
       "workspaces": [
         "./library",

src/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdk",
-  "version": "1.29.0",
+  "version": "1.27.0",
   "author": "",
   "license": "ISC",
   "description": "",

src/summary/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "summary"
-version = "1.29.0"
+version = "1.27.0"
 dependencies = [
     "fastapi[standard]>=0.105.0",
     "uvicorn>=0.24.0",

src/summary/summary/core/analytics.py

@@ -1,10 +1,9 @@
 """Analytics classes."""
 
 import json
-import socket
 import time
 from collections import Counter
-from functools import cached_property, lru_cache
+from functools import lru_cache
 from urllib.parse import urlsplit, urlunsplit
 
 import redis
@@ -34,10 +33,6 @@ class Analytics:
             logger.info("Initialize analytics client")
             self._client = Posthog(settings.posthog_api_key, settings.posthog_api_host)
 
-    @cached_property
-    def _hostname(self):
-        return socket.gethostname()
-
     @property
     def is_disabled(self):
         """Check if analytics client is disabled or not configured."""
@@ -48,8 +43,6 @@ class Analytics:
         if self.is_disabled:
             return
 
-        properties = {**(properties or {}), "_hostname": self._hostname}
-
         try:
             self._client.capture(
                 event_name, distinct_id=distinct_id, properties=properties

src/summary/summary/core/config.py

@@ -83,7 +83,6 @@ class Settings(BaseSettings):
     aws_s3_access_key_id: str
     aws_s3_secret_access_key: SecretStr
     aws_s3_secure_access: bool = True
-    aws_s3_region_name: str | None = None
     aws_transcript_path: str = "transcripts"
     aws_summary_path: str = "summaries"
 

src/summary/summary/core/file_service.py

@@ -282,7 +282,6 @@ class FileService:
             access_key=settings.aws_s3_access_key_id,
             secret_key=settings.aws_s3_secret_access_key.get_secret_value(),
             secure=settings.aws_s3_secure_access,
-            region=settings.aws_s3_region_name,
         )
 
         self._bucket_name = settings.aws_storage_bucket_name