♻️(devex) update Makefile lint targets and harmonize service naming

The make lint target did not cover the summary and agents components. Update the linting workflow to include both services and harmonize Makefile target names. Harmonize Docker compose user declarations.
⬆️(frontend) upgrade @fontsource-variable/lexend from 5.2.11 to 5.3.0
2026-08-31 12:47:58 +00:00 · 2026-08-31 14:41:52 +02:00 · 2026-08-31 14:10:02 +02:00 · 2026-08-31 13:59:39 +02:00 · 2026-08-31 13:59:21 +02:00 · 2026-08-31 13:59:21 +02:00
83 changed files with 4568 additions and 2060 deletions
@@ -10,6 +10,44 @@ and this project adheres to

 ### Added

+- ✨(agent) support Voxtral realtime as inference engine
+- 🌐(i18n) add Spanish language support
+
+### Changed
+
+- 🔥(backend) remove the S3 storage-event webhook for recordings
+- ♻️(backend) always finalize recordings using the LiveKit egress_ended webhook
+- ⬆️(frontend) upgrade posthog-js from 1.409.5 to 1.414.0
+- ⬆️(frontend) upgrade @fontsource-variable/lexend from 5.2.11 to 5.3.0
+
+### Fixed
+
+- 🐛(frontend) fix chat text-area bug
+
+## [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

@@ -35,6 +73,7 @@ and this project adheres to
 - 🐛(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

@@ -39,14 +39,16 @@ DB_PORT            = 5432
 DOCKER_UID          = $(shell id -u)
 DOCKER_GID          = $(shell id -g)
 DOCKER_USER         = $(DOCKER_UID):$(DOCKER_GID)
-COMPOSE             = DOCKER_USER=$(DOCKER_USER) docker compose
-COMPOSE_EXEC        = $(COMPOSE) exec
-COMPOSE_EXEC_APP    = $(COMPOSE_EXEC) app-dev
-COMPOSE_RUN         = $(COMPOSE) run --rm
-COMPOSE_RUN_APP     = $(COMPOSE_RUN) app-dev
-COMPOSE_RUN_LINT    = $(COMPOSE_RUN) --no-deps app-dev
-COMPOSE_RUN_CROWDIN = $(COMPOSE_RUN) crowdin crowdin
-WAIT_DB             = @$(COMPOSE_RUN) dockerize -wait tcp://$(DB_HOST):$(DB_PORT) -timeout 60s
+COMPOSE                  = DOCKER_USER=$(DOCKER_USER) docker compose
+COMPOSE_EXEC             = $(COMPOSE) exec
+COMPOSE_EXEC_APP         = $(COMPOSE_EXEC) app-dev
+COMPOSE_RUN              = $(COMPOSE) run --rm
+COMPOSE_RUN_APP          = $(COMPOSE_RUN) app-dev
+COMPOSE_RUN_LINT_BACK    = $(COMPOSE_RUN) --no-deps app-dev
+COMPOSE_RUN_LINT_AGENTS  = $(COMPOSE_RUN) --no-deps multi-user-transcriber-dev
+COMPOSE_RUN_LINT_SUMMARY = $(COMPOSE_RUN) --no-deps app-summary-dev
+COMPOSE_RUN_CROWDIN      = $(COMPOSE_RUN) crowdin crowdin
+WAIT_DB                  = @$(COMPOSE_RUN) dockerize -wait tcp://$(DB_HOST):$(DB_PORT) -timeout 60s

 # -- Backend
 MANAGE              = $(COMPOSE_RUN_APP) python manage.py
@@ -59,6 +61,10 @@ LINT_PYLINT         = pylint meet demo core
 LINT_BACK           = echo 'lint:ruff-format started…' && $(LINT_RUFF_FORMAT) \
  && echo 'lint:ruff-check started…' && $(LINT_RUFF_CHECK) \
  && echo 'lint:pylint started…' && $(LINT_PYLINT)
+LINT_AGENTS         = echo 'lint:ruff-format started…' && $(LINT_RUFF_FORMAT) \
+  && echo 'lint:ruff-check started…' && $(LINT_RUFF_CHECK)
+LINT_SUMMARY        = echo 'lint:ruff-format started…' && $(LINT_RUFF_FORMAT) \
+  && echo 'lint:ruff-check started…' && $(LINT_RUFF_CHECK)

 # -- Frontend
 PATH_FRONT          = ./src/frontend
@@ -198,23 +204,37 @@ demo: ## flush db then create a demo for load testing purpose
 	@$(MANAGE) create_demo
 .PHONY: demo

-lint: ## lint back-end python sources
-	@$(COMPOSE_RUN_LINT) sh -c "$(LINT_BACK)"
+lint: ## lint all python sources (back-end, agents, summary)
+	@$(MAKE) lint-back
+	@$(MAKE) lint-agents
+	@$(MAKE) lint-summary
 .PHONY: lint

+lint-back: ## lint back-end python sources
+	@$(COMPOSE_RUN_LINT_BACK) sh -c "$(LINT_BACK)"
+.PHONY: lint-back
+
+lint-agents: ## lint agents python sources
+	@$(COMPOSE_RUN_LINT_AGENTS) sh -c "$(LINT_AGENTS)"
+.PHONY: lint-agents
+
+lint-summary: ## lint summary python sources
+	@$(COMPOSE_RUN_LINT_SUMMARY) sh -c "$(LINT_SUMMARY)"
+.PHONY: lint-summary
+
 lint-ruff-format: ## format back-end python sources with ruff
 	@echo 'lint:ruff-format started…'
-	@$(COMPOSE_RUN_LINT) $(LINT_RUFF_FORMAT)
+	@$(COMPOSE_RUN_LINT_BACK) $(LINT_RUFF_FORMAT)
 .PHONY: lint-ruff-format

 lint-ruff-check: ## lint back-end python sources with ruff
 	@echo 'lint:ruff-check started…'
-	@$(COMPOSE_RUN_LINT) $(LINT_RUFF_CHECK)
+	@$(COMPOSE_RUN_LINT_BACK) $(LINT_RUFF_CHECK)
 .PHONY: lint-ruff-check

 lint-pylint: ## lint back-end python sources with pylint only on changed files from main
 	@echo 'lint:pylint started…'
-	@$(COMPOSE_RUN_LINT) $(LINT_PYLINT)
+	@$(COMPOSE_RUN_LINT_BACK) $(LINT_PYLINT)
 .PHONY: lint-pylint

 test: ## run project tests; pass extra pytest args via ARGS, e.g. `make test ARGS="-vv"`
@@ -16,6 +16,23 @@ the following command inside your docker container:

 ## [Unreleased]

+### Removing S3 storage-event webhooks for recordings
+
+Recordings were previously confirmed as saved by an S3 storage-event webhook posting to `/api/v1.0/recordings/storage-hook/`. That endpoint has been removed: recordings are now always finalized from LiveKit's own `egress_ended` webhook, which has been the default path since v1.22.0.
+
+**Required for every deployment:** LiveKit must be able to deliver webhooks to the backend at `/api/v1.0/rooms/webhooks-livekit/`. This is now the only way a recording reaches a saved state; if `egress_ended` is never delivered, recordings stay in the `active` state.
+
+For hosters who had configured storage-event webhooks:
+- Recordings reach the same final state, but they are now finalized when LiveKit reports the egress as ended rather than when the storage backend reports the upload.
+- Remove the event notification from your bucket configuration: it now targets a non-existent endpoint and will fail on every delivery.
+
+For hosters who had **not** configured storage-event webhooks:
+- Nothing changes. Recordings have been finalized from the `egress_ended` webhook since v1.22.0.
+
+In both cases, the following settings are no longer used and can be removed from your env: `RECORDING_EVENT_PARSER_CLASS`, `RECORDING_ENABLE_STORAGE_EVENT_AUTH`, `RECORDING_STORAGE_EVENT_ENABLE`, `RECORDING_STORAGE_EVENT_TOKEN`.
+
+On completion of the egress, a recording moves to `notification_succeeded`, or to `saved` if notifying external services failed.
+
 ## v1.23.0

 As part of the 1.23.0 release, the legacy `api/v1` implementation has been removed from the _experimental_ Summary service and Meet has been migrated to the new `api/v2`.
@@ -46,21 +46,6 @@ services:
      /usr/bin/mc mb meet/meet-media-storage && \
      exit 0;"

-  createwebhook:
-    image: minio/mc
-    depends_on:
-      minio:
-        condition: service_healthy
-        restart: true
-    entrypoint: >
-      sh -c "
-      /usr/bin/mc alias set meet http://minio:9000 meet password &&
-      /usr/bin/mc admin config set meet notify_webhook:meet-webhook endpoint='http://app-dev:8000/api/v1.0/recordings/storage-hook/' auth_token='Bearer password' &&
-      /usr/bin/mc admin service restart meet --wait --json &&
-      sleep 15 &&
-      /usr/bin/mc event add meet/meet-media-storage arn:minio:sqs::meet-webhook:webhook --event put --prefix "recordings" &&
-      exit 0;"
-
  app-dev:
    build:
      context: .
@@ -86,7 +71,6 @@ services:
        - mailcatcher
        - redis
        - createbuckets
-        - createwebhook
    extra_hosts:
      - "127.0.0.1.nip.io:host-gateway"
    networks:
@@ -249,6 +233,7 @@ services:
    build:
      context: ./src/agents
      target: development
+    user: ${DOCKER_USER:-1000}
    command: ["python", "metadata_collector.py", "dev"]
    env_file:
      - env.d/development/metadata_collector
@@ -267,6 +252,8 @@ services:
    build:
      context: ./src/agents
      target: development
+    user: ${DOCKER_USER:-1000}
+    command: ["python", "multi_user_transcriber.py", "dev"]
    env_file:
      - env.d/development/multi_user_transcriber
    volumes:
@@ -23,14 +23,11 @@ It uses LiveKit Egress to record room sessions. For reference, see the [LiveKit
 To use the room recording feature, the following components are required:

 - A running [LiveKit Egress](https://github.com/livekit/egress) server capable of handling room composite recordings.
- A S3-compatible object storage that supports webhook events to notify the backend when recordings are uploaded.
+- A S3-compatible object storage where the egress uploads the recorded files.
 - An email service to notify room owners when a recording is available for download.
 - Webhook events configured between LiveKit Server and the backend.


-> [!CAUTION]
->  Minio supports lifecycle events; other providers may not work out of the box. There is currently a dependency on Minio, which is planned to be refactored in the future.
-
 > [!NOTE]
 > Celery isn’t in use for these async tasks yet. It’s something we’d like to add, but it’s not planned at this stage.

@@ -75,7 +72,7 @@ sequenceDiagram
    LiveKit->>Egress: Stop recording
    Egress->>Storage: Upload recorded file
    
-    Storage->>Backend: Storage event notification
+    LiveKit->>Backend: POST /api/v1.0/rooms/webhooks-livekit/ (egress_ended)
    Backend->>Backend: Update Recording status to SAVED
    Backend->>Email: Send notification to room owner
    
@@ -94,10 +91,6 @@ sequenceDiagram
 | **RECORDING_ENABLE**                    | Boolean     | `False`                                                                                                                                                            | Enable or disable the room recording feature.                                                                                                                                                                                                                                                      |
 | **RECORDING_OUTPUT_FOLDER**             | String      | `"recordings"`                                                                                                                                                     | Folder/prefix where recordings are stored in the object storage.                                                                                                                                                                                                                                   |
 | **RECORDING_WORKER_CLASSES**            | Dict        | `{ "screen_recording": "core.recording.worker.services.VideoCompositeEgressService", "transcript": "core.recording.worker.services.AudioCompositeEgressService" }` | Maps recording types to their worker service classes.                                                                                                                                                                                                                                              |
-| **RECORDING_EVENT_PARSER_CLASS**        | String      | `"core.recording.event.parsers.MinioParser"`                                                                                                                       | Class responsible for parsing storage events and updating the backend.                                                                                                                                                                                                                             |
-| **RECORDING_ENABLE_STORAGE_EVENT_AUTH** | Boolean     | `True`                                                                                                                                                             | Enable authentication for storage event webhook requests.                                                                                                                                                                                                                                          |
-| **RECORDING_STORAGE_EVENT_ENABLE**      | Boolean     | `False`                                                                                                                                                            | Enable handling of storage events (must configure webhook in storage). If `False`, fallback to LiveKit egress complete webhook.                                                    |
-| **RECORDING_STORAGE_EVENT_TOKEN**       | Secret/File | `None`                                                                                                                                                             | Token used to authenticate storage webhook requests, if `RECORDING_ENABLE_STORAGE_EVENT_AUTH` is enabled.                                                                                                                                                                                          |
 | **RECORDING_EXPIRATION_DAYS**           | Integer     | `None`                                                                                                                                                             | Number of days before recordings expire. Should match bucket lifecycle policy. Set to `None` for no expiration.                                                                                                                                                                                    |
 | **RECORDING_MAX_DURATION**              | Integer     | `None`                                                                                                                                                             | Maximum duration of a recording in milliseconds. Must be synced with the LiveKit Egress configuration. Set to None for unlimited duration. When the maximum duration is reached, the recording is automatically stopped and saved, and the user is prompted in the frontend with an alert message. |
 | **RECORDING_ENCODING_ENABLED**          | Boolean     | `False`                                                                                                                                                            | When `False`, LiveKit Egress uses its built-in `H264_720P_30` preset. When `True`, the `RECORDING_ENCODING_*` values below are sent to LiveKit as advanced `EncodingOptions`. See [Tuning recording encoding](#tuning-recording-encoding).                                                          |
@@ -109,19 +102,6 @@ sequenceDiagram
 | **RECORDING_ENCODING_KEY_FRAME_INTERVAL_S** | Float   | `4.0`                                                                                                                                                              | Keyframe interval in seconds. Drives seek granularity in the recorded MP4 (a player can only seek to keyframe boundaries). Larger values give the encoder slightly more bits for non-keyframe content at a fixed bitrate. `4.0` is a standard VOD value. Only applied when `RECORDING_ENCODING_ENABLED` is `True`. |


-### Manual Storage Webhook
-
-Storage events must be configured manually; the Kubernetes chart does not do this automatically.
-
-1. Configure your S3 bucket to send file creation events to the backend webhook.
-2. Enable events and token in settings:
-
-```python
-RECORDING_STORAGE_EVENT_ENABLE = True
-RECORDING_ENABLE_STORAGE_EVENT_AUTH = True
-RECORDING_STORAGE_EVENT_TOKEN = <token>
-```
-
 > [!NOTE]
 > Questions? Open an issue on [GitHub](https://github.com/suitenumerique/meet/issues/new?assignees=&labels=bug&template=Bug_report.md) or join our [Matrix community](https://matrix.to/#/#meet-official:matrix.org).

@@ -406,10 +406,6 @@ These are the environmental options available on meet backend.
 | RECORDING_ENABLE                                | Record meeting option                                                                                                                                        | false                                                                                                                                                         |
 | RECORDING_OUTPUT_FOLDER                         | Folder to store meetings                                                                                                                                     | recordings                                                                                                                                                    |
 | RECORDING_WORKER_CLASSES                        | Worker classes for recording                                                                                                                                 | {"screen_recording": "core.recording.worker.services.VideoCompositeEgressService","transcript": "core.recording.worker.services.AudioCompositeEgressService"} |
-| RECORDING_EVENT_PARSER_CLASS                    | Storage event engine for recording                                                                                                                           | core.recording.event.parsers.MinioParser                                                                                                                      |
-| RECORDING_ENABLE_STORAGE_EVENT_AUTH             | Enable storage event authorization                                                                                                                           | true                                                                                                                                                          |
-| RECORDING_STORAGE_EVENT_ENABLE                  | Enable recording storage events. If false, fallback to egress webhook.                                                                                                                           | false                                                                                                                                                         |
-| RECORDING_STORAGE_EVENT_TOKEN                   | Recording storage event token                                                                                                                                |                                                                                                                                                               |
 | RECORDING_EXPIRATION_DAYS                       | Recording expiration in days                                                                                                                                 |                                                                                                                                                               |
 | RECORDING_MAX_DURATION                          | Maximum recording duration in milliseconds. Must match LiveKit Egress configuration exactly.                                                                 |                                                                                                                                                               |
 | SCREEN_RECORDING_BASE_URL                       | Screen recording base URL                                                                                                                                    |                                                                                                                                                               |
@@ -63,8 +63,6 @@ ALLOW_UNREGISTERED_ROOMS=False

 # Recording
 RECORDING_ENABLE=True
-RECORDING_STORAGE_EVENT_ENABLE=False
-RECORDING_STORAGE_EVENT_TOKEN=password
 SUMMARY_SERVICE_ENDPOINT=http://app-summary-dev:8000/api/v2/async-jobs/transcribe/
 SUMMARY_SERVICE_API_TOKEN=password
 SUMMARY_SERVICE_WEBHOOK_API_TOKEN=webhook-password
@@ -1,14 +1,23 @@
+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=kyutai # kyutai, deepgram
+STT_PROVIDER=voxtral-vllm # voxtral-vllm, kyutai, deepgram
 ENABLE_SILERO_VAD=False

-DEEPGRAM_API_KEY=
+DEEPGRAM_API_KEY=your-deepgram-api-key

-KYUTAI_STT_BASE_URL=
-KYUTAI_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

 SENTRY_DSN=
 SENTRY_ENVIRONMENT=
@@ -1,6 +1,7 @@
 """Multi user transcription agent."""

 import asyncio
+import contextlib
 import logging
 import os

@@ -25,6 +26,7 @@ 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

@@ -36,9 +38,18 @@ TRANSCRIBER_AGENT_NAME = os.getenv("TRANSCRIBER_AGENT_NAME", "multi-user-transcr
 STT_PROVIDER = os.getenv("STT_PROVIDER", "deepgram")
 ENABLE_SILERO_VAD = os.getenv("ENABLE_SILERO_VAD", "true").lower() == "true"

+SESSION_DRAIN_TIMEOUT_S = 15.0

-def create_stt_provider():
-    """Create STT provider based on environment configuration."""
+
+def create_stt_provider(vad: silero.VAD | None = None):
+    """Create STT provider based on environment configuration.
+
+    Args:
+        vad: Shared, prewarmed VAD instance. Required in practice for
+            voxtral-vllm (no server-side endpointing): if omitted, the plugin
+            loads its own Silero model synchronously on the event loop, once
+            per participant, freezing all active sessions for the duration.
+    """
    if STT_PROVIDER == "deepgram":
        # Note: Not all Deepgram API parameters are supported by the LiveKit plugin
        # detect_language is NOT supported for real-time streaming
@@ -49,6 +60,9 @@ 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(vad=vad)
    else:
        raise ValueError(f"Unknown STT_PROVIDER: {STT_PROVIDER}")

@@ -58,9 +72,9 @@ def create_stt_provider():
 class Transcriber(Agent):
    """Create a transcription agent for a specific participant."""

-    def __init__(self, *, participant_identity: str):
+    def __init__(self, *, participant_identity: str, vad: silero.VAD | None = None):
        """Init transcription agent."""
-        stt = create_stt_provider()
+        stt = create_stt_provider(vad=vad)

        super().__init__(
            instructions="not-needed",
@@ -76,6 +90,7 @@ class MultiUserTranscriber:
        """Init multi user transcription agent."""
        self.ctx = ctx
        self._sessions: dict[str, AgentSession] = {}
+        self._starting: dict[str, asyncio.Task] = {}
        self._tasks: set[asyncio.Task] = set()

    def start(self):
@@ -96,22 +111,30 @@ class MultiUserTranscriber:

    def on_participant_connected(self, participant: rtc.RemoteParticipant):
        """Handle new participant connection by starting transcription session."""
-        if participant.identity in self._sessions:
+        identity = participant.identity
+        if identity in self._sessions or identity in self._starting:
            return

-        logger.info(f"starting session for {participant.identity}")
+        logger.info(f"starting session for {identity}")
        task = asyncio.create_task(self._start_session(participant))
+        self._starting[identity] = task
        self._tasks.add(task)
+        task.add_done_callback(lambda t, i=identity: self._starting.pop(i, None))
        task.add_done_callback(
            done_callback(
                logger,
                self._tasks,
-                f"start transcription session for {participant.identity}",
+                f"start transcription session for {identity}",
            )
        )

    def on_participant_disconnected(self, participant: rtc.RemoteParticipant):
        """Handle participant disconnection by closing transcription session."""
+        if (start_task := self._starting.pop(participant.identity, None)) is not None:
+            logger.info(f"cancelling pending session start for {participant.identity}")
+            start_task.cancel()
+            return
+
        if (session := self._sessions.pop(participant.identity, None)) is None:
            return

@@ -127,10 +150,12 @@ class MultiUserTranscriber:
        )

    async def _start_session(self, participant: rtc.RemoteParticipant) -> AgentSession:
-        """Create and start transcription session for participant."""
-        if participant.identity in self._sessions:
-            return self._sessions[participant.identity]
+        """Create and start transcription session for participant.

+        Deduplication happens synchronously in on_participant_connected via
+        self._starting; by the time this coroutine runs, the identity is
+        already reserved.
+        """
        vad = self.ctx.proc.userdata.get("vad", None)
        session = AgentSession(vad=vad)
        room_io = RoomIO(
@@ -141,18 +166,30 @@ class MultiUserTranscriber:
                text_input=False, audio_output=False, text_output=True
            ),
        )
-        await room_io.start()
-        await session.start(
-            agent=Transcriber(
-                participant_identity=participant.identity,
+        try:
+            await room_io.start()
+            await session.start(
+                agent=Transcriber(
+                    participant_identity=participant.identity,
+                    vad=vad,
+                )
            )
-        )
+        except BaseException:
+            with contextlib.suppress(Exception):
+                await session.aclose()
+            raise
        self._sessions[participant.identity] = session
        return session

    async def _close_session(self, sess: AgentSession) -> None:
        """Close and cleanup transcription session."""
-        await sess.drain()
+        try:
+            await asyncio.wait_for(sess.drain(), timeout=SESSION_DRAIN_TIMEOUT_S)
+        except (TimeoutError, asyncio.TimeoutError):
+            logger.warning(
+                "session drain timed out after %.0fs; forcing close",
+                SESSION_DRAIN_TIMEOUT_S,
+            )
        await sess.aclose()


@@ -1,7 +1,7 @@

 [project]
 name = "agents"
-version = "1.27.0"
+version = "1.29.0"
 requires-python = ">=3.12"
 dependencies = [
    "livekit-agents==1.6.7",
@@ -12,6 +12,8 @@ dependencies = [
    "protobuf==6.33.6",
    "minio==7.2.20",
    "sentry-sdk==2.66.1",
+    "websockets==17.1",
+    "httpx==0.28.1",
 ]

 [project.optional-dependencies]
@@ -0,0 +1,476 @@
+"""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):
+    """Voxtral realtime handler."""
+
+    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)
@@ -11,7 +11,6 @@ class FeatureFlag:

    FLAGS = {
        "recording": "RECORDING_ENABLE",
-        "storage_event": "RECORDING_STORAGE_EVENT_ENABLE",
        "subtitle": "ROOM_SUBTITLE_ENABLED",
        "file_upload": "FILE_UPLOAD_ENABLED",
        "addons": "ADDONS_ENABLED",
@@ -5,7 +5,7 @@ from django.http import Http404

 from rest_framework import permissions

-from ..models import RoleChoices
+from ..models import RoleChoices, RoomAccessLevel
 from ..services.participants_management import (
    ParticipantNotFoundException,
    ParticipantsManagement,
@@ -198,3 +198,48 @@ 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
@@ -45,25 +45,11 @@ from core.api import throttling
 from core.api.filters import ListFileFilter
 from core.enums import MEDIA_STORAGE_URL_PATTERN
 from core.recording.enums import FileExtension
-from core.recording.event.authentication import (
-    RecordingProcessWebhookAuthentication,
-    StorageEventAuthentication,
-)
-from core.recording.event.exceptions import (
-    InvalidBucketError,
-    InvalidFilepathError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-from core.recording.event.parsers import get_parser
+from core.recording.event.authentication import RecordingProcessWebhookAuthentication
 from core.recording.services.metadata_collector import (
    MetadataCollectorException,
    MetadataCollectorService,
 )
-from core.recording.services.recording_events import (
-    RecordingEventsService,
-    RecordingNotSavableError,
-)
 from core.recording.worker.exceptions import (
    RecordingStartError,
    RecordingStopError,
@@ -536,7 +522,7 @@ class RoomViewSet(
        methods=["post"],
        url_path="enter",
        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
+            permissions.CanManageLobby,
        ],
    )
    def allow_participant_to_enter(self, request, pk=None):  # pylint: disable=unused-argument
@@ -574,7 +560,7 @@ class RoomViewSet(
        methods=["GET"],
        url_path="waiting-participants",
        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
+            permissions.CanManageLobby,
        ],
    )
    def list_waiting_participants(self, request, pk=None):  # pylint: disable=unused-argument
@@ -1034,56 +1020,6 @@ class RecordingViewSet(
            .filter(Q(accesses__user=user) | Q(accesses__team__in=user.get_teams()))
        )

-    @decorators.action(
-        detail=False,
-        methods=["post"],
-        url_path="storage-hook",
-        authentication_classes=[StorageEventAuthentication],
-    )
-    @FeatureFlag.require("storage_event")
-    def on_storage_event_received(self, request, pk=None):  # pylint: disable=unused-argument
-        """Handle incoming storage hook events for recordings."""
-
-        parser = get_parser()
-
-        try:
-            recording_id = parser.get_recording_id(request.data)
-
-        except ParsingEventDataError as e:
-            raise drf_exceptions.PermissionDenied("Invalid request data.") from e
-
-        except InvalidBucketError as e:
-            raise drf_exceptions.PermissionDenied("Invalid bucket specified.") from e
-
-        except InvalidFilepathError:
-            return drf_response.Response(
-                {"message": "Notification ignored."},
-            )
-
-        except InvalidFileTypeError:
-            return drf_response.Response(
-                {"message": "Notification ignored."},
-            )
-
-        try:
-            recording = models.Recording.objects.get(id=recording_id)
-        except models.Recording.DoesNotExist as e:
-            raise drf_exceptions.NotFound("No recording found for this event.") from e
-
-        # Save recording
-        recording_events_service = RecordingEventsService()
-        try:
-            recording_events_service.handle_complete(recording)
-        except RecordingNotSavableError:
-            raise drf_exceptions.PermissionDenied(
-                f"Recording with ID {recording_id} cannot be saved because it is either,"
-                " in an error state or has already been saved."
-            ) from None
-
-        return drf_response.Response(
-            {"message": "Event processed."},
-        )
-
    @decorators.action(
        detail=False,
        methods=["post"],
@@ -1,4 +1,4 @@
-"""Authentication class for storage event token validation."""
+"""Authentication classes for server-to-server webhook token validation."""

 import logging
 import secrets
@@ -12,9 +12,9 @@ logger = logging.getLogger(__name__)


 class MachineUser:
-    """Represent a non-interactive system user for automated storage operations."""
+    """Represent a non-interactive system user for automated operations."""

-    def __init__(self, username: str = "storage_event_user") -> None:
+    def __init__(self, username: str = "machine_user") -> None:
        self.pk = None
        self.username = username
        self.is_active = True
@@ -41,24 +41,17 @@ class HeaderBasedAuthentication(BaseAuthentication):
    TOKEN_TYPE = "Bearer"  # noqa S105
    REALM = ""

-    IS_ENFORCED_SETTINGS_KEY = None
    EXPECTED_TOKEN_SETTINGS_KEY = None

    def authenticate(self, request):
        """Validate the Bearer token from the Authorization header."""

-        if self.IS_ENFORCED_SETTINGS_KEY is not None:
-            if not getattr(settings, self.IS_ENFORCED_SETTINGS_KEY):
-                return MachineUser(), None
-
        if (
            self.EXPECTED_TOKEN_SETTINGS_KEY is None
            or (required_token := getattr(settings, self.EXPECTED_TOKEN_SETTINGS_KEY))
            is None
        ):
-            raise AuthenticationFailed(
-                "Authentication is enabled but token is not configured."
-            )
+            raise AuthenticationFailed("Authentication token is not configured.")

        auth_header = request.headers.get(self.AUTH_HEADER)
        if not auth_header:
@@ -88,18 +81,6 @@ class HeaderBasedAuthentication(BaseAuthentication):
        return f"{self.TOKEN_TYPE} realm='{self.REALM}'"


-class StorageEventAuthentication(HeaderBasedAuthentication):
-    """Authenticate requests using a Bearer token for storage event integration.
-    This class validates Bearer tokens for storage events that don't map to database users.
-    It's designed for S3-compatible storage integrations and similar use cases.
-    Events are submitted when a webhook is configured on some bucket's events.
-    """
-
-    REALM = "Storage event API"
-    IS_ENFORCED_SETTINGS_KEY = "RECORDING_ENABLE_STORAGE_EVENT_AUTH"
-    EXPECTED_TOKEN_SETTINGS_KEY = "RECORDING_STORAGE_EVENT_TOKEN"  # noqa S105
-
-
 class RecordingProcessWebhookAuthentication(HeaderBasedAuthentication):
    """
    Custom authentication class for recording process webhook requests.
@@ -1,17 +0,0 @@
-"""Storage parsers specific exceptions."""
-
-
-class ParsingEventDataError(Exception):
-    """Raised when the request data is malformed, incomplete, or missing."""
-
-
-class InvalidBucketError(Exception):
-    """Raised when the bucket name in the request does not match the expected one."""
-
-
-class InvalidFileTypeError(Exception):
-    """Raised when the file type in the request is not supported."""
-
-
-class InvalidFilepathError(Exception):
-    """Raised when the filepath in the request is invalid."""
@@ -1,178 +0,0 @@
-"""Meet storage event parser classes."""
-
-import logging
-import mimetypes
-import re
-from dataclasses import dataclass
-from functools import lru_cache
-from typing import Any, Dict, Optional, Protocol
-from urllib.parse import quote
-
-from django.conf import settings
-from django.utils.module_loading import import_string
-
-from core.enums import FILE_EXT_REGEX, UUID_REGEX
-
-from .exceptions import (
-    InvalidBucketError,
-    InvalidFilepathError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-
-# Additional MIME type mapping
-mimetypes.add_type("audio/ogg", ".ogg")
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class StorageEvent:
-    """Represents a storage event with relevant metadata.
-    Attributes:
-        filepath: Identifier for the affected recording
-        filetype: Type of storage event
-        bucket_name: When the event occurred
-        metadata: Additional event data
-    """
-
-    filepath: str
-    filetype: str
-    bucket_name: str
-    metadata: Optional[Dict[str, Any]]
-
-    def __post_init__(self):
-        if self.filepath is None:
-            raise TypeError("filepath cannot be None")
-        if self.filetype is None:
-            raise TypeError("filetype cannot be None")
-        if self.bucket_name is None:
-            raise TypeError("bucket_name cannot be None")
-
-
-class EventParser(Protocol):
-    """Interface for parsing storage events."""
-
-    def __init__(self, bucket_name, allowed_filetypes=None):
-        """Initialize parser with bucket name and optional allowed filetypes."""
-
-    def parse(self, data: Dict) -> StorageEvent:
-        """Extract storage event data from raw dictionary input."""
-
-    def validate(self, data: StorageEvent) -> str:
-        """Verify storage event data meets all requirements."""
-
-    def get_recording_id(self, data: Dict) -> str:
-        """Extract recording ID from event dictionary."""
-
-
-@lru_cache(maxsize=1)
-def get_parser() -> EventParser:
-    """Return cached instance of configured event parser.
-    Uses function memoization instead of a factory class since the only
-    varying parameter is the parser class from settings. A factory class
-    would add unnecessary complexity when a cached function provides the
-    same singleton behavior with simpler code.
-    """
-
-    event_parser_cls = import_string(settings.RECORDING_EVENT_PARSER_CLASS)
-    return event_parser_cls(bucket_name=settings.AWS_STORAGE_BUCKET_NAME)
-
-
-class BaseS3Parser:
-    """Base class for handling parsing and validation of S3-compatible storage events."""
-
-    def __init__(self, bucket_name: str, allowed_filetypes=None):
-        """Initialize parser with target bucket name and accepted filetypes."""
-
-        if not bucket_name:
-            raise ValueError("Bucket name cannot be None or empty")
-
-        self._bucket_name = bucket_name
-        self._allowed_filetypes = allowed_filetypes or {"audio/ogg", "video/mp4"}
-
-        # pylint: disable=line-too-long
-        self._filepath_regex = re.compile(
-            rf"(?P<url_encoded_folder_path>(?:[^%]+%2F)+)?{settings.RECORDING_OUTPUT_FOLDER}%2F(?P<recording_id>{UUID_REGEX})\.(?P<extension>{FILE_EXT_REGEX})"
-        )
-
-    def validate(self, event_data: StorageEvent) -> str:
-        """Verify StorageEvent matches bucket, filetype and filepath requirements."""
-
-        if event_data.bucket_name != self._bucket_name:
-            raise InvalidBucketError(
-                f"Invalid bucket: expected {self._bucket_name}, got {event_data.bucket_name}"
-            )
-
-        if event_data.filetype not in self._allowed_filetypes:
-            raise InvalidFileTypeError(
-                f"Invalid file type, expected {self._allowed_filetypes},"
-                f"got '{event_data.filetype}'"
-            )
-
-        match = self._filepath_regex.match(event_data.filepath)
-        if not match:
-            raise InvalidFilepathError(
-                f"Invalid filepath structure: {event_data.filepath}"
-            )
-
-        recording_id = match.group("recording_id")
-        return recording_id
-
-    def get_recording_id(self, data):
-        """Extract recording ID from S3 event through parsing and validation."""
-
-        event_data = self.parse(data)
-        return self.validate(event_data)
-
-    def parse(self, data: Dict) -> StorageEvent:
-        """To be implemented by subclasses."""
-        raise NotImplementedError("Subclasses must implement parse()")
-
-
-class MinioParser(BaseS3Parser):
-    """Minio specific event parsing."""
-
-    def parse(self, data: Dict) -> StorageEvent:
-        if not data:
-            raise ParsingEventDataError("Received empty data.")
-        try:
-            record = data["Records"][0]
-            s3 = record["s3"]
-            return StorageEvent(
-                filepath=s3["object"]["key"],
-                filetype=s3["object"]["contentType"],  # Minio-specific field
-                bucket_name=s3["bucket"]["name"],
-                metadata=None,
-            )
-        except (KeyError, IndexError) as e:
-            raise ParsingEventDataError(f"Malformed Minio event: {e}") from e
-        except TypeError as e:
-            raise ParsingEventDataError(f"Missing essential data fields: {e}") from e
-
-
-class S3Parser(BaseS3Parser):
-    """AWS S3 specific event parsing."""
-
-    def parse(self, data: Dict) -> StorageEvent:
-        if not data:
-            raise ParsingEventDataError("Received empty data.")
-        try:
-            # AWS S3 structure can slightly differ from Minio implementation
-            record = data["Records"][0]
-            s3 = record["s3"]
-            filepath = s3["object"]["key"]
-            if not filepath:
-                raise ParsingEventDataError("Missing object key name")
-            filetype, _ = mimetypes.guess_type(filepath)
-            # Normalize raw S3-compatible object keys without re-encoding
-            # already encoded AWS S3 notification keys.
-            filepath = quote(filepath, safe="%+")
-            return StorageEvent(
-                filepath=filepath,
-                filetype=filetype,
-                bucket_name=s3["bucket"]["name"],
-                metadata=None,
-            )
-        except (KeyError, IndexError) as e:
-            raise ParsingEventDataError(f"Malformed S3 event: {e}") from e
@@ -23,6 +23,7 @@ from core.recording.services.recording_events import (
 )

 from .lobby import LobbyService
+from .presence import PresenceCache
 from .room_management import (
    RoomManagement,
    RoomManagementException,
@@ -99,6 +100,7 @@ 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(
@@ -107,6 +109,7 @@ 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()

@@ -217,10 +220,8 @@ class LiveKitEventsService:
                    f"Failed to process limit reached event for recording {recording}"
                ) from e

-        # Fallback for completion when no MinIO/S3 webhooks are configured
-        if (
-            not settings.RECORDING_STORAGE_EVENT_ENABLE
-        ) and data.egress_info.status in [
+        # Finalize the recording, the egress has uploaded the file to the storage
+        if data.egress_info.status in [
            api.EgressStatus.EGRESS_COMPLETE,
            api.EgressStatus.EGRESS_LIMIT_REACHED,
        ]:
@@ -285,9 +286,31 @@ 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)
@@ -270,7 +270,7 @@ class LobbyService:
        """List all waiting participants for a room."""

        pattern = self._get_cache_key(room_id, "*")
-        keys = cache.keys(pattern)
+        keys = list(cache.iter_keys(pattern, itersize=utils.CACHE_SCAN_ITERSIZE))

        if not keys:
            return []
@@ -345,13 +345,9 @@ class LobbyService:
    def clear_room_cache(self, room_id: UUID) -> None:
        """Clear all participant entries from the cache for a specific room."""

-        pattern = self._get_cache_key(room_id, "*")
-        keys = cache.keys(pattern)
-
-        if not keys:
-            return
-
-        cache.delete_many(keys)
+        cache.delete_pattern(
+            self._get_cache_key(room_id, "*"), itersize=utils.CACHE_SCAN_ITERSIZE
+        )

    def clear_participant_cache(self, room_id: UUID, participant_id: str) -> None:
        """Clear a given participant entry from the cache for a specific room."""
@@ -20,6 +20,7 @@ from livekit.protocol.models import ParticipantInfo
 from core import utils

 from .lobby import LobbyService
+from .presence import PresenceCache

 logger = getLogger(__name__)

@@ -72,7 +73,9 @@ class ParticipantsManagement:

    @async_to_sync
    async def remove(self, room_name: str, identity: str):
-        """Remove a participant from a room and clear their lobby cache."""
+        """Remove a participant from a room and clear their lobby/presence cache."""
+
+        PresenceCache().clear(room_name, identity)

        try:
            LobbyService().clear_participant_cache(
@@ -156,6 +159,30 @@ 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`.
@@ -0,0 +1,52 @@
+"""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
+        )
@@ -11,135 +11,98 @@ from rest_framework.exceptions import AuthenticationFailed

 from core.recording.event.authentication import (
    MachineUser,
-    StorageEventAuthentication,
+    RecordingProcessWebhookAuthentication,
 )


 def test_successful_authentication(settings):
    """Test successful authentication with valid token."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "valid-test-token"
    request = RequestFactory().get("/")
    request.headers = {"Authorization": "Bearer valid-test-token"}

-    user, token = StorageEventAuthentication().authenticate(request)
+    user, token = RecordingProcessWebhookAuthentication().authenticate(request)
    assert token == "valid-test-token"
    assert isinstance(user, MachineUser)


-def test_disabled_authentication_with_header(settings):
-    """Authentication should pass when no auth is configured, and header is present."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = None
-    settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH = False
-
-    request = RequestFactory().get("/")
-    request.headers = {"Authorization": "Bearer some-token"}
-
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token is None
-    assert isinstance(user, MachineUser)
-
-
-def test_disabled_authentication_without_header(settings):
-    """Authentication should pass when no auth is configured, and no header is present."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = None
-    settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH = False
-
-    request = RequestFactory().get("/")
-
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token is None
-    assert isinstance(user, MachineUser)
-
-
-def test_authentication_when_disabled(settings):
-    """Authentication should pass when disabled, regardless of token configuration."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "some-token"
-    settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH = False
-
-    request = RequestFactory().get("/")
-
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token is None
-    assert isinstance(user, MachineUser)
-
-
 def test_authentication_fails_when_token_not_configured(settings):
-    """Authentication should fail when authentication is enabled but no token is configured."""
+    """Authentication should fail when no token is configured."""

-    # By default RECORDING_ENABLE_STORAGE_EVENT_AUTH should be True
-    settings.RECORDING_STORAGE_EVENT_TOKEN = None
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = None

    request = RequestFactory().get("/")

    with pytest.raises(
        AuthenticationFailed,
-        match="Authentication is enabled but token is not configured",
+        match="Authentication token is not configured",
    ):
-        StorageEventAuthentication().authenticate(request)
+        RecordingProcessWebhookAuthentication().authenticate(request)


 def test_missing_auth_header(settings):
    """Test failure when Authorization header is missing."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "valid-test-token"
    request = RequestFactory().get("/")
    request.headers = {}

    with pytest.raises(AuthenticationFailed, match="Authorization header is required"):
-        StorageEventAuthentication().authenticate(request)
+        RecordingProcessWebhookAuthentication().authenticate(request)


 def test_invalid_auth_header_format(settings):
    """Test failure when Authorization header has invalid format."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "valid-test-token"
    request = RequestFactory().get("/")
    request.headers = {"Authorization": "InvalidFormat"}

    with pytest.raises(AuthenticationFailed, match="Invalid authorization header"):
-        StorageEventAuthentication().authenticate(request)
+        RecordingProcessWebhookAuthentication().authenticate(request)


 def test_invalid_token_type(settings):
    """Test failure when token type is not Bearer."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "valid-test-token"
    request = RequestFactory().get("/")
    request.headers = {"Authorization": "Basic some-token"}

    with pytest.raises(AuthenticationFailed, match="Invalid authorization header"):
-        StorageEventAuthentication().authenticate(request)
+        RecordingProcessWebhookAuthentication().authenticate(request)


 def test_invalid_token(settings):
    """Test failure when token is invalid."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "valid-test-token"
    request = RequestFactory().get("/")
    request.headers = {"Authorization": "Bearer wrong-token"}

    with pytest.raises(AuthenticationFailed, match="Invalid token"):
-        StorageEventAuthentication().authenticate(request)
+        RecordingProcessWebhookAuthentication().authenticate(request)


 def test_malformed_auth_header(settings):
    """Test failure when Authorization header is malformed."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "valid-test-token"
    request = RequestFactory().get("/")
    request.headers = {"Authorization": "Bearer"}  # Missing token part

    with pytest.raises(AuthenticationFailed, match="Invalid authorization header"):
-        StorageEventAuthentication().authenticate(request)
+        RecordingProcessWebhookAuthentication().authenticate(request)


 def test_authenticate_header():
    """Test the WWW-Authenticate header value."""
    request = RequestFactory().get("/")
-    header = StorageEventAuthentication().authenticate_header(request)
-    assert header == "Bearer realm='Storage event API'"
+    header = RecordingProcessWebhookAuthentication().authenticate_header(request)
+    assert header == "Bearer realm='External process webhook API'"


 def test_multiple_spaces_in_auth_header(settings):
-    """Test success when Authorization header contains multiple spaces."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+    """Extra spaces between the scheme and the token should be tolerated."""
+    settings.SUMMARY_SERVICE_WEBHOOK_API_TOKEN = "extra-spaces-token"
    request = RequestFactory().get("/")
    request.headers = {"Authorization": "Bearer   extra-spaces-token"}

-    header = StorageEventAuthentication().authenticate_header(request)
-    assert header == "Bearer realm='Storage event API'"
+    user, token = RecordingProcessWebhookAuthentication().authenticate(request)
+    assert token == "extra-spaces-token"
+    assert isinstance(user, MachineUser)
@@ -1,512 +0,0 @@
-"""
-Test event parsers.
-"""
-
-# pylint: disable=protected-access,redefined-outer-name,unused-argument
-
-from unittest import mock
-
-from django.conf import settings
-
-import pytest
-
-from core.recording.event.exceptions import (
-    InvalidBucketError,
-    InvalidFilepathError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-from core.recording.event.parsers import (
-    MinioParser,
-    S3Parser,
-    StorageEvent,
-    get_parser,
-)
-
-# MinioParser
-
-
-@pytest.fixture
-def valid_minio_event():
-    """Mock a valid Minio event."""
-    return {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": "recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-                        "contentType": "audio/ogg",
-                    },
-                }
-            }
-        ]
-    }
-
-
-@pytest.fixture
-def minio_parser():
-    """Mock a Minio parser."""
-    return MinioParser(bucket_name="test-bucket")
-
-
-def test_minio_parse_valid_event(minio_parser, valid_minio_event):
-    """Test parsing a valid Minio event."""
-    event = minio_parser.parse(valid_minio_event)
-    assert isinstance(event, StorageEvent)
-    assert event.filepath == "recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg"
-    assert event.filetype == "audio/ogg"
-    assert event.bucket_name == "test-bucket"
-    assert event.metadata is None
-
-
-def test_minio_parse_with_video_type(minio_parser):
-    """Test parsing event with video file type."""
-    video_event = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": "46d1a121-2426-484d-8fb3-09b5d886f7a8.mp4",
-                        "contentType": "video/mp4",
-                    },
-                }
-            }
-        ]
-    }
-    event = minio_parser.parse(video_event)
-    assert event.filetype == "video/mp4"
-    assert event.filepath.endswith(".mp4")
-
-
-def test_minio_parse_empty_data(minio_parser):
-    """Test parsing empty event data raises error."""
-    with pytest.raises(ParsingEventDataError, match="Received empty data."):
-        minio_parser.parse({})
-
-
-def test_minio_parse_missing_keys(minio_parser):
-    """Test parsing event with missing key."""
-
-    invalid_minio_event = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": None},
-                    # Missing 'object' key
-                }
-            }
-        ]
-    }
-
-    with pytest.raises(ParsingEventDataError, match="Malformed Minio event:"):
-        minio_parser.parse(invalid_minio_event)
-
-
-def test_minio_parse_none_key(minio_parser):
-    """Test parsing event with None field."""
-
-    invalid_minio_event = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": "recording%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-                        "contentType": None,  # 'contentType' should not be None
-                    },
-                }
-            }
-        ]
-    }
-
-    with pytest.raises(ParsingEventDataError, match="Missing essential data fields"):
-        minio_parser.parse(invalid_minio_event)
-
-
-def test_minio_validate_invalid_bucket(minio_parser):
-    """Test validation with wrong bucket name."""
-    event = StorageEvent(
-        filepath="recording%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-        filetype="audio/ogg",
-        bucket_name="wrong-bucket",
-        metadata=None,
-    )
-    with pytest.raises(InvalidBucketError):
-        minio_parser.validate(event)
-
-
-def test_minio_validate_invalid_filetype(minio_parser):
-    """Test validation with unsupported file type."""
-    event = StorageEvent(
-        filepath="recording%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.txt",
-        filetype="text/plain",  # Not included in the default allowed filetypes
-        bucket_name="test-bucket",
-        metadata=None,
-    )
-    with pytest.raises(InvalidFileTypeError):
-        minio_parser.validate(event)
-
-
-@pytest.mark.parametrize(
-    "invalid_filepath",
-    [
-        "invalid_filepath",  # totally invalid string
-        "recordings/46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-        "recordings/46d1a121-2426-484d-8fb3-09b5d886f7a8",  # missing extension
-        "46d1a121-2426-484d-8fb3-09b5d886f7a8",  # missing url_encoded_folder_path and extension
-        "",  # empty string
-        "46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",  # no folder at all
-        "uploads%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",  # wrong folder name
-        "folder%2Fuploads%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",  # nested but no recordings/
-    ],
-)
-def test_minio_validate_invalid_filepath(invalid_filepath, minio_parser):
-    """Test validation with malformed filepath."""
-    event = StorageEvent(
-        filepath=invalid_filepath,
-        filetype="audio/ogg",
-        bucket_name="test-bucket",
-        metadata=None,
-    )
-    with pytest.raises(InvalidFilepathError):
-        minio_parser.validate(event)
-
-
-def test_minio_validate_valid_event(minio_parser):
-    """Test validation with valid event data."""
-    event = StorageEvent(
-        filepath="recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-        filetype="audio/ogg",
-        bucket_name="test-bucket",
-        metadata=None,
-    )
-    recording_id = minio_parser.validate(event)
-    assert recording_id == "46d1a121-2426-484d-8fb3-09b5d886f7a8"
-
-
-def test_minio_get_recording_id_success(minio_parser, valid_minio_event):
-    """Test successful extraction of recording ID."""
-    recording_id = minio_parser.get_recording_id(valid_minio_event)
-    assert recording_id == "46d1a121-2426-484d-8fb3-09b5d886f7a8"
-
-
-def test_minio_validate_filepath_with_folder(minio_parser):
-    """Test validation of filepath with folder structure."""
-    event = StorageEvent(
-        filepath="parent_folder%2Frecordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-        filetype="audio/ogg",
-        bucket_name="test-bucket",
-        metadata=None,
-    )
-    recording_id = minio_parser.validate(event)
-    assert recording_id == "46d1a121-2426-484d-8fb3-09b5d886f7a8"
-
-
-def test_minio_empty_allowed_filetypes():
-    """Test MinioParser with empty allowed_filetypes."""
-    empty_types = set()
-    parser = MinioParser(bucket_name="test-bucket", allowed_filetypes=empty_types)
-    assert parser._allowed_filetypes == {"audio/ogg", "video/mp4"}
-
-
-def test_minio_custom_allowed_filetypes():
-    """Test MinioParser with empty allowed_filetypes."""
-    custom_types = {"audio/mp3", "video/mov"}
-    parser = MinioParser(bucket_name="test-bucket", allowed_filetypes=custom_types)
-    assert parser._allowed_filetypes == {"audio/mp3", "video/mov"}
-
-
-def test_minio_validate_custom_filetypes():
-    """Test validation of filepath with folder structure."""
-
-    parser = MinioParser(bucket_name="test-bucket", allowed_filetypes={"audio/mp3"})
-
-    event = StorageEvent(
-        filepath="parent_folder%2Frecordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-        filetype="audio/mp3",
-        bucket_name="test-bucket",
-        metadata=None,
-    )
-    parser.validate(event)
-
-
-def test_minio_constructor_none_bucket():
-    """Test MinioParser constructor with None bucket name."""
-    with pytest.raises(ValueError, match="Bucket name cannot be None or empty"):
-        MinioParser(bucket_name=None)
-
-
-def test_minio_constructor_empty_bucket():
-    """Test MinioParser constructor with empty bucket name."""
-    with pytest.raises(ValueError, match="Bucket name cannot be None or empty"):
-        MinioParser(bucket_name="")
-
-
-# S3Parser
-
-
-@pytest.fixture
-def valid_s3_event():
-    """Mock a valid S3 event."""
-    return {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": "recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg",
-                    },
-                }
-            }
-        ]
-    }
-
-
-@pytest.fixture
-def s3_parser():
-    """Mock an S3 parser."""
-    return S3Parser(bucket_name="test-bucket")
-
-
-def test_s3_parse_valid_event(s3_parser, valid_s3_event):
-    """Test parsing a valid S3 event."""
-    event = s3_parser.parse(valid_s3_event)
-    assert isinstance(event, StorageEvent)
-    assert event.filepath == "recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.ogg"
-    assert event.filetype == "audio/ogg"
-    assert event.bucket_name == "test-bucket"
-    assert event.metadata is None
-
-
-def test_s3_parse_empty_data(s3_parser):
-    """Test parsing empty S3 event data raises error."""
-    with pytest.raises(ParsingEventDataError, match="Received empty data."):
-        s3_parser.parse({})
-
-
-def test_s3_parse_missing_keys(s3_parser):
-    """Test parsing S3 event with missing key."""
-    invalid_s3_event = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    # Missing 'object' key
-                }
-            }
-        ]
-    }
-
-    with pytest.raises(ParsingEventDataError, match="Malformed S3 event:"):
-        s3_parser.parse(invalid_s3_event)
-
-
-def test_s3_parse_none_key(s3_parser):
-    """Test parsing S3 event with None field."""
-    invalid_s3_event = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": None,
-                    },
-                }
-            }
-        ]
-    }
-
-    with pytest.raises(ParsingEventDataError, match="Missing object key name"):
-        s3_parser.parse(invalid_s3_event)
-
-
-def test_s3_parse_with_video_type(s3_parser):
-    """Test parsing S3 event with mp4 file extension."""
-    video_event = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": "recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.mp4",
-                    },
-                }
-            }
-        ]
-    }
-    event = s3_parser.parse(video_event)
-    assert event.filetype == "video/mp4"
-    assert event.filepath.endswith(".mp4")
-
-
-def test_s3_parse_unrecognized_extension(s3_parser):
-    """Test parsing S3 event with unrecognized file extension."""
-    event_with_unknown_ext = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "test-bucket"},
-                    "object": {
-                        "key": "recordings%2F46d1a121-2426-484d-8fb3-09b5d886f7a8.zzunknown999",
-                    },
-                }
-            }
-        ]
-    }
-
-    with pytest.raises(TypeError, match="filetype cannot be None"):
-        s3_parser.parse(event_with_unknown_ext)
-
-
-def test_s3_parser_keeps_encoded_filepath_compatible(settings):
-    """Test S3 parser keeps already encoded object keys compatible."""
-    settings.RECORDING_OUTPUT_FOLDER = "recordings"
-
-    recording_id = "80ae9fe5-639a-438b-b86e-9e3dd2d55f4d"
-    parser = S3Parser(bucket_name="recordings-bucket")
-
-    data = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "recordings-bucket"},
-                    "object": {
-                        "key": f"recordings%2F{recording_id}.mp4",
-                    },
-                }
-            }
-        ]
-    }
-
-    assert parser.get_recording_id(data) == recording_id
-
-
-def test_s3_parser_accepts_unencoded_filepath(settings):
-    """Test S3 parser accepts raw object keys with slash separators."""
-    settings.RECORDING_OUTPUT_FOLDER = "recordings"
-
-    recording_id = "80ae9fe5-639a-438b-b86e-9e3dd2d55f4d"
-    parser = S3Parser(bucket_name="recordings-bucket")
-
-    data = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "recordings-bucket"},
-                    "object": {
-                        "key": f"recordings/{recording_id}.mp4",
-                    },
-                }
-            }
-        ]
-    }
-
-    assert parser.get_recording_id(data) == recording_id
-
-
-def test_s3_parser_preserves_plus_signs_in_encoded_filepath(settings):
-    """Test S3 parser preserves plus signs in already encoded object keys."""
-    settings.RECORDING_OUTPUT_FOLDER = "recordings"
-
-    recording_id = "80ae9fe5-639a-438b-b86e-9e3dd2d55f4d"
-    parser = S3Parser(bucket_name="recordings-bucket")
-
-    data = {
-        "Records": [
-            {
-                "s3": {
-                    "bucket": {"name": "recordings-bucket"},
-                    "object": {
-                        "key": f"folder+name%2Frecordings%2F{recording_id}.mp4",
-                    },
-                }
-            }
-        ]
-    }
-
-    assert parser.get_recording_id(data) == recording_id
-
-
-def test_s3_get_recording_id_success(s3_parser, valid_s3_event):
-    """Test successful extraction of recording ID from S3 event."""
-    recording_id = s3_parser.get_recording_id(valid_s3_event)
-    assert recording_id == "46d1a121-2426-484d-8fb3-09b5d886f7a8"
-
-
-# get_parser
-
-
-@pytest.fixture
-def clear_lru_cache():
-    """Fixture to clear the LRU cache between tests."""
-    get_parser.cache_clear()
-    yield
-    get_parser.cache_clear()
-
-
-def test_returns_correct_instance(clear_lru_cache):
-    """Test if get_parser returns the correct parser instance."""
-    settings.AWS_STORAGE_BUCKET_NAME = "test-bucket"
-    parser = get_parser()
-    assert isinstance(parser, MinioParser)
-    assert parser._bucket_name == "test-bucket"
-
-
-def test_caching_behavior(clear_lru_cache):
-    """Test if the function properly caches the parser instance."""
-    settings.AWS_STORAGE_BUCKET_NAME = "test-bucket"
-    parser1 = get_parser()
-    parser2 = get_parser()
-    assert parser1 is parser2  # Check object identity
-
-
-def test_different_settings_new_instance():
-    """Test if changing settings creates a new instance."""
-    settings.AWS_STORAGE_BUCKET_NAME = "different-bucket"
-    parser = get_parser()
-    assert parser._bucket_name == "different-bucket"
-
-
-def test_import_error_handling(clear_lru_cache):
-    """Test handling of import errors for invalid parser class."""
-    settings.RECORDING_EVENT_PARSER_CLASS = "invalid.parser.path"
-    with pytest.raises(ImportError):
-        get_parser()
-
-
-@mock.patch("core.recording.event.parsers.import_string")
-def test_parser_instantiation_called_once(mock_import_string, clear_lru_cache):
-    """Test that parser class is instantiated only once due to caching."""
-    mock_parser_cls = type(
-        "MockParser",
-        (),
-        {
-            "__init__": lambda self, bucket_name: setattr(
-                self, "_bucket_name", bucket_name
-            )
-        },
-    )
-    mock_import_string.return_value = mock_parser_cls
-
-    # First call
-    parser1 = get_parser()
-    # Second call
-    parser2 = get_parser()
-
-    # Verify import_string was called only once
-    mock_import_string.assert_called_once_with(settings.RECORDING_EVENT_PARSER_CLASS)
-    assert parser1 is parser2
-
-
-def test_cache_clear_behavior(clear_lru_cache, settings):
-    """Test that cache clearing creates new instance."""
-
-    settings.RECORDING_EVENT_PARSER_CLASS = "core.recording.event.parsers.MinioParser"
-
-    parser1 = get_parser()
-    get_parser.cache_clear()
-    parser2 = get_parser()
-
-    assert parser1 is not parser2  # Should be different instances after cache clear
@@ -12,6 +12,7 @@ from core.factories import RecordingFactory
 from core.recording.services.recording_events import (
    RecordingEventsError,
    RecordingEventsService,
+    RecordingNotSavableError,
 )
 from core.utils import NotificationError

@@ -70,3 +71,56 @@ def test_handle_limit_reached_error(mock_notify, mode, notification_type, servic
    mock_notify.assert_called_once_with(
        room_name=str(recording.room.id), notification_data={"type": notification_type}
    )
+
+
+@pytest.mark.parametrize("status", ["active", "stopped"])
+@pytest.mark.parametrize(
+    ("notify_return_value", "expected_status"),
+    ((True, "notification_succeeded"), (False, "saved")),
+)
+@mock.patch(
+    "core.recording.services.recording_events.notification_service."
+    "notify_external_services"
+)
+def test_handle_complete_saves_recording(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+    mock_notify_external_services,
+    notify_return_value,
+    expected_status,
+    status,
+    service,
+):
+    """Test handle_complete notifies external services and saves a savable recording."""
+
+    mock_notify_external_services.return_value = notify_return_value
+
+    recording = RecordingFactory(status=status)
+    service.handle_complete(recording)
+
+    mock_notify_external_services.assert_called_once_with(recording)
+
+    recording.refresh_from_db()
+    assert recording.status == expected_status
+
+
+@pytest.mark.parametrize(
+    "status",
+    ["initiated", "saved", "notification_succeeded", "aborted", "failed_to_start"],
+)
+@mock.patch(
+    "core.recording.services.recording_events.notification_service."
+    "notify_external_services"
+)
+def test_handle_complete_non_savable_recording(
+    mock_notify_external_services, status, service
+):
+    """Test handle_complete refuses recordings that are already saved or in error."""
+
+    recording = RecordingFactory(status=status)
+
+    with pytest.raises(RecordingNotSavableError):
+        service.handle_complete(recording)
+
+    mock_notify_external_services.assert_not_called()
+
+    recording.refresh_from_db()
+    assert recording.status == status
@@ -1,267 +0,0 @@
-"""
-Test recordings API endpoints in the Meet core app: save recording.
-"""
-
-# pylint: disable=redefined-outer-name,unused-argument
-
-import uuid
-from unittest import mock
-
-import pytest
-from rest_framework.test import APIClient
-
-from ...factories import RecordingFactory
-from ...models import Recording, RecordingStatusChoices
-from ...recording.event.exceptions import (
-    InvalidBucketError,
-    InvalidFilepathError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-
-pytestmark = pytest.mark.django_db
-
-
-@pytest.fixture
-def recording_settings(settings):
-    """Configure recording-related and storage event Django settings."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-    settings.RECORDING_STORAGE_EVENT_ENABLE = True
-    return settings
-
-
-@pytest.fixture
-def mock_get_parser():
-    """Mock 'get_parser' factory function."""
-    with mock.patch("core.api.viewsets.get_parser") as mock_parser:
-        yield mock_parser
-
-
-def test_save_recording_anonymous(settings, client):
-    """Anonymous users should not be allowed to save room recordings."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-
-    RecordingFactory(status="active")
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-    )
-
-    assert response.status_code == 401
-    assert Recording.objects.count() == 1
-
-
-def test_save_recording_wrong_bearer(settings, client):
-    """Requests with incorrect bearer token should be rejected when auth is required."""
-
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer wrongAuthToken",
-    )
-
-    assert response.status_code == 401
-
-
-def test_save_recording_permission_needed(settings, client):
-    """Recordings should not be saved when feature is disabled."""
-
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-    settings.RECORDING_STORAGE_EVENT_ENABLE = False
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 404
-    assert response.json() == {"detail": "Not found."}
-
-
-def test_save_recording_parsing_error(recording_settings, mock_get_parser, client):
-    """Test handling of parsing errors in recording event data."""
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = ParsingEventDataError("Error message")
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {"detail": "Invalid request data."}
-
-
-def test_save_recording_bucket_error(recording_settings, mock_get_parser, client):
-    """Test handling of invalid storage bucket errors in recording event data."""
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = InvalidBucketError("Error message")
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {"detail": "Invalid bucket specified."}
-
-
-def test_save_recording_filetype_error(recording_settings, mock_get_parser):
-    """Test handling of unsupported file types in recording event data."""
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = InvalidFileTypeError(
-        "unsupported '.json'"
-    )
-    mock_get_parser.return_value = mock_parser
-
-    client = APIClient()
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Notification ignored."}
-
-
-def test_save_recording_filepath_error(recording_settings, mock_get_parser):
-    """Test handling of unsupported filepath in recording event data."""
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = InvalidFilepathError(
-        "Invalid filepath structure: parent/folder/recording.jpeg"
-    )
-    mock_get_parser.return_value = mock_parser
-
-    client = APIClient()
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Notification ignored."}
-
-
-def test_save_recording_unknown_recording(recording_settings, mock_get_parser, client):
-    """Test handling of events for non-existent recordings."""
-
-    RecordingFactory(status="active")
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = uuid.uuid4()
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 404
-    assert response.json() == {"detail": "No recording found for this event."}
-
-
-@pytest.mark.parametrize(
-    "status", ["failed_to_start", "aborted", "failed_to_stop", "saved", "initiated"]
-)
-def test_save_recording_non_savable_recording(
-    recording_settings, mock_get_parser, client, status
-):
-    """Test that recordings in non-savable states cannot be saved."""
-
-    recording = RecordingFactory(status=status)
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = recording.id
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {
-        "detail": f"Recording with ID {recording.id} cannot be saved because it is either,"
-        " in an error state or has already been saved."
-    }
-
-
-@pytest.mark.parametrize("status", ["active", "stopped"])
-def test_save_recording_success(recording_settings, mock_get_parser, client, status):
-    """Test successful saving of recordings in valid states."""
-
-    recording = RecordingFactory(status=status)
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = recording.id
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Event processed."}
-
-    recording.refresh_from_db()
-    assert recording.status == RecordingStatusChoices.SAVED
-
-
-@mock.patch(
-    "core.recording.services.recording_events.notification_service."
-    "notify_external_services"
-)
-@pytest.mark.parametrize("notification_succeeded", [True, False])
-def test_save_recording_notifies_external_services(
-    mock_notify_external_services,
-    recording_settings,
-    mock_get_parser,
-    client,
-    notification_succeeded,
-):
-    """External services should be notified when a recording is saved."""
-
-    recording = RecordingFactory(status="active")
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = recording.id
-    mock_get_parser.return_value = mock_parser
-
-    mock_notify_external_services.return_value = notification_succeeded
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Event processed."}
-
-    mock_notify_external_services.assert_called_once_with(recording)
-
-    recording.refresh_from_db()
-    assert recording.status == (
-        RecordingStatusChoices.NOTIFICATION_SUCCEEDED
-        if notification_succeeded
-        else RecordingStatusChoices.SAVED
-    )
@@ -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()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
    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()
+    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
    user = UserFactory()
    client = APIClient()
    client.force_login(user)
@@ -0,0 +1,106 @@
+"""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."}
@@ -75,12 +75,11 @@ def test_initialization(
 )
@mock.patch("core.utils.notify_participants")
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_success(  # noqa: PLR0913, PLR0917 # pylint: disable=too-many-arguments, too-many-positional-arguments
-    mock_update_metadata, mock_notify, mode, notification_type, service, settings
+def test_handle_egress_ended_success(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+    mock_update_metadata, mock_notify, mode, notification_type, service
 ):
    """Should successfully stop recording and notifies all participant."""

-    settings.RECORDING_STORAGE_EVENT_ENABLE = False
    recording = RecordingFactory(worker_id="worker-1", mode=mode, status="active")
    mock_data = mock.MagicMock()
    mock_data.egress_info.egress_id = recording.worker_id
@@ -159,12 +158,11 @@ def test_handle_egress_updated_non_handled(
 )
@mock.patch("core.utils.notify_participants")
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_metadata_update_fails(  # noqa: PLR0913, PLR0917 # pylint: disable=too-many-arguments, too-many-positional-arguments
-    mock_update_metadata, mock_notify, mode, notification_type, service, settings
+def test_handle_egress_ended_metadata_update_fails(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+    mock_update_metadata, mock_notify, mode, notification_type, service
 ):
    """Should successfully stop and save recording when metadata's update fails."""

-    settings.RECORDING_STORAGE_EVENT_ENABLE = False
    recording = RecordingFactory(worker_id="worker-1", mode=mode, status="active")
    mock_data = mock.MagicMock()
    mock_data.egress_info.egress_id = recording.worker_id
@@ -358,12 +356,10 @@ def test_handle_egress_ended_finalizes_recording(  # noqa: PLR0913, PLR0917
    recording_status,
    egress_status,
    service,
-    settings,
 ):  # pylint: disable=too-many-arguments,too-many-positional-arguments
    """Should notify external services and save the recording on egress completion
-    (EGRESS_COMPLETE or EGRESS_LIMIT_REACHED) when RECORDING_STORAGE_EVENT_ENABLE is False.
+    (EGRESS_COMPLETE or EGRESS_LIMIT_REACHED).
    """
-    settings.RECORDING_STORAGE_EVENT_ENABLE = False
    mock_notify_external_services.return_value = notify_return_value

    recording = RecordingFactory(worker_id="worker-1", status="active")
@@ -379,47 +375,6 @@ def test_handle_egress_ended_finalizes_recording(  # noqa: PLR0913, PLR0917
    assert recording.status == recording_status


-@mock.patch(
-    "core.recording.services.recording_events.notification_service."
-    "notify_external_services"
-)
-@mock.patch("core.utils.notify_participants")
-@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-@pytest.mark.parametrize(
-    "egress_status, expected_status",
-    [
-        (EgressStatus.EGRESS_COMPLETE, "active"),
-        (EgressStatus.EGRESS_LIMIT_REACHED, "stopped"),
-    ],
-)
-def test_handle_egress_ended_does_not_finalize_when_webhooks_enabled(  # noqa: PLR0913, PLR0917
-    mock_update_metadata,
-    mock_notify,
-    mock_notify_external_services,
-    egress_status,
-    expected_status,
-    service,
-    settings,
-):  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    """When storage event webhooks are enabled, egress_ended must not finalize the
-    recording: external services are never notified. EGRESS_LIMIT_REACHED still stops
-    the recording, EGRESS_COMPLETE leaves it active.
-    """
-    settings.RECORDING_STORAGE_EVENT_ENABLE = True
-
-    recording = RecordingFactory(worker_id="worker-1", status="active")
-    mock_data = mock.MagicMock()
-    mock_data.egress_info.egress_id = recording.worker_id
-    mock_data.egress_info.status = egress_status
-
-    service._handle_egress_ended(mock_data)
-
-    mock_notify_external_services.assert_not_called()
-
-    recording.refresh_from_db()
-    assert recording.status == expected_status
-
-
@pytest.mark.parametrize(
    "egress_status",
    [
@@ -432,10 +387,9 @@ def test_handle_egress_ended_does_not_finalize_when_webhooks_enabled(  # noqa: P
 )
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_does_not_save_on_wrong_status(
-    mock_update_metadata, egress_status, service, settings
+    mock_update_metadata, egress_status, service
 ):
    """Shouldn't save on invalid status."""
-    settings.RECORDING_STORAGE_EVENT_ENABLE = False

    recording = RecordingFactory(worker_id="worker-1", status="active")
    mock_data = mock.MagicMock()
@@ -453,14 +407,13 @@ def test_handle_egress_ended_does_not_save_on_wrong_status(
 )
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_ignores_non_savable_recording(
-    mock_update_metadata, status, service, settings
+    mock_update_metadata, status, service
 ):
    """Should handle non-savable recordings idempotently without raising.

    'egress_ended' may be redelivered (e.g. for an already-saved recording);
    this must not raise, otherwise the webhook would 500 and LiveKit would retry.
    """
-    settings.RECORDING_STORAGE_EVENT_ENABLE = False

    recording = RecordingFactory(worker_id="worker-1", status=status)
    mock_data = mock.MagicMock()
@@ -854,3 +807,31 @@ 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()
@@ -24,6 +24,7 @@ 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
@@ -578,14 +579,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.keys.return_value = []
+    mock_cache.iter_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.keys.assert_called_once_with(pattern)
+    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
    mock_cache.get_many.assert_not_called()


@@ -594,7 +595,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.keys.return_value = [cache_key]
+    mock_cache.iter_keys.return_value = [cache_key]
    mock_cache.get_many.return_value = {cache_key: participant_dict}

    result = lobby_service.list_waiting_participants(room.id)
@@ -603,7 +604,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.keys.assert_called_once_with(pattern)
+    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
    mock_cache.get_many.assert_called_once_with([cache_key])


@@ -628,7 +629,7 @@ def test_list_waiting_participants_multiple(mock_cache, lobby_service):
        "color": "#654321",
    }

-    mock_cache.keys.return_value = [cache_key1, cache_key2]
+    mock_cache.iter_keys.return_value = [cache_key1, cache_key2]
    mock_cache.get_many.return_value = {
        cache_key1: participant1,
        cache_key2: participant2,
@@ -646,7 +647,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.keys.assert_called_once_with(pattern)
+    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
    mock_cache.get_many.assert_called_once_with([cache_key1, cache_key2])


@@ -655,7 +656,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.keys.return_value = [cache_key]
+    mock_cache.iter_keys.return_value = [cache_key]
    mock_cache.get_many.return_value = {cache_key: {"invalid": "data"}}

    result = lobby_service.list_waiting_participants(room.id)
@@ -680,7 +681,7 @@ def test_list_waiting_participants_partially_corrupted(mock_cache, lobby_service

    corrupted_participant = {"invalid": "data"}

-    mock_cache.keys.return_value = [cache_key1, cache_key2]
+    mock_cache.iter_keys.return_value = [cache_key1, cache_key2]
    mock_cache.get_many.return_value = {
        cache_key1: corrupted_participant,
        cache_key2: valid_participant,
@@ -699,7 +700,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.keys.assert_called_once_with(pattern)
+    mock_cache.iter_keys.assert_called_once_with(pattern, itersize=CACHE_SCAN_ITERSIZE)
    mock_cache.get_many.assert_called_once_with([cache_key1, cache_key2])


@@ -723,7 +724,7 @@ def test_list_waiting_participants_non_waiting(mock_cache, lobby_service):
        "color": "#654321",
    }

-    mock_cache.keys.return_value = [cache_key1, cache_key2]
+    mock_cache.iter_keys.return_value = [cache_key1, cache_key2]
    mock_cache.get_many.return_value = {
        cache_key1: participant1,
        cache_key2: participant2,
@@ -0,0 +1,108 @@
+"""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
@@ -512,3 +512,6 @@ def build_telephony_config():
        "default_country": country,
        "international_phone_number": international,
    }
+
+
+CACHE_SCAN_ITERSIZE = 500
@@ -677,3 +677,7 @@ msgstr "Niederländisch"
 #: meet/settings.py:231
 msgid "German"
 msgstr "Deutsch"
+
+#: meet/settings.py:233
+msgid "Spanish"
+msgstr "Spanisch"
@@ -672,3 +672,7 @@ msgstr "Dutch"
 #: meet/settings.py:231
 msgid "German"
 msgstr "German"
+
+#: meet/settings.py:233
+msgid "Spanish"
+msgstr "Spanish"
@@ -0,0 +1,652 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2026-07-02 10:47+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: core/admin.py:67
+msgid "Personal info"
+msgstr "Datos Personales"
+
+#: core/admin.py:80
+msgid "Permissions"
+msgstr "Permisos"
+
+#: core/admin.py:92
+msgid "Important dates"
+msgstr "Fechas importantes"
+
+#: core/admin.py:206
+msgid "Content"
+msgstr "Contenido"
+
+#: core/admin.py:217
+msgid "Deletion"
+msgstr "Eliminar Salas"
+
+#: core/admin.py:226
+msgid "Derived info"
+msgstr ""
+
+#: core/admin.py:237
+# 'Marcas de tiempo' is a bad translation for spanish
+msgid "Timestamps"
+msgstr "" 
+
+#: core/admin.py:240
+msgid "File preview"
+msgstr "Vista previa"
+
+#: core/admin.py:300 core/admin.py:443
+msgid "No owner"
+msgstr "Sin propietario"
+
+#: core/admin.py:303 core/admin.py:446
+msgid "Multiple owners"
+msgstr "Varios propietarios"
+
+#: core/admin.py:316
+msgid "Resend notification to external service"
+msgstr "Reenviar la notificación al servicio externo"
+
+#: core/admin.py:339
+#, python-format
+msgid "Failed to notify for recording %(id)s"
+msgstr "Error al notificar la grabación %(id)s"
+
+#: core/admin.py:347
+#, python-format
+msgid "Failed to notify for recording %(id)s: %(error)s"
+msgstr "Error al notificar la grabación %(id)s: %(error)s"
+
+#: core/admin.py:355
+#, python-format
+msgid "Successfully sent notifications for %(count)s recording(s)."
+msgstr "Notificaciones enviadas correctamente para %(count)s grabación(es)."
+
+#: core/admin.py:363
+#, python-format
+msgid "Skipped %(count)s expired recording(s)."
+msgstr "Se han omitido %(count)s grabación(es) caducada(s)."
+
+#: core/admin.py:368
+msgid "Mark selected recordings as 'Failed to Stop'"
+msgstr "Marcar las grabaciones seleccionadas como «Error al detener»"
+
+#: core/admin.py:386
+#, python-format
+msgid "%(count)s recording(s) successfully marked as 'Failed to Stop'."
+msgstr "%(count)s grabación(es) marcada(s) correctamente como «Error al detener»."
+
+#: core/admin.py:394
+#, python-format
+msgid "Skipped %(count)s recording(s) with an ineligible status."
+msgstr "Se han omitido %(count)s grabación(es) con un estado no elegible."
+
+#: core/admin.py:510
+msgid "No scopes"
+msgstr ""
+
+#: core/admin.py:512
+msgid "Scopes"
+msgstr "Ámbitos"
+
+#: core/api/filters.py:25
+msgid "Creator is me"
+msgstr "Yo soy el creador"
+
+#: core/api/serializers.py:89
+msgid "You must be administrator or owner of a room to add accesses to it."
+msgstr "Debes ser administrador o propietario de una reunión para añadirle accesos."
+
+#: core/api/serializers.py:534
+msgid "This file extension is not allowed."
+msgstr "Esta extensión de archivo no está permitida."
+
+#: core/api/viewsets.py:1222
+msgid "You have reached the maximum number of files for this type."
+msgstr "Has alcanzado el número máximo de archivos de este tipo."
+
+#: core/models.py:37
+msgid "Member"
+msgstr "Miembro"
+
+#: core/models.py:38
+msgid "Administrator"
+msgstr "Administrador"
+
+#: core/models.py:39
+msgid "Owner"
+msgstr "Propietario"
+
+#: core/models.py:55
+# To check here and following lines for gender agreement (Masculine/Feminine)
+msgid "Initiated"
+msgstr "Iniciada"
+
+#: core/models.py:56
+msgid "Active"
+msgstr "Activa"
+
+#: core/models.py:57
+msgid "Stopped"
+msgstr "Detenida"
+
+#: core/models.py:58
+msgid "Saved"
+msgstr "Guardada"
+
+#: core/models.py:59
+msgid "Aborted"
+msgstr "Cancelada"
+
+#: core/models.py:60
+msgid "Failed to Start"
+msgstr "Error al iniciar"
+
+#: core/models.py:61
+msgid "Failed to Stop"
+msgstr "Error al detener"
+
+#: core/models.py:62
+msgid "Notification succeeded"
+msgstr "Notificado correctamente"
+
+#: core/models.py:65
+msgid "External process successful"
+msgstr "Proceso externo finalizado correctamente"
+
+#: core/models.py:67
+msgid "External process failed"
+msgstr "Error en el Proceso externo"
+
+#: core/models.py:96
+msgid "SCREEN_RECORDING"
+msgstr "GRABACIÓN_DE_PANTALLA"
+
+#: core/models.py:97
+msgid "TRANSCRIPT"
+msgstr "TRANSCRIPCIÓN"
+
+#: core/models.py:103
+msgid "Public Access"
+msgstr "Acceso público"
+
+#: core/models.py:104
+msgid "Trusted Access"
+msgstr "Acceso usuarios autorizados"
+
+#: core/models.py:105
+msgid "Restricted Access"
+msgstr "Acceso restringido"
+
+#: core/models.py:117
+msgid "id"
+msgstr "id"
+
+#: core/models.py:118
+msgid "primary key for the record as UUID"
+msgstr "clave primaria del registro en forma de UUID"
+
+#: core/models.py:124
+msgid "created on"
+msgstr "creado el"
+
+#: core/models.py:125
+msgid "date and time at which a record was created"
+msgstr "fecha y hora en que se creó un registro"
+
+#: core/models.py:130
+msgid "updated on"
+msgstr "actualizado el"
+
+#: core/models.py:131
+msgid "date and time at which a record was last updated"
+msgstr "fecha y hora de la última actualización de un registro"
+
+#: core/models.py:151
+msgid ""
+"Enter a valid sub. This value may contain only letters, numbers, and @/./+/-/"
+"_ characters."
+msgstr "Introduce un sub válido. Este valor solo puede contener letras, números y los caracteres @/./+/-/_."
+
+#: core/models.py:157
+msgid "sub"
+msgstr "sub"
+
+#: core/models.py:159
+msgid ""
+"Optional for pending users; required upon account activation. 255 characters "
+"or fewer. Letters, numbers, and @/./+/-/_ characters only."
+msgstr "Opcional para los usuarios pendientes; obligatorio al activar la cuenta. 255 caracteres como máximo. Solo letras, números y los caracteres @/./+/-/_."
+
+#: core/models.py:168
+msgid "identity email address"
+msgstr "dirección de correo electrónico"
+
+#: core/models.py:173
+msgid "admin email address"
+msgstr "dirección de correo electrónico de administrador"
+
+#: core/models.py:175
+msgid "full name"
+msgstr "nombre completo"
+
+#: core/models.py:177
+msgid "short name"
+msgstr "nombre corto"
+
+#: core/models.py:183
+msgid "language"
+msgstr "idioma"
+
+#: core/models.py:184
+msgid "The language in which the user wants to see the interface."
+msgstr "El idioma preferido de interfaz."
+
+#: core/models.py:190
+msgid "The timezone in which the user wants to see times."
+msgstr "La zona horaria en la que el usuario quiere ver las horas."
+
+#: core/models.py:193
+msgid "device"
+msgstr "dispositivo"
+
+#: core/models.py:195
+msgid "Whether the user is a device or a real user."
+msgstr "Si el usuario es un dispositivo o un usuario real."
+
+#: core/models.py:198
+msgid "staff status"
+msgstr "estado del personal"
+
+#: core/models.py:200
+msgid "Whether the user can log into this admin site."
+msgstr "Si el usuario puede acceder a este sitio de administración."
+
+#: core/models.py:203
+msgid "active"
+msgstr "activo"
+
+#: core/models.py:206
+msgid ""
+"Whether this user should be treated as active. Unselect this instead of "
+"deleting accounts."
+msgstr "Si este usuario debe considerarse activo. Desmarca esta opción en lugar de eliminar cuentas."
+
+#: core/models.py:219
+msgid "user"
+msgstr "usuario"
+
+#: core/models.py:220
+msgid "users"
+msgstr "usuarios"
+
+#: core/models.py:286
+msgid "Resource"
+msgstr "Recurso"
+
+#: core/models.py:287
+msgid "Resources"
+msgstr "Recursos"
+
+#: core/models.py:345
+msgid "Resource access"
+msgstr "Acceso a recursos"
+
+#: core/models.py:346
+msgid "Resource accesses"
+msgstr "Accesos a recursos"
+
+#: core/models.py:352
+msgid "Resource access with this User and Resource already exists."
+msgstr "Ya existe un acceso al recurso con este usuario y este recurso."
+
+#: core/models.py:409
+msgid "Visio room configuration"
+msgstr "Configuración de la videoconferencia"
+
+#: core/models.py:410
+msgid "Values for Visio parameters to configure the room."
+msgstr "Valores de los parámetros de videoconferencia para configurar la reunión."
+
+#: core/models.py:417
+msgid "Room PIN code"
+msgstr "Código PIN de la reunión"
+
+#: core/models.py:418
+msgid "Unique n-digit code that identifies this room in telephony mode."
+msgstr "Código único de n dígitos que identifica esta reunión en modo telefónico."
+
+#: core/models.py:424 core/models.py:578
+msgid "Room"
+msgstr "Reunión"
+
+#: core/models.py:425
+msgid "Rooms"
+msgstr "Reuniones"
+
+#: core/models.py:589
+msgid "Worker ID"
+msgstr "ID del worker"
+
+#: core/models.py:591
+msgid ""
+"Enter an identifier for the worker recording.This ID is retained even when "
+"the worker stops, allowing for easy tracking."
+msgstr "Introduce un identificador para la grabación del worker. Este identificador se conserva incluso cuando el worker se detiene, lo que permite un seguimiento sencillo."
+
+#: core/models.py:599
+msgid "Recording mode"
+msgstr "Modo de grabación"
+
+#: core/models.py:600
+msgid "Defines the mode of recording being called."
+msgstr "Define el modo de grabación a utilizar."
+
+#: core/models.py:605 core/models.py:606
+msgid "Recording options"
+msgstr "Opciones de grabación"
+
+#: core/models.py:613
+msgid "External Process ID"
+msgstr "ID del proceso externo"
+
+#: core/models.py:614
+msgid "ID of the external process associated with the recording."
+msgstr "ID del proceso externo asociado a la grabación."
+
+#: core/models.py:620
+msgid "Recording"
+msgstr "Grabación"
+
+#: core/models.py:621
+msgid "Recordings"
+msgstr "Grabaciones"
+
+#: core/models.py:731
+msgid "Recording/user relation"
+msgstr "Relación grabación/usuario"
+
+#: core/models.py:732
+msgid "Recording/user relations"
+msgstr "Relaciones grabación/usuario"
+
+#: core/models.py:738
+msgid "This user is already in this recording."
+msgstr "Este usuario ya está en esta grabación."
+
+#: core/models.py:744
+msgid "This team is already in this recording."
+msgstr "Este equipo ya está en esta grabación."
+
+#: core/models.py:750
+msgid "Either user or team must be set, not both."
+msgstr "Debe definirse el usuario o el equipo, pero no ambos."
+
+#: core/models.py:767
+msgid "Create rooms"
+msgstr "Crear reunión"
+
+#: core/models.py:768
+msgid "List rooms"
+msgstr "Listar reuniones"
+
+#: core/models.py:769
+msgid "Retrieve room details"
+msgstr "Ver los detalles de una reunión"
+
+#: core/models.py:770
+msgid "Update rooms"
+msgstr "Actualizar las reuniones"
+
+#: core/models.py:771
+msgid "Delete rooms"
+msgstr "Eliminar las reuniones"
+
+#: core/models.py:784
+msgid "Application name"
+msgstr "Nombre de la aplicación"
+
+#: core/models.py:785
+msgid "Descriptive name for this application."
+msgstr "Nombre descriptivo de esta aplicación."
+
+#: core/models.py:795
+msgid "Hashed on Save. Copy it now if this is a new secret."
+msgstr "Se cifra al guardar. Cópialo ahora si se trata de un secreto nuevo."
+
+#: core/models.py:806
+msgid "Application"
+msgstr "Aplicación"
+
+#: core/models.py:807
+msgid "Applications"
+msgstr "Aplicaciones"
+
+#: core/models.py:830
+msgid "Enter a valid domain"
+msgstr "Introduce un dominio válido"
+
+#: core/models.py:833
+msgid "Domain"
+msgstr "Dominio"
+
+#: core/models.py:834
+msgid "Email domain this application can act on behalf of."
+msgstr "Dominio de correo electrónico en cuyo nombre puede actuar esta aplicación."
+
+#: core/models.py:846
+msgid "Application domain"
+msgstr "Dominio de aplicación"
+
+#: core/models.py:847
+msgid "Application domains"
+msgstr "Dominios de aplicación"
+
+#: core/models.py:865
+msgid "Pending"
+msgstr "Pendiente"
+
+#: core/models.py:866
+msgid "Analyzing"
+msgstr "Analizando"
+
+#: core/models.py:873
+msgid "Ready"
+msgstr "Listo"
+
+#: core/models.py:879
+msgid "Background image"
+msgstr "Imagen de fondo"
+
+#: core/models.py:891
+msgid "title"
+msgstr "título"
+
+#: core/models.py:915
+msgid "Malware detection info when the analysis status is unsafe."
+msgstr "Información sobre la detección de malware cuando el estado del análisis no es seguro."
+
+#: core/models.py:920
+msgid "File"
+msgstr "Archivo"
+
+#: core/models.py:921
+msgid "Files"
+msgstr "Archivos"
+
+#: core/models.py:1041
+msgid "This file is already hard deleted."
+msgstr "Este archivo ya se ha eliminado definitivamente."
+
+#: core/models.py:1051
+msgid "To hard delete a file, it must first be soft deleted."
+msgstr "Para eliminar definitivamente un archivo, primero debe haberse marcado como eliminado."
+
+#: core/recording/event/notification.py:123
+msgid "Your recording is ready"
+msgstr "Tu grabación está lista"
+
+#: core/recording/event/notification.py:194
+msgid "Transcription"
+msgstr "Transcripción"
+
+#: core/recording/event/notification.py:204
+#, python-brace-format
+msgid "Meeting \"{room}\" on {room_recording_date} at {room_recording_time}"
+msgstr "Reunión \"{room}\" del {room_recording_date} a las {room_recording_time}"
+
+#: core/services/invitation.py:44
+#, python-brace-format
+msgid "Video call in progress: {sender.email} is waiting for you to connect"
+msgstr "Videollamada en curso: {sender.email} está esperando a que te conectes"
+
+#: core/templates/mail/html/invitation.html:159
+#: core/templates/mail/html/screen_recording.html:159
+#: core/templates/mail/text/invitation.txt:3
+#: core/templates/mail/text/screen_recording.txt:3
+msgid "Logo email"
+msgstr "Logotipo del correo"
+
+#: core/templates/mail/html/invitation.html:189
+#: core/templates/mail/text/invitation.txt:5
+msgid "invites you to join an ongoing video call"
+msgstr "te invita a unirte a una videollamada en curso"
+
+#: core/templates/mail/html/invitation.html:200
+#: core/templates/mail/text/invitation.txt:7
+msgid "JOIN THE CALL"
+msgstr "UNIRSE A LA LLAMADA"
+
+#: core/templates/mail/html/invitation.html:227
+#: core/templates/mail/text/invitation.txt:13
+msgid ""
+"If you can't click the button, copy and paste the URL into your browser to "
+"join the call."
+msgstr "Si no puedes hacer clic en el botón, copia y pega la URL en tu navegador para unirte a la llamada."
+
+#: core/templates/mail/html/invitation.html:235
+#: core/templates/mail/text/invitation.txt:15
+msgid "Tips for a better experience:"
+msgstr "Consejos para una mejor experiencia:"
+
+#: core/templates/mail/html/invitation.html:237
+#: core/templates/mail/text/invitation.txt:17
+msgid "Use Chrome or Firefox for better call quality"
+msgstr "Usa Chrome o Firefox para una mejor calidad de llamada"
+
+#: core/templates/mail/html/invitation.html:238
+#: core/templates/mail/text/invitation.txt:18
+msgid "Test your microphone and camera before joining"
+msgstr "Prueba tu micrófono y tu cámara antes de unirte"
+
+#: core/templates/mail/html/invitation.html:239
+#: core/templates/mail/text/invitation.txt:19
+msgid "Make sure you have a stable internet connection"
+msgstr "Asegúrate de tener una conexión a internet estable"
+
+#: core/templates/mail/html/invitation.html:248
+#: core/templates/mail/html/screen_recording.html:245
+#: core/templates/mail/text/invitation.txt:21
+#: core/templates/mail/text/screen_recording.txt:23
+#, python-format
+msgid " Thank you for using %(brandname)s. "
+msgstr " Gracias por usar %(brandname)s. "
+
+#: core/templates/mail/html/screen_recording.html:188
+#: core/templates/mail/text/screen_recording.txt:6
+msgid "Your recording is ready!"
+msgstr "¡Tu grabación está lista!"
+
+#: core/templates/mail/html/screen_recording.html:195
+#: core/templates/mail/text/screen_recording.txt:8
+#, python-format
+msgid ""
+" Your recording of \"%(room_name)s\" on %(recording_date)s at "
+"%(recording_time)s is now ready to download. "
+msgstr " Tu grabación de \"%(room_name)s\" del %(recording_date)s a las %(recording_time)s ya está lista para descargar. "
+
+#: core/templates/mail/html/screen_recording.html:195
+#: core/templates/mail/text/screen_recording.txt:8
+#, python-format
+msgid " The recording will expire in %(days)s days. "
+msgstr " La grabación caducará dentro de %(days)s días. "
+
+#: core/templates/mail/html/screen_recording.html:200
+#: core/templates/mail/text/screen_recording.txt:9
+msgid ""
+" Sharing the recording via link is not yet available. Only organizers can "
+"download it. "
+msgstr " Compartir la grabación mediante un enlace todavía no está disponible. Solo los organizadores pueden descargarla. "
+
+#: core/templates/mail/html/screen_recording.html:206
+#: core/templates/mail/text/screen_recording.txt:11
+msgid "To keep this recording permanently:"
+msgstr "Para conservar esta grabación de forma permanente:"
+
+#: core/templates/mail/html/screen_recording.html:208
+#, python-format
+msgid "Click the \"<a href=\"%(link)s\">Open</a>\" link below "
+msgstr "Haz clic en el enlace \"<a href=\"%(link)s\">Abrir</a>\" que aparece abajo "
+
+#: core/templates/mail/html/screen_recording.html:209
+#: core/templates/mail/text/screen_recording.txt:14
+msgid "Use the \"Download\" button in the interface "
+msgstr "Usa el botón \"Descargar\" de la interfaz "
+
+#: core/templates/mail/html/screen_recording.html:210
+#: core/templates/mail/text/screen_recording.txt:15
+msgid "Save the file to your preferred location"
+msgstr "Guarda el archivo en la ubicación que prefieras"
+
+#: core/templates/mail/html/screen_recording.html:221
+#: core/templates/mail/text/screen_recording.txt:17
+msgid "Open"
+msgstr "Abrir"
+
+#: core/templates/mail/html/screen_recording.html:230
+#: core/templates/mail/text/screen_recording.txt:19
+#, python-format
+msgid ""
+" If you have any questions or need assistance, please contact our support "
+"team at %(support_email)s. "
+msgstr " Si tienes alguna pregunta o necesitas ayuda, ponte en contacto con nuestro equipo de soporte en %(support_email)s. "
+
+#: core/templates/mail/text/screen_recording.txt:13
+#, python-format
+msgid "Click the \"Open [%(link)s]\" link below "
+msgstr "Haz clic en el enlace \"Abrir [%(link)s]\" que aparece abajo "
+
+#: meet/settings.py:228
+msgid "English"
+msgstr "Inglés"
+
+#: meet/settings.py:229
+msgid "French"
+msgstr "Francés"
+
+#: meet/settings.py:230
+msgid "Dutch"
+msgstr "Neerlandés"
+
+#: meet/settings.py:231
+msgid "German"
+msgstr "Alemán"
+
+#: meet/settings.py:233
+msgid "Spanish"
+msgstr "Español"
@@ -678,3 +678,7 @@ msgstr "Néerlandais"
 #: meet/settings.py:231
 msgid "German"
 msgstr "Allemand"
+
+#: meet/settings.py:233
+msgid "Spanish"
+msgstr "Espagnol"
@@ -672,3 +672,7 @@ msgstr "Nederlands"
 #: meet/settings.py:231
 msgid "German"
 msgstr "Duits"
+
+#: meet/settings.py:233
+msgid "Spanish"
+msgstr "Spaans"
@@ -230,6 +230,7 @@ class Base(Configuration):
            ("fr-fr", _("French")),
            ("nl-nl", _("Dutch")),
            ("de-de", _("German")),
+            ("es-es", _("Spanish")),
        )
    )

@@ -729,20 +730,6 @@ class Base(Configuration):
        environ_name="RECORDING_WORKER_CLASSES",
        environ_prefix=None,
    )
-    RECORDING_EVENT_PARSER_CLASS = values.Value(
-        "core.recording.event.parsers.MinioParser",
-        environ_name="RECORDING_EVENT_PARSER_CLASS",
-        environ_prefix=None,
-    )
-    RECORDING_ENABLE_STORAGE_EVENT_AUTH = values.BooleanValue(
-        True, environ_name="RECORDING_ENABLE_STORAGE_EVENT_AUTH", environ_prefix=None
-    )
-    RECORDING_STORAGE_EVENT_ENABLE = values.BooleanValue(
-        False, environ_name="RECORDING_STORAGE_EVENT_ENABLE", environ_prefix=None
-    )
-    RECORDING_STORAGE_EVENT_TOKEN = SecretFileValue(
-        None, environ_name="RECORDING_STORAGE_EVENT_TOKEN", environ_prefix=None
-    )
    # Number of days before recordings expire - must be synced with bucket lifecycle policy
    # Set to None for no expiration
    RECORDING_EXPIRATION_DAYS = values.IntegerValue(
@@ -856,6 +843,15 @@ 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
    )
@@ -7,7 +7,7 @@ build-backend = "uv_build"

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

 [[package]]
 name = "meet"
-version = "1.27.0"
+version = "1.29.0"
 source = { editable = "." }
 dependencies = [
    { name = "aiohttp" },
@@ -3,6 +3,6 @@
  "input": ["src/**/*.{ts,tsx}", "!src/styled-system/**/*", "!src/**/*.d.ts"],
  "output": "src/locales/$LOCALE/$NAMESPACE.json",
  "createOldCatalogs": false,
-  "locales": ["en", "fr", "de", "nl"],
+  "locales": ["en", "fr", "de", "nl", "es"],
  "sort": true
 }
@@ -1,25 +1,25 @@
 {
  "name": "meet",
-  "version": "1.27.0",
+  "version": "1.29.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "meet",
-      "version": "1.27.0",
+      "version": "1.29.0",
      "dependencies": {
-        "@fontsource-variable/atkinson-hyperlegible-next": "5.2.6",
-        "@fontsource-variable/lexend": "5.2.11",
+        "@fontsource-variable/atkinson-hyperlegible-next": "5.3.0",
+        "@fontsource-variable/lexend": "5.3.0",
        "@fontsource/opendyslexic": "5.2.5",
        "@libreaudio/la-call": "0.1.4",
        "@livekit/components-react": "2.9.23",
        "@livekit/components-styles": "1.2.0",
        "@livekit/track-processors": "0.7.2",
        "@mediapipe/tasks-vision": "0.10.14",
-        "@pandacss/preset-panda": "1.11.3",
+        "@pandacss/preset-panda": "1.12.0",
        "@react-types/overlays": "3.10.0",
        "@remixicon/react": "4.9.0",
-        "@tanstack/react-query": "5.101.1",
+        "@tanstack/react-query": "5.101.4",
        "@timephy/rnnoise-wasm": "1.0.0",
        "crisp-sdk-web": "1.1.2",
        "hoofd": "1.7.3",
@@ -27,9 +27,9 @@
        "i18next": "26.3.6",
        "i18next-browser-languagedetector": "8.2.1",
        "i18next-parser": "9.4.0",
-        "i18next-resources-to-backend": "1.2.1",
+        "i18next-resources-to-backend": "1.2.3",
        "livekit-client": "2.21.0",
-        "posthog-js": "1.404.1",
+        "posthog-js": "1.414.0",
        "react": "18.3.1",
        "react-aria": "3.50.0",
        "react-aria-components": "1.19.0",
@@ -767,18 +767,18 @@
      "license": "MIT"
    },
    "node_modules/@fontsource-variable/atkinson-hyperlegible-next": {
-      "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==",
+      "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==",
      "license": "OFL-1.1",
      "funding": {
        "url": "https://github.com/sponsors/ayuhito"
      }
    },
    "node_modules/@fontsource-variable/lexend": {
-      "version": "5.2.11",
-      "resolved": "https://registry.npmjs.org/@fontsource-variable/lexend/-/lexend-5.2.11.tgz",
-      "integrity": "sha512-0hgEQ4O7Nh8fxL/WWmspJf0BErbocRkZwtLRGey/V4mUUqxfF7QUwqhcdzwpjom3NYCniY4uzQ5wYD7r9/92tQ==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/lexend/-/lexend-5.3.0.tgz",
+      "integrity": "sha512-3SXtiZ8rFbT0oaPzEboCG5RM3jtyhpNxandh1jWNLqvrJRfV/eP3R+GGw+o5e3hS1uqmAGutKxSvaWG5oyrimA==",
      "license": "OFL-1.1",
      "funding": {
        "url": "https://github.com/sponsors/ayuhito"
@@ -1642,21 +1642,21 @@
      }
    },
    "node_modules/@pandacss/preset-panda": {
-      "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==",
+      "version": "1.12.0",
+      "resolved": "https://registry.npmjs.org/@pandacss/preset-panda/-/preset-panda-1.12.0.tgz",
+      "integrity": "sha512-jhzhAmtGY34b1FlMJGEAh/IkfU4WyTNT2mpJfcBUPBi1rZLHSTcs0aqedRmMdwM4tTT43XFOXMiazbztKME60A==",
      "license": "MIT",
      "dependencies": {
-        "@pandacss/types": "1.11.3"
+        "@pandacss/types": "1.12.0"
      },
      "engines": {
        "node": ">=20"
      }
    },
    "node_modules/@pandacss/preset-panda/node_modules/@pandacss/types": {
-      "version": "1.11.3",
-      "resolved": "https://registry.npmjs.org/@pandacss/types/-/types-1.11.3.tgz",
-      "integrity": "sha512-tUbxa3WzoCuulP6kcMn7f0uNgLBvu81JAg4sfoUpz6PZE36VHA3k9n6ROEwziTbr7vqgeCj5DYQCUldrVNbEGQ==",
+      "version": "1.12.0",
+      "resolved": "https://registry.npmjs.org/@pandacss/types/-/types-1.12.0.tgz",
+      "integrity": "sha512-PtlEIOBEV3RzWffeu1zH+/YFmP+fn24M63STGEbgTwjEBMhyo/FfT2sfZGB8oWAbWUBKBp69OMg25E+/rY3klQ==",
      "license": "MIT",
      "engines": {
        "node": ">=20"
@@ -1719,19 +1719,29 @@
      "dev": true,
      "license": "MIT"
    },
-    "node_modules/@posthog/core": {
-      "version": "1.48.3",
-      "resolved": "https://registry.npmjs.org/@posthog/core/-/core-1.48.3.tgz",
-      "integrity": "sha512-kwVDVvwtCTXctApA2tpnwDjDDan8LrkwCW1Wv6PABaVs/s5ahbQ9W3pvdXcqr71HCuqukSA1jp7MySczebubGg==",
+    "node_modules/@posthog/browser-common": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@posthog/browser-common/-/browser-common-0.4.0.tgz",
+      "integrity": "sha512-W9DCGVks15docUMPvJ2nd8NS16Gn74bsGWuaeg31beEKFSjdW8wvnQ1ETY6WSql5pYxZb3GdJmEUZVVstKSrBQ==",
      "license": "MIT",
      "dependencies": {
-        "@posthog/types": "^1.405.0"
+        "@posthog/core": "^1.46.8",
+        "@posthog/types": "^1.402.0"
+      }
+    },
+    "node_modules/@posthog/core": {
+      "version": "1.49.1",
+      "resolved": "https://registry.npmjs.org/@posthog/core/-/core-1.49.1.tgz",
+      "integrity": "sha512-jdZh85tG56OXLH881CVwBZyiXCPPaZasfYeWwm9kVUvxC/Rb+lz7wYN9GuqSEmNPJgVnK4v8wS0bCaFc3OmVEA==",
+      "license": "MIT",
+      "dependencies": {
+        "@posthog/types": "^1.407.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.407.1",
+      "resolved": "https://registry.npmjs.org/@posthog/types/-/types-1.407.1.tgz",
+      "integrity": "sha512-WhbkXPC2rgylXqmxHqv70ffI3k+KxyR6s7DBIfr5NvIqHkxp6v0pk31D/jbz0DNVbzwkLjyll2pxr4FNbJiYzg==",
      "license": "MIT"
    },
    "node_modules/@react-aria/overlays": {
@@ -2414,9 +2424,9 @@
      }
    },
    "node_modules/@tanstack/query-core": {
-      "version": "5.101.1",
-      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.101.1.tgz",
-      "integrity": "sha512-Y6Y92dkXtNqx67m2pMSxUsA3zOCwv862JexZRP8/EPwvKXMPu9m8rv43spiXWzOUIggQ3SQApttALStzhA8B4g==",
+      "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==",
      "license": "MIT",
      "funding": {
        "type": "github",
@@ -2435,12 +2445,12 @@
      }
    },
    "node_modules/@tanstack/react-query": {
-      "version": "5.101.1",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.101.1.tgz",
-      "integrity": "sha512-ZnONUuQKJe1bJMStXUL1s5uKN9FcfC28j5cK+iDZcdSHtUv1wtin1cGc/Oewhf2Oc4eKY7lggtpvT/AbMmhHew==",
+      "version": "5.101.4",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.101.4.tgz",
+      "integrity": "sha512-yRg2pfOCxIs4ZJW3XYYHU/WgtD04FHSnfHlpRT7h7pR77hwkdRG4wxbKe4aq6P0RvXUTBSQpQeadS1SUYUe+KA==",
      "license": "MIT",
      "dependencies": {
-        "@tanstack/query-core": "5.101.1"
+        "@tanstack/query-core": "5.101.4"
      },
      "funding": {
        "type": "github",
@@ -4784,13 +4794,10 @@
      }
    },
    "node_modules/dompurify": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.2.tgz",
-      "integrity": "sha512-6obghkliLdmKa56xdbLOpUZ43pAR6xFy1uOrxBaIDjT+yaRuuybLjGS9eVBoSR/UPU5fq3OXClEHLJNGvbxKpQ==",
+      "version": "3.4.14",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.14.tgz",
+      "integrity": "sha512-dVoH9z+MY+C9IilgGCk3YfFqjLi3fChm2OiKJMzh6axrJ5qwxqWaZamgmHrpv22CN/KdbZJuGEGgfQoL00LTdg==",
      "license": "(MPL-2.0 OR Apache-2.0)",
-      "engines": {
-        "node": ">=20"
-      },
      "optionalDependencies": {
        "@types/trusted-types": "^2.0.7"
      }
@@ -6975,9 +6982,10 @@
      }
    },
    "node_modules/i18next-resources-to-backend": {
-      "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==",
+      "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",
      "dependencies": {
        "@babel/runtime": "^7.23.2"
      }
@@ -9123,19 +9131,21 @@
      "license": "MIT"
    },
    "node_modules/posthog-js": {
-      "version": "1.404.1",
-      "resolved": "https://registry.npmjs.org/posthog-js/-/posthog-js-1.404.1.tgz",
-      "integrity": "sha512-ck/HOMKuZ6yefUk5OX+h2s9mUWBsnu0mGDUAWjIwAmQQrloZPShzOhOWuEuZQuMnCKORBFRVGsBAuzsl66cBJA==",
+      "version": "1.414.0",
+      "resolved": "https://registry.npmjs.org/posthog-js/-/posthog-js-1.414.0.tgz",
+      "integrity": "sha512-dtZd4asdskr8lNyltAEX6zyn48uO1pO0EMvx6AXJU65PFhu6yn2LPbKtQcyLysjcN57FJPNT9QYL6St5SBJHqw==",
      "license": "(Apache-2.0 AND MIT)",
      "dependencies": {
-        "@posthog/core": "^1.43.1",
-        "@posthog/types": "^1.397.0",
+        "@posthog/browser-common": "^0.4.0",
+        "@posthog/core": "^1.46.9",
+        "@posthog/types": "^1.402.2",
        "core-js": "^3.49.0",
-        "dompurify": "^3.3.2",
+        "dompurify": "^3.4.12",
        "fflate": "^0.4.8",
        "preact": "^10.29.3",
        "query-selector-shadow-dom": "^1.0.1",
-        "web-vitals": "^5.3.0"
+        "web-vitals": "^5.3.0",
+        "web-vitals-soft-navs": "npm:web-vitals@6.0.0"
      }
    },
    "node_modules/powershell-utils": {
@@ -11647,6 +11657,13 @@
      "integrity": "sha512-q6LWsLatGYZp5VGBIOvbTj6JBV2nOmC8KvWztXBmwJcfFAzhwKwbOxhUH306XY3CcaZDUlSmSuNPBsCn0bFu+g==",
      "license": "Apache-2.0"
    },
+    "node_modules/web-vitals-soft-navs": {
+      "name": "web-vitals",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-6.0.0.tgz",
+      "integrity": "sha512-Guaibvy/+uNtL6Bsu4jmMJGzuSl91oeRH5iO9pPRbYftnFUr3yqT1TUNX/OE4o9HexuEMU3Kb/Wg7iKhlffZUA==",
+      "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",
@@ -1,7 +1,7 @@
 {
  "name": "meet",
  "private": true,
-  "version": "1.27.0",
+  "version": "1.29.0",
  "type": "module",
  "scripts": {
    "dev": "panda codegen && vite",
@@ -15,18 +15,18 @@
    "check": "prettier --check ./src"
  },
  "dependencies": {
-    "@fontsource-variable/atkinson-hyperlegible-next": "5.2.6",
-    "@fontsource-variable/lexend": "5.2.11",
+    "@fontsource-variable/atkinson-hyperlegible-next": "5.3.0",
+    "@fontsource-variable/lexend": "5.3.0",
    "@fontsource/opendyslexic": "5.2.5",
    "@libreaudio/la-call": "0.1.4",
    "@livekit/components-react": "2.9.23",
    "@livekit/components-styles": "1.2.0",
    "@livekit/track-processors": "0.7.2",
    "@mediapipe/tasks-vision": "0.10.14",
-    "@pandacss/preset-panda": "1.11.3",
+    "@pandacss/preset-panda": "1.12.0",
    "@react-types/overlays": "3.10.0",
    "@remixicon/react": "4.9.0",
-    "@tanstack/react-query": "5.101.1",
+    "@tanstack/react-query": "5.101.4",
    "@timephy/rnnoise-wasm": "1.0.0",
    "crisp-sdk-web": "1.1.2",
    "hoofd": "1.7.3",
@@ -34,9 +34,9 @@
    "i18next": "26.3.6",
    "i18next-browser-languagedetector": "8.2.1",
    "i18next-parser": "9.4.0",
-    "i18next-resources-to-backend": "1.2.1",
+    "i18next-resources-to-backend": "1.2.3",
    "livekit-client": "2.21.0",
-    "posthog-js": "1.404.1",
+    "posthog-js": "1.414.0",
    "react": "18.3.1",
    "react-aria": "3.50.0",
    "react-aria-components": "1.19.0",
@@ -2,6 +2,12 @@ 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 =>
@@ -21,7 +21,9 @@ const StyledContainer = styled('div', {
 })

 export const ChatTextArea = () => {
-  const { isSending, send, textAreaValue } = useSnapshot(chatStore)
+  const { isSending, send, textAreaValue } = useSnapshot(chatStore, {
+    sync: true,
+  })

  const { t } = useTranslation('rooms', { keyPrefix: 'controls.chat.input' })

@@ -13,7 +13,7 @@ const controlBarRegion = cva({
    mobile: {
      true: {
        justifyContent: 'center',
-        width: '330px',
+        width: '100%',
      },
    },
  },
@@ -1,61 +1,31 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { useRoomContext } from '@livekit/components-react'
-import { RoomEvent } from 'livekit-client'
+import { useMemo } from 'react'
+
 import { useRoomData } from '@/features/rooms/livekit/hooks/useRoomData'
-import { useIsAdminOrOwner } from '@/features/rooms/livekit/hooks/useIsAdminOrOwner'
+import { useCanManageLobby } from '@/features/rooms/livekit/hooks/useCanManageLobby'
 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 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 canManageLobby = useCanManageLobby()

  const { data: waitingData, refetch: refetchWaiting } =
    useListWaitingParticipants(roomId, {
      retry: false,
-      enabled: listEnabled && isAdminOrOwner,
-      refetchInterval: POLL_INTERVAL_MS,
-      refetchIntervalInBackground: true,
+      enabled: false,
    })

  const waitingParticipants = useMemo(
-    () => waitingData?.participants || [],
-    [waitingData]
+    () => (canManageLobby ? waitingData?.participants || [] : []),
+    [waitingData, canManageLobby]
  )

-  useEffect(() => {
-    if (!waitingParticipants.length) setListEnabled(false)
-  }, [waitingParticipants])
-
  const { mutateAsync: enterRoom } = useEnterRoom()

  const handleParticipantEntry = async (
@@ -74,8 +44,6 @@ export const useWaitingParticipants = () => {
    allowEntry: boolean
  ): Promise<void> => {
    try {
-      setListEnabled(false)
-
      await Promise.all(
        waitingParticipants.map((participant) =>
          enterRoom({
@@ -89,7 +57,6 @@ export const useWaitingParticipants = () => {
      await refetchWaiting()
    } catch (e) {
      reportError('generic_failure', e)
-      setListEnabled(true)
    }
  }

@@ -1,4 +1,3 @@
-import { useCallback } from 'react'
 import { useTranslation } from 'react-i18next'
 import { RiEmotionLine } from '@remixicon/react'
 import { ToggleButton } from '@/primitives'
@@ -7,6 +6,8 @@ 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
@@ -17,35 +18,44 @@ const focusReactionsToolbar = () => {

 export const REACTIONS_TOGGLE_ID = 'reactions-toggle'

-export const ReactionsToggle = () => {
+/* 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) => {
  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: handleShortcut,
+    handler: reactionShortcutHandler,
  })

  return (
    <ToggleButton
+      {...props}
      id={REACTIONS_TOGGLE_ID}
      data-attr="reactions-toggle"
      square
-      variant="primaryDark"
+      variant={variant}
      aria-label={t('button')}
      aria-expanded={isOpen}
      tooltip={t('button')}
      isSelected={isOpen}
      onChange={toggle}
+      onPress={onPress}
    >
      <RiEmotionLine />
    </ToggleButton>
@@ -43,6 +43,7 @@ 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,
@@ -115,6 +116,7 @@ export const Conference = ({
      },
      audioCaptureDefaults: {
        deviceId: userConfig.audioDeviceId ?? undefined,
+        ...VOICE_AUDIO_CONSTRAINTS,
      },
      audioOutput: {
        deviceId: userConfig.audioOutputDeviceId ?? undefined,
@@ -0,0 +1,114 @@
+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
+}
@@ -15,7 +15,8 @@ const Card = styled('div', {
    marginTop: '1.5rem',
    borderRadius: '0.25rem',
    boxShadow: '',
-    minWidth: '380px',
+    width: '100%',
+    maxWidth: '380px',
    minHeight: '196px',
  },
 })
@@ -37,8 +38,11 @@ const ratingButtonRecipe = cva({
    color: 'initial',
    border: 'none',
    borderRadius: 0,
-    padding: '0.5rem 0.85rem',
+    padding: { base: '0.5rem 0.25rem', xsm: '0.5rem 0.85rem' },
    flexGrow: '1',
+    flexBasis: 0,
+    minWidth: 0,
+    textAlign: 'center',
    cursor: 'pointer',
  },
  variants: {
@@ -99,7 +103,9 @@ const OpenFeedback = ({

  return (
    <Card>
-      <H lvl={3}>{t('question')}</H>
+      <H lvl={3} centered>
+        {t('question')}
+      </H>
      <TextArea
        id="feedbackInput"
        name="feedback"
@@ -168,7 +174,9 @@ const RateQuality = ({

  return (
    <Card>
-      <H lvl={3}>{t('question')}</H>
+      <H lvl={3} centered>
+        {t('question')}
+      </H>
      <Bar>
        {[...Array(maxRating)].map((_, index) => (
          <RACButton
@@ -228,7 +236,9 @@ const ConfirmationMessage = ({ onNext }: { onNext: () => void }) => {
      }}
    >
      <VStack gap={0}>
-        <H lvl={3}>{t('heading')}</H>
+        <H lvl={3} centered>
+          {t('heading')}
+        </H>
        <Text as="p" variant="paragraph" centered>
          {t('body')}
        </Text>
@@ -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 { HStack } from '@/styled-system/jsx'
+import { Stack } from '@/styled-system/jsx'
 import { useEffect, useRef, useState } from 'react'
 import { navigateTo } from '@/navigation/navigateTo'
 import { useScreenReaderAnnounce } from '@/hooks/useScreenReaderAnnounce'
@@ -134,7 +134,11 @@ export const IsIdleDisconnectModal = () => {
            </H>
            <Description />
            <Settings />
-            <HStack marginTop="2rem">
+            <Stack
+              direction={{ base: 'column', xsm: 'row' }}
+              align={{ base: 'stretch', xsm: 'center' }}
+              marginTop="2rem"
+            >
              <Button
                onPress={() => {
                  connectionObserverStore.isIdleDisconnectModalOpen = false
@@ -148,7 +152,7 @@ export const IsIdleDisconnectModal = () => {
              <Button onPress={close} size="sm" variant="primary">
                {t('stayButton')}
              </Button>
-            </HStack>
+            </Stack>
          </div>
        )
      }}
@@ -10,10 +10,18 @@ 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

-export const HandToggle = () => {
+type Props = Pick<NonNullable<ButtonRecipeProps>, 'variant'> & ToggleButtonProps
+
+export const HandToggle = ({
+  variant = 'primaryDark',
+  onPress,
+  ...props
+}: Props) => {
  const { t } = useTranslation('rooms', { keyPrefix: 'controls.hand' })

  const room = useRoomContext()
@@ -74,12 +82,16 @@ export const HandToggle = () => {
      })}
    >
      <ToggleButton
+        {...props}
        square
-        variant="primaryDark"
+        variant={variant}
        aria-label={t(tooltipLabel)}
        tooltip={t(tooltipLabel)}
        isSelected={isHandRaised}
-        onPress={handleToggle}
+        onPress={(e) => {
+          handleToggle()
+          onPress?.(e)
+        }}
        data-attr={`controls-hand-${tooltipLabel}`}
      >
        <RiHand />
@@ -0,0 +1,17 @@
+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
+  )
+}
@@ -18,6 +18,7 @@ import {
  noteDeviceReady,
  onMediaPermissionError,
 } from '../utils/mediaPermissions'
+import { VOICE_AUDIO_CONSTRAINTS } from '../utils/constants'
 import {
  saveAudioInputDeviceId,
  saveAudioInputEnabled,
@@ -27,16 +28,6 @@ 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
-
 // Module-level: effect dependencies, must be referentially stable.
 const disableAudio = () => saveAudioInputEnabled(false)
 const disableVideo = () => saveVideoInputEnabled(false)
@@ -1,7 +1,7 @@
 import { supportsScreenSharing } from '@livekit/components-core'
 import { useTranslation } from 'react-i18next'
 import type { ControlBarAuxProps } from './ControlBar'
-import React from 'react'
+import React, { useLayoutEffect, useRef, useState } from 'react'
 import { css } from '@/styled-system/css'
 import { LeaveButton } from '../../components/controls/LeaveButton'
 import { Track } from 'livekit-client'
@@ -26,7 +26,26 @@ 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 } from '@/features/reactions/components/ReactionsToggle'
+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,
+})

 export function MobileControlBar({
  onDeviceError,
@@ -36,50 +55,107 @@ 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',
        })}
      >
-        <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
+          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>
      </div>
-      <ResponsiveMenu
-        isOpened={isMenuOpened}
-        onClosed={() => setIsMenuOpened(false)}
-      >
+      <ResponsiveMenu isOpened={isMenuOpened} onClosed={closeMenu}>
        <div
          className={css({
            display: 'flex',
@@ -98,6 +174,20 @@ export function MobileControlBar({
              },
            })}
          >
+            {hideReactions && (
+              <ReactionsToggle
+                variant="primaryTextDark"
+                description={true}
+                onPress={closeMenu}
+              />
+            )}
+            {hideHand && (
+              <HandToggle
+                variant="primaryTextDark"
+                description={true}
+                onPress={closeMenu}
+              />
+            )}
            {browserSupportsScreenSharing && (
              <ScreenShareToggle
                onDeviceError={(error) =>
@@ -105,25 +195,16 @@ export function MobileControlBar({
                }
                variant="primaryTextDark"
                description={true}
-                onPress={() => setIsMenuOpened(false)}
+                onPress={closeMenu}
              />
            )}
-            <ChatToggle
-              description={true}
-              onPress={() => setIsMenuOpened(false)}
-            />
-            <ParticipantsToggle
-              description={true}
-              onPress={() => setIsMenuOpened(false)}
-            />
-            <ToolsToggle
-              description={true}
-              onPress={() => setIsMenuOpened(false)}
-            />
+            <ChatToggle description={true} onPress={closeMenu} />
+            <ParticipantsToggle description={true} onPress={closeMenu} />
+            <ToolsToggle description={true} onPress={closeMenu} />
            <Button
              onPress={() => {
                toggleEffects()
-                setIsMenuOpened(false)
+                closeMenu()
              }}
              variant="primaryTextDark"
              aria-label={t('options.items.effects')}
@@ -140,7 +221,7 @@ export function MobileControlBar({
                aria-label={t('options.items.feedback')}
                description={true}
                target="_blank"
-                onPress={() => setIsMenuOpened(false)}
+                onPress={closeMenu}
              >
                <RiMegaphoneLine size={20} />
              </LinkButton>
@@ -148,7 +229,7 @@ export function MobileControlBar({
            <Button
              onPress={() => {
                openSettingsDialog()
-                setIsMenuOpened(false)
+                closeMenu()
              }}
              variant="primaryTextDark"
              aria-label={t('options.items.settings')}
@@ -157,7 +238,7 @@ export function MobileControlBar({
            >
              <RiSettings3Line size={20} />
            </Button>
-            <CameraSwitchButton onPress={() => setIsMenuOpened(false)} />
+            <CameraSwitchButton onPress={closeMenu} />
          </div>
        </div>
      </ResponsiveMenu>
@@ -31,6 +31,7 @@ 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
@@ -120,6 +121,7 @@ export function VideoConference({ ...props }: VideoConferenceProps) {
      <RoomSilentMicDetector />
      <MediaStateObserver />
      <ChatProvider />
+      <LobbyProvider />
      <VideoResolutionSubscription />
      <div
        className="lk-video-conference"
@@ -0,0 +1,9 @@
+export const VOICE_AUDIO_CONSTRAINTS = {
+  noiseSuppression: true,
+  echoCancellation: true,
+  autoGainControl: true,
+  voiceIsolation: false,
+  sampleRate: 48000,
+  channelCount: 1,
+  sampleSize: 16,
+} as const
@@ -1,7 +1,8 @@
 import { useTranslation } from 'react-i18next'
 import { Button } from '@/primitives'
 import { Screen } from '@/layout/Screen'
-import { Center, HStack, styled, VStack } from '@/styled-system/jsx'
+import { Center, Stack, styled, VStack } from '@/styled-system/jsx'
+import { css } from '@/styled-system/css'
 import { Rating } from '@/features/rooms/components/Rating.tsx'
 import { useLocation } from 'wouter'
 import { useMemo } from 'react'
@@ -14,14 +15,18 @@ const Heading = styled('h1', {
    fontStyle: 'normal',
    fontStretch: 'normal',
    fontOpticalSizing: 'auto',
-    fontSize: '2.3rem',
-    lineHeight: '2.5rem',
+    fontSize: { base: '1.75rem', xsm: '2.3rem' },
+    lineHeight: { base: '2.125rem', xsm: '2.5rem' },
    letterSpacing: '0',
-    paddingBottom: '2rem',
+    paddingBottom: { base: '1.5rem', xsm: '2rem' },
    textAlign: 'center',
  },
 })

+const buttonClass = css({
+  width: { base: '100%', xsm: 'auto' },
+})
+
 enum DisconnectReasonKey {
  DuplicateIdentity = 'duplicateIdentity',
  ParticipantRemoved = 'participantRemoved',
@@ -54,19 +59,31 @@ const FeedbackRoute = () => {

  return (
    <Screen layout="centered" footer={false}>
-      <Center>
-        <VStack>
+      <Center width="100%">
+        <VStack width="100%" paddingX="1rem">
          <Heading>{t(`feedback.heading.${reasonKey || 'normal'}`)}</Heading>
-          <HStack>
+          <Stack
+            direction={{ base: 'column', xsm: 'row' }}
+            width={{ base: '100%', xsm: 'auto' }}
+            maxWidth="380px"
+          >
            {showBackButton && (
-              <Button variant="secondary" onPress={() => window.history.back()}>
+              <Button
+                variant="secondary"
+                className={buttonClass}
+                onPress={() => window.history.back()}
+              >
                {t('feedback.back')}
              </Button>
            )}
-            <Button variant="primary" onPress={() => setLocation('/')}>
+            <Button
+              variant="primary"
+              className={buttonClass}
+              onPress={() => setLocation('/')}
+            >
              {t('feedback.home')}
            </Button>
-          </HStack>
+          </Stack>
          <Rating metadata={metadata} />
        </VStack>
      </Center>
@@ -75,15 +75,15 @@ const useTranscriptionState = () => {
    const segment = segments[0]

    setTranscriptionSegments((prevSegments) => {
-      const existingSegmentIds = new Set(prevSegments.map((s) => s.id))
-      if (existingSegmentIds.has(segment.id)) return prevSegments
-      return [
-        ...prevSegments,
-        {
-          participant: participant,
-          ...segment,
-        },
-      ]
+      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
    })
  }

@@ -15,7 +15,7 @@ i18n
  .use(initReactI18next)
  .use(LanguageDetector)
  .init({
-    supportedLngs: ['en', 'fr', 'nl', 'de'],
+    supportedLngs: ['en', 'fr', 'nl', 'de', 'es'],
    fallbackLng,
    ns: i18nDefaultNamespace,
    detection: {
@@ -5,6 +5,7 @@ const languageLabels: Record<string, string> = {
  fr: 'Français',
  de: 'Deutsch',
  nl: 'Nederlands',
+  es: 'Español',
 }

 export const useLanguageLabels = () => {
@@ -0,0 +1,34 @@
+{
+  "accessibility": {
+    "title": "Accesibilidad",
+    "introduction": "<i>Visio</i> se compromete a hacer accesibles sus servicios digitales, de conformidad con el artículo 47 de la ley n.º 2005-102 de 11 de febrero de 2005.",
+    "declaration": {
+      "title": "Declaración de accesibilidad",
+      "date": "Redactada el 4 de diciembre de 2024."
+    },
+    "scope": "Esta declaración de accesibilidad se aplica al sitio visio.numerique.gouv.fr",
+    "complianceStatus": {
+      "title": "Estado de conformidad",
+      "body": "visio.numerique.gouv.fr no es conforme con el RGAA 4.1. El sitio todavía no ha sido auditado. No obstante, el equipo trabaja para crear un sitio accesible para todo el mundo siguiendo las recomendaciones del RGAA."
+    },
+    "improvement": {
+      "title": "Mejora y contacto",
+      "body": "Si no consigues acceder a un contenido o a un servicio, puedes ponerte en contacto con el responsable de lasuite.numerique.gouv.fr para que te oriente hacia una alternativa accesible u obtener el contenido en otro formato.",
+      "contact": {
+        "email": "Correo electrónico: visio@numerique.gouv.fr",
+        "address": "Dirección: DINUM, 20 avenue de Ségur 75007 París"
+      },
+      "response": "Intentamos responder en un plazo de 2 días laborales."
+    },
+    "recourse": {
+      "title": "Vía de recurso",
+      "introduction": "Este procedimiento debe utilizarse en el siguiente caso: has comunicado al responsable del sitio web un defecto de accesibilidad que te impide acceder a un contenido o a uno de los servicios del portal y no has obtenido una respuesta satisfactoria.",
+      "options": {
+        "intro": "Puedes:",
+        "option1": "Escribir un mensaje al Defensor de Derechos",
+        "option2": "Ponerte en contacto con el delegado del Defensor de Derechos de tu región",
+        "option3": "Enviar una carta por correo postal (gratuito, sin sello): </br> Défenseur des droits Libre réponse 71120 75342 Paris CEDEX 07"
+      }
+    }
+  }
+}
@@ -0,0 +1,56 @@
+{
+  "title": "Prueba tu configuración",
+  "runTest": "Iniciar la prueba",
+  "runAgain": "Repetir",
+  "cancel": "Cancelar",
+  "detailsFor": "Detalles del paso {{step}}",
+  "downloadReport": "Descargar el informe",
+  "homeLink": "Prueba tu configuración",
+  "progress": "{{done}}/{{total}}",
+  "progressLabel": "Progreso de la prueba de conexión",
+  "groups": {
+    "local": "Navegador y dispositivos",
+    "network": "Conexión al servidor"
+  },
+  "steps": {
+    "browser": "Navegador",
+    "microphone": "Micrófono",
+    "camera": "Cámara",
+    "devices": "Dispositivos multimedia",
+    "websocket": "WebSocket",
+    "webrtc": "WebRTC",
+    "turn": "TURN",
+    "reconnect": "Reconexión",
+    "selectedCandidate": "Ruta seleccionada",
+    "publishAudio": "Publicación de audio",
+    "publishVideo": "Publicación de vídeo"
+  },
+  "status": {
+    "pending": "En espera",
+    "running": "En curso…",
+    "success": "Correcto",
+    "failed": "Error",
+    "skipped": "Omitido"
+  },
+  "counts": {
+    "passed": "correctas",
+    "failed": "con errores",
+    "skipped": "omitidas"
+  },
+  "summary": {
+    "idle": "Listo para la prueba",
+    "idleHint": "La prueba dura aproximadamente un minuto. Tu cámara y tu micrófono solo se utilizan durante la prueba.",
+    "running": "Prueba en curso…",
+    "runningHint": "Mantén esta página abierta hasta que terminen las comprobaciones.",
+    "passed": "Todo funciona",
+    "passedHint": "Tu navegador, tus dispositivos y tu red están listos para una reunión.",
+    "partial": "Prueba parcial",
+    "partialHint": "Se han omitido algunas comprobaciones. Autoriza el acceso a tu cámara y a tu micrófono para probarlos.",
+    "failed_one": "{{count}} verificación en error",
+    "failed_other": "{{count}} verificaciones en error",
+    "failedHint": "Abre las verificaciones en error para ver el detalle y transmite después el informe a tu servicio informático."
+  },
+  "help": {
+    "firewall": "Si las pruebas de red fallan, comprueba los permisos de tu navegador y las reglas de filtrado de red (WebRTC, WebSocket, TURN) con tu servicio informático."
+  }
+}
@@ -0,0 +1,62 @@
+{
+  "backToHome": "Volver al inicio",
+  "cancel": "Cancelar",
+  "closeDialog": "Cerrar la ventana modal",
+  "error": {
+    "heading": "Se ha producido un error al cargar la página"
+  },
+  "feedback": {
+    "context": "¡Tu opinión es fundamental!",
+    "cta": "Comparte tu opinión - nueva ventana"
+  },
+  "forbidden": {
+    "heading": "Acceso denegado"
+  },
+  "loading": "Cargando…",
+  "loggedInUserTooltip": "Con la sesión iniciada como ",
+  "login": {
+    "buttonLabel": "Iniciar sesión",
+    "proconnectButtonLabel": "Identificarse con ProConnect",
+    "proconnectLinkLabel": "¿Qué es ProConnect? - nueva ventana",
+    "proconnectLink": "¿Qué es ProConnect?"
+  },
+  "logout": "Cerrar sesión",
+  "notFound": {
+    "heading": "Comprueba tu código de reunión",
+    "body": "Comprueba que has introducido el código de reunión correcto en la URL. Ejemplo:"
+  },
+  "selected": "seleccionado",
+  "submit": "Aceptar",
+  "footer": {
+    "links": {
+      "legifrance": "legifrance.gouv.fr",
+      "infogouv": "info.gouv.fr",
+      "servicepublic": "service-public.fr",
+      "datagouv": "data.gouv.fr",
+      "legalsTerms": "Aviso legal",
+      "data": "Datos personales y cookies",
+      "accessibility": "Accesibilidad: no conforme",
+      "connectionTest": "Prueba tu configuración",
+      "ariaLabel": "nueva ventana",
+      "codeAnnotation": "Nuestro código es abierto y está disponible en este",
+      "code": "repositorio de código abierto",
+      "technicalDetails": "Ficha técnica",
+      "termsOfService": "Condiciones de uso"
+    },
+    "mentions": "Salvo que se indique lo contrario, los contenidos de este sitio están disponibles bajo",
+    "license": "licencia etalab 2.0"
+  },
+  "loginHint": {
+    "title": "Inicia sesión con tu cuenta",
+    "body": "En lugar de esperar, inicia sesión con tu cuenta.",
+    "button": {
+      "ariaLabel": "Cerrar la sugerencia",
+      "label": "Aceptar"
+    }
+  },
+  "skipLink": "Ir al contenido principal",
+  "clipboardContent": {
+    "url": "Para participar en la videoconferencia, haz clic en este enlace: {{roomUrl}}",
+    "numberAndPin": "Para participar por teléfono, marca el {{phoneNumber}} e introduce este código: {{pinCode}}"
+  }
+}
@@ -0,0 +1,63 @@
+{
+  "createMeeting": "Crear una reunión",
+  "heading": "Videoconferencias sencillas y seguras",
+  "intro": "Comunícate y trabaja con facilidad, manteniendo siempre el control de tus datos",
+  "joinInputError": "Introduce un enlace o un código de reunión. Ejemplos:",
+  "joinInputExample": "Un código de reunión tiene este aspecto: abc-defg-hij",
+  "joinInputLabel": "Enlace completo o código de la reunión",
+  "joinInputSubmit": "Unirse a la reunión",
+  "joinMeeting": "Unirse a una reunión",
+  "joinMeetingTipContent": "Puedes unirte a una reunión copiando directamente su enlace completo en la barra de direcciones del navegador.",
+  "joinMeetingTipHeading": "Consejo",
+  "loginToCreateMeeting": "Inicia sesión para crear una reunión",
+  "moreLinkLabel": "Más información sobre {{appTitle}} - nueva ventana",
+  "moreLink": "Más información",
+  "moreAbout": "sobre {{appTitle}}",
+  "connectionTestLink": "Prueba tu configuración",
+  "createMenu": {
+    "laterOption": "Crear una reunión para más tarde",
+    "instantOption": "Iniciar una reunión ahora"
+  },
+  "laterMeetingDialog": {
+    "heading": "Tus datos de conexión",
+    "description": "Comparte estos datos con los invitados. Podrán unirse a la reunión sin necesidad de iniciar sesión. Esta reunión es permanente y puede reutilizarse.",
+    "permissions": "Las personas que dispongan de este enlace no necesitan tu autorización para unirse a esta reunión.",
+    "copy": "Copiar los datos",
+    "copied": "Copiados en el portapapeles",
+    "copyUrl": "Copiar el enlace de la reunión",
+    "phone": {
+      "call": "Llama al:",
+      "pinCode": "Código:"
+    }
+  },
+  "introSlider": {
+    "carouselLabel": "Presentación de diapositivas",
+    "previous": {
+      "label": "Diapositiva anterior",
+      "labelWithPosition": "Diapositiva anterior ({{current}} de {{total}})",
+      "tooltip": "Diapositiva anterior"
+    },
+    "next": {
+      "label": "Diapositiva siguiente",
+      "labelWithPosition": "Diapositiva siguiente ({{current}} de {{total}})",
+      "tooltip": "Diapositiva siguiente"
+    },
+    "slidePosition": "Diapositiva {{current}} de {{total}}",
+    "beta": {
+      "text": "Probar la beta",
+      "tooltip": "Acceder al formulario"
+    },
+    "slide1": {
+      "title": "Pásate a la sencillez. ¡Pruébanos ahora mismo!",
+      "body": "Descubre una solución intuitiva y accesible, pensada para el sector público y todos sus colaboradores."
+    },
+    "slide2": {
+      "title": "Organiza llamadas de grupo sin límite",
+      "body": "Reuniones sin límite de tiempo, con una comunicación fluida y de alta calidad, sea cual sea el número de participantes."
+    },
+    "slide3": {
+      "title": "Transforma tus reuniones con la IA",
+      "body": "Obtén transcripciones precisas y accionables para impulsar tu productividad. Función experimental, ¡pruébala ahora!"
+    }
+  }
+}
@@ -0,0 +1,37 @@
+{
+  "title": "Aviso legal",
+  "creator": {
+    "title": "Editor",
+    "body": "El servicio Visio está editado por la Dirección Interministerial de lo Digital del Estado (DINUM), con domicilio en:",
+    "contact": {
+      "title": "Datos de contacto",
+      "address": "20 avenue de Ségur",
+      "city": "75007 París",
+      "phone": "Tel. Recepción: 01.71.21.01.70",
+      "siret": "SIRET: 12000101100010 (secretaría general del gobierno)",
+      "siren": "SIREN: 120 001 011"
+    }
+  },
+  "director": {
+    "title": "Director de la publicación",
+    "body": "La directora de la publicación es la señora Stéphanie Schaer, directora interministerial de lo digital."
+  },
+  "hosting": {
+    "title": "Alojamiento",
+    "body": "El servicio está alojado por Outscale West-1 CloudGouv SecNumCloud, situado en Francia."
+  },
+  "accessibility": {
+    "title": "Accesibilidad",
+    "body": "La conformidad con las normas de accesibilidad digital es un objetivo posterior. El sitio todavía no ha sido auditado. No obstante, el equipo trabaja para crear un sitio accesible para todo el mundo siguiendo las recomendaciones del RGAA.",
+    "more": "Para saber más: ",
+    "link": "enlace a la página de accesibilidad",
+    "status": "Estado de accesibilidad: no conforme"
+  },
+  "reuse": {
+    "title": "Reutilización de los contenidos y enlaces",
+    "body1": "Salvo mención explícita de propiedad intelectual perteneciente a terceros, los contenidos de este sitio se ofrecen bajo ",
+    "license": "licencia abierta Etalab 2.0",
+    "body2": "En particular, eres libre de reproducirlos, copiarlos, modificarlos, extraerlos, transformarlos, comunicarlos, difundirlos, redistribuirlos, publicarlos, transmitirlos y explotarlos siempre que menciones su fuente y su fecha de última actualización, y no induzcas a error a terceros sobre la información que contienen.",
+    "body3": "Todo sitio público o privado está autorizado a establecer, sin autorización previa, un enlace (incluido un enlace profundo) hacia la información difundida en este sitio."
+  }
+}
@@ -0,0 +1,66 @@
+{
+  "defaultName": "Un colaborador",
+  "joined": {
+    "description": "{{name}} participa en la llamada"
+  },
+  "raised": {
+    "description": "{{name}} ha levantado la mano.",
+    "cta": "Abrir la lista de espera"
+  },
+  "muted": "{{name}} ha silenciado tu micrófono. Ningún participante puede oírte.",
+  "openChat": "Abrir el chat",
+  "chatMessageReceived": "{{name}} dice: {{message}}",
+  "lowerHand": {
+    "auto": "Parece que has tomado la palabra, así que se va a bajar la mano.",
+    "dismiss": "Dejar la mano levantada"
+  },
+  "autoMuteLargeRoom": {
+    "auto": "Acabas de unirte a una reunión numerosa. Tu micrófono se ha silenciado automáticamente.",
+    "dismiss": "Reactivar el micrófono"
+  },
+  "reaction": {
+    "description": "{{name}} ha reaccionado con {{emoji}}"
+  },
+  "permissionsRemoved": {
+    "camera": "El organizador ha desactivado el vídeo de todos los participantes.",
+    "microphone": "El organizador ha desactivado el micrófono de todos los participantes.",
+    "screen_share": "El organizador ha desactivado la pantalla compartida de todos los participantes."
+  },
+  "waitingParticipants": {
+    "one": "Una persona quiere participar en esta llamada.",
+    "several": "Varias personas quieren participar en esta llamada.",
+    "open": "Mostrar",
+    "accept": "Aceptar"
+  },
+  "transcript": {
+    "started": "{{name}} ha iniciado la transcripción de la reunión.",
+    "stopped": "{{name}} ha detenido la transcripción de la reunión.",
+    "limitReached": "La transcripción ha superado la duración máxima permitida, se va a guardar automáticamente.",
+    "requested": "{{name}} ha solicitado iniciar la transcripción."
+  },
+  "screenRecording": {
+    "started": "{{name}} ha iniciado la grabación de la reunión.",
+    "stopped": "{{name}} ha detenido la grabación de la reunión.",
+    "limitReached": "La grabación ha superado la duración máxima permitida, se va a guardar automáticamente.",
+    "requested": "{{name}} ha solicitado iniciar la grabación."
+  },
+  "recordingSave": {
+    "transcript": {
+      "message": "¡Estamos finalizando tu grabación! Recibirás un correo electrónico en <strong>{{email}}</strong> en cuanto la transcripción esté lista.",
+      "default": "¡Estamos finalizando tu grabación! Recibirás un correo electrónico en cuanto la transcripción esté lista."
+    },
+    "screenRecording": {
+      "message": "¡Estamos finalizando tu grabación! Recibirás un correo electrónico en <strong>{{email}}</strong> en cuanto esté lista.",
+      "default": "¡Estamos finalizando tu grabación! Recibirás un correo electrónico en cuanto esté lista."
+    }
+  },
+  "roleChanged": {
+    "body": "Tu rol ha cambiado, ahora eres {{role}}.",
+    "roles": {
+      "owner": "Organizador",
+      "administrator": "Coorganizador",
+      "member": "Miembro"
+    }
+  },
+  "openMenu": "Abrir el menú"
+}
@@ -0,0 +1,28 @@
+{
+  "error": {
+    "title": "Grabación no disponible",
+    "body": "No se encuentra la grabación. Solo el organizador de la reunión puede acceder a ella. No dudes en ponerte en contacto con él si lo necesitas."
+  },
+  "expired": {
+    "title": "Grabación caducada",
+    "body": "Esta grabación se eliminó el {{date}}."
+  },
+  "authentication": {
+    "title": "Autenticación necesaria",
+    "body": "Inicia sesión para acceder a esta grabación."
+  },
+  "unsaved": {
+    "title": "Descarga no disponible",
+    "body": "Esta grabación aún no está lista para descargarse. Inténtalo de nuevo más tarde."
+  },
+  "success": {
+    "title": "¡Tu grabación está lista!",
+    "body": "Grabación de la reunión {{room}} del {{created_at}}.",
+    "expiration": "Atención: esta grabación caducará al cabo de {{expiration_days}} día(s).",
+    "button": "Descargar",
+    "warning": {
+      "title": "Uso compartido por enlace desactivado",
+      "body": "Compartir la grabación mediante un enlace todavía no está disponible. Solo los organizadores pueden descargarla."
+    }
+  }
+}
@@ -0,0 +1,801 @@
+{
+  "feedback": {
+    "heading": {
+      "normal": "Has salido de la reunión",
+      "duplicateIdentity": "Te has unido a la reunión desde otro dispositivo",
+      "participantRemoved": "Un administrador te ha expulsado de la llamada"
+    },
+    "home": "Volver al inicio",
+    "back": "Volver a la reunión"
+  },
+  "selectDevice": {
+    "loading": "Cargando…",
+    "select": "Selecciona un valor",
+    "permissionsNeeded": "Permisos necesarios",
+    "deviceNotFound": {
+      "videoinput": "No se ha detectado ninguna cámara. Comprueba que esté bien conectada.",
+      "audioinput": "No se ha detectado ningún micrófono. Comprueba que esté bien conectado."
+    },
+    "deviceInUse": {
+      "videoinput": "Cámara no disponible: probablemente la esté usando otra aplicación u otra pestaña.",
+      "audioinput": "Micrófono no disponible: probablemente lo esté usando otra aplicación u otra pestaña."
+    },
+    "settings": {
+      "audio": "Configuración de audio",
+      "video": "Configuración de vídeo"
+    },
+    "effects": "Fondos y efectos",
+    "videoinput": {
+      "choose": "Elegir la cámara web",
+      "permissionsNeeded": "Elegir la cámara web - permisos necesarios",
+      "disable": "Desactivar la cámara web",
+      "enable": "Activar la cámara web",
+      "turnedOff": "Cámara web desactivada",
+      "turnedOn": "Cámara web activada",
+      "label": "Cámara web",
+      "placeholder": "Activa la cámara web para previsualizar la imagen"
+    },
+    "audioinput": {
+      "choose": "Elegir el micrófono",
+      "level": "Nivel de entrada del micrófono",
+      "muteTest": "Activa tu micrófono para probarlo",
+      "permissionsNeeded": "Elegir el micrófono - permisos necesarios",
+      "disable": "Desactivar el micrófono",
+      "enable": "Activar el micrófono",
+      "turnedOff": "Micrófono desactivado",
+      "turnedOn": "Micrófono activado",
+      "label": "Micrófono"
+    },
+    "audiooutput": {
+      "choose": "Elegir el altavoz",
+      "permissionsNeeded": "Elegir el altavoz - permisos necesarios",
+      "test": "Probar los altavoces",
+      "testing": "Reproduciendo el sonido de prueba…"
+    }
+  },
+  "join": {
+    "heading": "¿Unirse a la reunión?",
+    "effects": {
+      "description": "Fondos y efectos",
+      "title": "Fondos y efectos",
+      "subTitle": "Configura los efectos de tu cámara."
+    },
+    "joinLabel": "Unirse",
+    "joinMeeting": "Unirse a la reunión",
+    "toggleOff": "Haz clic para desactivar",
+    "toggleOn": "Haz clic para activar",
+    "usernameHint": "Se muestra a los demás participantes",
+    "usernameLabel": "Tu nombre",
+    "errors": {
+      "usernameEmpty": "Tu nombre no puede estar vacío"
+    },
+    "cameraDisabled": "La cámara está desactivada.",
+    "cameraNotFound": "No se ha detectado ninguna cámara. Comprueba que esté bien conectada.",
+    "cameraInUse": "Tu cámara no está disponible. Probablemente la esté usando otra aplicación u otra pestaña.",
+    "cameraStarting": "La cámara va a iniciarse…",
+    "cameraNotGranted": "¿Quieres que los demás puedan verte durante la reunión?",
+    "cameraAndMicNotGranted": "¿Quieres que los demás puedan verte y oírte durante la reunión?",
+    "videoPreview": {
+      "enabled": "Vista previa de vídeo activada",
+      "disabled": "Vista previa de vídeo desactivada"
+    },
+    "permissionsButton": {
+      "cameraAndMicNotGranted": "Autoriza el acceso a la cámara y al micrófono",
+      "cameraNotGranted": "Autoriza el acceso a la cámara"
+    },
+    "waiting": {
+      "title": "Solicitud de participación…",
+      "body": "Podrás participar en esta llamada cuando alguien te lo autorice"
+    },
+    "denied": {
+      "title": "No puedes participar en esta llamada",
+      "body": "Tu solicitud de participación ha sido rechazada."
+    },
+    "timeoutInvite": {
+      "title": "No puedes participar en esta llamada",
+      "body": "Nadie ha respondido a tu solicitud de participación en la llamada"
+    }
+  },
+  "leaveRoomPrompt": "Volver al inicio hará que salgas de la reunión.",
+  "shareDialog": {
+    "copy": "Copiar los datos",
+    "copyUrl": "Copiar el enlace",
+    "copied": "Copiados en el portapapeles",
+    "heading": "Tu reunión está lista",
+    "description": "Comparte este enlace con las personas que quieras invitar a la reunión.",
+    "permissions": "Las personas que dispongan de este enlace no necesitan tu autorización para unirse a esta reunión.",
+    "closeDialog": "Cerrar la ventana modal",
+    "phone": {
+      "call": "Llama al:",
+      "pinCode": "Código:"
+    }
+  },
+  "pagination": {
+    "label": "Páginas de participantes",
+    "count": "{{currentPage}} de {{totalPageCount}}",
+    "next": "página siguiente",
+    "previous": "página anterior"
+  },
+  "mediaErrorDialog": {
+    "DeviceInUse": {
+      "title": {
+        "audioinput": "No se puede activar el micrófono",
+        "videoinput": "No se puede activar la cámara"
+      },
+      "body": {
+        "audioinput": "Tu micrófono ya se está usando en otra pestaña o en otra aplicación, lo que impide activarlo en esta videoconferencia. Si quieres, cierra la otra pestaña o aplicación para usarlo aquí.",
+        "videoinput": "Tu cámara ya se está usando en otra pestaña o en otra aplicación, lo que impide activarla en esta videoconferencia. Si quieres, cierra la otra pestaña o aplicación para usarla aquí."
+      }
+    },
+    "NotFound": {
+      "title": {
+        "audioinput": "No se ha detectado ningún micrófono",
+        "videoinput": "No se ha detectado ninguna cámara"
+      },
+      "body": {
+        "audioinput": "No se ha detectado ningún micrófono en tu dispositivo. Comprueba que esté bien conectado y que ningún botón lo silencie, y vuelve a intentarlo.",
+        "videoinput": "No se ha detectado ninguna cámara en tu dispositivo. Comprueba que esté bien conectada y que ninguna tapa o botón la bloquee, y vuelve a intentarlo."
+      }
+    },
+    "close": "Aceptar"
+  },
+  "permissionErrorDialog": {
+    "heading": {
+      "camera": "{{appTitle}} no tiene permiso para usar tu cámara",
+      "microphone": "{{appTitle}} no tiene permiso para usar tu micrófono",
+      "cameraAndMicrophone": "{{appTitle}} no tiene permiso para usar tu micrófono ni tu cámara",
+      "default": "{{appTitle}} no tiene permiso para usar algunas funciones necesarias."
+    },
+    "body": {
+      "openMenu": {
+        "others": "Haz clic en el icono de configuración ICON_PLACEHOLDER en la barra de direcciones de tu navegador",
+        "safari": "Haz clic en el menú \"Safari\" y abre \"Configuración para {{appDomain}}\"."
+      },
+      "details": {
+        "camera": "Autoriza el acceso a la cámara",
+        "microphone": "Autoriza el acceso al micrófono",
+        "cameraAndMicrophone": "Autoriza el acceso a la cámara y al micrófono",
+        "default": "Activa los permisos necesarios."
+      }
+    }
+  },
+  "systemPermissionDialog": {
+    "heading": {
+      "camera": "Autoriza a tu navegador a usar tu cámara",
+      "microphone": "Autoriza a tu navegador a usar tu micrófono",
+      "cameraAndMicrophone": "Autoriza a tu navegador a usar tu cámara y tu micrófono"
+    },
+    "device": {
+      "camera": "cámara",
+      "microphone": "micrófono",
+      "cameraAndMicrophone": "cámara y tu micrófono"
+    },
+    "intro": "Tu navegador ya tiene el permiso, pero la configuración de tu ordenador bloquea el acceso a tu {{device}}.",
+    "steps": {
+      "macos": {
+        "1": "En los ajustes del Sistema, abre «Privacidad y seguridad».",
+        "2": "Autoriza a tu navegador a acceder a tu {{device}}."
+      },
+      "windows": {
+        "1": "En la configuración de Windows, abre «Privacidad y seguridad».",
+        "2": "Activa el acceso a tu {{device}} y autoriza a las aplicaciones de escritorio a usarlo."
+      },
+      "android": {
+        "1": "En los ajustes de Android, abre «Aplicaciones» y selecciona tu navegador.",
+        "2": "En «Permisos», autoriza el acceso a tu {{device}} y recarga la página."
+      },
+      "other": {
+        "1": "En los ajustes de privacidad de tu sistema, autoriza a tu navegador a acceder a tu {{device}}.",
+        "2": "Después, vuelve a intentarlo."
+      }
+    },
+    "openSettings": "Abrir los ajustes del sistema"
+  },
+  "silentMic": {
+    "tooltip": "Tu micrófono está activado, pero no se detecta ningún sonido. Haz clic para saber más.",
+    "dialog": {
+      "title": "No se detecta ningún sonido",
+      "intro": "Tu micrófono está activado, pero hace un rato que no se detecta ningún sonido. Comprueba los siguientes puntos:",
+      "causes": {
+        "system": "Puede que el acceso al micrófono esté bloqueado en los ajustes de privacidad de tu sistema.",
+        "hardware": "Puede que un botón o interruptor silencie el micrófono, o que esté desconectado o defectuoso.",
+        "wrongDevice": "Puede que haya otro micrófono seleccionado. Prueba a elegir otro en el menú del micrófono."
+      },
+      "hint": "Vuelve a hablar después de comprobar estos puntos. El aviso desaparecerá en cuanto se detecte un sonido.",
+      "close": "Entendido",
+      "discard": "Desactivar esta detección"
+    }
+  },
+  "permissionsButton": {
+    "tooltip": "Más información",
+    "ariaLabel": "Problema de permisos. Mostrar más información"
+  },
+  "error": {
+    "createRoom": {
+      "heading": "Autenticación necesaria",
+      "body": "Esta reunión todavía no se ha creado. Autentícate para crearla o espera a que lo haga un usuario autenticado."
+    },
+    "screenShare": {
+      "title": "No se puede compartir tu pantalla",
+      "ariaLabel": "No se puede compartir tu pantalla",
+      "message": "Puede que tu navegador no tenga permiso para grabar la pantalla en tu ordenador.",
+      "settingsInstructions": "Accede a tus",
+      "settingsLabel": {
+        "macos": "Preferencias del sistema",
+        "windows": "ajustes de privacidad de Windows"
+      },
+      "helpLinkText": "Para saber más, consulta",
+      "helpLinkLabel": "Problema de presentación",
+      "closeButton": "Ignorar",
+      "newTab": "Nueva ventana"
+    }
+  },
+  "isIdleDisconnectModal": {
+    "title": "¿Sigues ahí?",
+    "body": "Eres el único participante. Por eso, esta llamada terminará dentro de {{duration}}. ¿Quieres continuar la llamada?",
+    "settingsPrefix": "Para no volver a ver este mensaje, ve a",
+    "settingsLink": "Configuración > General",
+    "settingsSuffix": ".",
+    "stayButton": "Continuar la llamada",
+    "leaveButton": "Salir ahora",
+    "countdownAnnouncement": "La llamada termina dentro de {{duration}}."
+  },
+  "controls": {
+    "region": "Controles de la llamada",
+    "microphone": "Micrófono",
+    "camera": "Cámara",
+    "chat": {
+      "open": "Ocultar el chat",
+      "closed": "Mostrar el chat",
+      "input": {
+        "textArea": {
+          "label": "Escribir un mensaje",
+          "placeholder": "Escribir un mensaje"
+        },
+        "button": {
+          "label": "Enviar un mensaje"
+        }
+      }
+    },
+    "info": {
+      "open": "Ocultar la información",
+      "closed": "Mostrar la información"
+    },
+    "hand": {
+      "raise": "Levantar la mano",
+      "lower": "Bajar la mano"
+    },
+    "subtitles": {
+      "closed": "Mostrar los subtítulos",
+      "open": "Ocultar los subtítulos"
+    },
+    "screenShare": {
+      "start": "Compartir pantalla",
+      "stop": "Dejar de compartir"
+    },
+    "leave": "Salir",
+    "participants": {
+      "open": "Ocultar los participantes",
+      "closed": "Mostrar los participantes",
+      "count_one": "{{count}} participante",
+      "count_other": "{{count}} participantes"
+    },
+    "tools": {
+      "open": "Ocultar las herramientas de reunión",
+      "closed": "Mostrar las herramientas de reunión"
+    },
+    "admin": {
+      "open": "Ocultar la administración",
+      "closed": "Mostrar la administración"
+    },
+    "moreOptions": "Más opciones",
+    "reactions": {
+      "button": "Enviar una reacción",
+      "toolbar": "Enviar una reacción",
+      "announce": "{{name}}: {{emoji}}",
+      "you": "tú",
+      "emojis": {
+        "thumbs-up": "pulgar hacia arriba",
+        "thumbs-down": "pulgar hacia abajo",
+        "clapping-hands": "aplausos",
+        "red-heart": "corazón",
+        "face-with-tears-of-joy": "cara llorando de risa",
+        "face-with-open-mouth": "cara de asombro",
+        "party-popper": "confeti",
+        "folded-hands": "manos juntas"
+      }
+    }
+  },
+  "pictureInPicture": {
+    "placeholder": {
+      "title": "Tu videollamada está en otra ventana.",
+      "description": "El modo imagen en imagen te permite seguir conectado a la llamada mientras haces otras tareas.",
+      "bringBack": "Traer la llamada aquí"
+    },
+    "stage": "Participantes",
+    "controlBar": "Controles de la reunión",
+    "title": "Reunión en imagen en imagen"
+  },
+  "options": {
+    "buttonLabel": "Más opciones",
+    "items": {
+      "feedback": "Comparte tu opinión",
+      "settings": "Configuración",
+      "screenRecording": "Grabación",
+      "transcript": "Transcripción",
+      "username": "Elegir tu nombre",
+      "effects": "Fondos y efectos",
+      "switchCamera": "Cambiar de cámara",
+      "pictureInPicture": {
+        "enter": "Imagen en imagen",
+        "exit": "Cerrar la imagen en imagen"
+      },
+      "fullscreen": {
+        "enter": "Pantalla completa",
+        "exit": "Salir del modo de pantalla completa"
+      },
+      "support": "Contactar con el soporte",
+      "documentation": "Documentación"
+    }
+  },
+  "effects": {
+    "activateCamera": "Tu cámara está desactivada. Elige una opción para activarla.",
+    "cameraDisabled": "Tu cámara está desactivada.",
+    "notAvailable": "Los efectos de vídeo estarán disponibles pronto en tu navegador. ¡Estamos trabajando en ello! Mientras tanto, puedes usar Google Chrome para un mejor rendimiento, o Firefox :(",
+    "heading": "Desenfoque",
+    "clear": "Desactivar el efecto",
+    "blur": {
+      "title": "Desenfoque del fondo",
+      "status": {
+        "none": "Fondo nítido.",
+        "light": "Fondo ligeramente desenfocado.",
+        "strong": "Fondo muy desenfocado."
+      },
+      "light": {
+        "apply": "Desenfocar el fondo",
+        "clear": "Desactivar el desenfoque"
+      },
+      "normal": {
+        "apply": "Desenfocar aún más el fondo",
+        "clear": "Desactivar el desenfoque"
+      }
+    },
+    "virtual": {
+      "title": "Fondos virtuales",
+      "selectedLabel": "Fondo aplicado:",
+      "apply": "Sustituye tu fondo:",
+      "personal": {
+        "title": "Mis fondos",
+        "selectedLabel": "Dejar de usar como fondo (actualmente activo).",
+        "apply": "Usar como fondo.",
+        "selectFileTooltip": "Selecciona una imagen para usarla como fondo",
+        "notLoggedInWarning": "No has iniciado sesión, el fondo personal no se guardará de una reunión a otra.",
+        "warningUploadDisabled": "Actualmente los fondos personales no se guardan de una reunión a otra.",
+        "uploadLimitReached": "No puedes añadir más fondos personales.",
+        "uploadInProgress": "Enviando la imagen…",
+        "deleteLabel": "Eliminar el fondo.",
+        "errors": {
+          "close": "Cerrar",
+          "file_too_large": {
+            "title": "Archivo demasiado grande",
+            "description": "El archivo es demasiado grande. Elige un archivo de menos de {{maxSize, number}} MB."
+          },
+          "invalid_file_type": {
+            "title": "Tipo de archivo no válido",
+            "description": "El tipo de archivo no es compatible. Elige un archivo {{allowedExtension}}."
+          }
+        }
+      },
+      "presets": {
+        "title": "Sugerencias",
+        "descriptions": {
+          "0": "Mueble acanalado de madera",
+          "1": "Sala de reuniones",
+          "2": "Loft con cristalera negra",
+          "3": "Comedor",
+          "4": "Estanterías de madera",
+          "5": "Escalera de madera",
+          "6": "Estantería gris",
+          "7": "Barra de cafetería"
+        }
+      }
+    },
+    "faceLandmarks": {
+      "title": "Efectos visuales",
+      "glasses": {
+        "apply": "Añadir gafas",
+        "clear": "Quitar las gafas"
+      },
+      "french": {
+        "apply": "Añadir el toque francés",
+        "clear": "Quitar el toque francés"
+      }
+    }
+  },
+  "sidePanel": {
+    "ariaLabel": "Panel lateral - {{title}}",
+    "backToTools": "Volver a las herramientas de reunión",
+    "heading": {
+      "participants": "Participantes",
+      "effects": "Fondos y efectos",
+      "chat": "Mensajes de la llamada",
+      "transcript": "Transcribir",
+      "screenRecording": "Grabar",
+      "admin": "Controles del organizador",
+      "tools": "Herramientas de reunión",
+      "info": "Información sobre la reunión"
+    },
+    "content": {
+      "participants": "los participantes",
+      "effects": "los efectos",
+      "chat": "los mensajes",
+      "transcript": "transcribir",
+      "screenRecording": "grabar",
+      "admin": "controles del organizador",
+      "tools": "herramientas de reunión",
+      "info": "información sobre la reunión"
+    },
+    "closeButton": "Ocultar {{content}}"
+  },
+  "chat": {
+    "disclaimer": "Los mensajes solo son visibles para los participantes en el momento de\nsu envío. Todos los mensajes se eliminan al final de la llamada.",
+    "messagesLog": "Mensajes del chat"
+  },
+  "moreTools": {
+    "body": "Accede a más herramientas para mejorar tus reuniones.",
+    "linkAriaLabel": "Abrir la documentación sobre las herramientas - se abre en una nueva ventana",
+    "moreLink": "Abrir la documentación",
+    "tools": {
+      "transcript": {
+        "title": "Transcribir",
+        "body": "Transcribir la reunión."
+      },
+      "screenRecording": {
+        "title": "Grabar",
+        "body": "Grabar la reunión en vídeo."
+      }
+    }
+  },
+  "info": {
+    "roomInformation": {
+      "title": "Datos de conexión",
+      "button": {
+        "ariaLabel": "Copiar los datos de tu reunión",
+        "copy": "Copiar los datos",
+        "copied": "Datos copiados"
+      },
+      "phone": {
+        "call": "Llama al:",
+        "pinCode": "Código:"
+      }
+    }
+  },
+  "transcript": {
+    "heading": "Transcribe tu reunión con el Asistente de IA",
+    "body": "Transcribe hasta {{max_duration}} de reunión.",
+    "bodyWithoutMaxDuration": "Transcribe tu reunión sin límite.",
+    "details": {
+      "receiver": "La transcripción se enviará al organizador y a los coorganizadores.",
+      "destination": "Se creará un nuevo documento en",
+      "destinationUnknown": "Se creará un nuevo documento",
+      "language": "Idioma de la reunión:",
+      "recording": "Iniciar también una grabación"
+    },
+    "button": {
+      "start": "Empezar a transcribir la reunión",
+      "stop": "Dejar de transcribir la reunión",
+      "saving": "Guardando…",
+      "starting": "Iniciando…",
+      "anotherModeStarted": "Hay una grabación en curso. <br/> Cambia de menú y deténla."
+    },
+    "linkMore": "Abrir la documentación",
+    "linkAriaLabel": "Abrir la documentación sobre la transcripción - se abre en una nueva ventana",
+    "notAdminOrOwner": {
+      "heading": "Acceso restringido",
+      "body": "Por razones de seguridad, solo el creador o un administrador de la reunión puede iniciar una transcripción (beta).",
+      "linkMore": "Abrir la documentación",
+      "linkAriaLabel": "Abrir la documentación sobre el acceso a la transcripción - se abre en una nueva ventana",
+      "dividerLabel": "O",
+      "login": {
+        "heading": "Inicio de sesión necesario",
+        "body": "Solo el creador de la reunión o un administrador puede iniciar la transcripción. Inicia sesión para comprobar tus permisos."
+      },
+      "request": {
+        "heading": "Pedírselo al organizador",
+        "body": "El anfitrión recibirá una notificación y podrá iniciar la transcripción por ti.",
+        "buttonLabel": "Solicitar"
+      }
+    },
+    "premium": {
+      "heading": "Función avanzada",
+      "body": "Esta función no está disponible para ti. Ponte en contacto con el soporte para obtener más información.",
+      "linkMore": "Abrir la documentación",
+      "dividerLabel": "O",
+      "login": {
+        "heading": "¡No has iniciado sesión!",
+        "body": "Debes haber iniciado sesión para usar esta función. Inicia sesión y vuelve a intentarlo."
+      },
+      "request": {
+        "heading": "Pedírselo al organizador",
+        "body": "El anfitrión recibirá una notificación y podrá iniciar la transcripción por ti.",
+        "buttonLabel": "Solicitar"
+      },
+      "linkAriaLabel": "Abrir la documentación sobre la función avanzada - se abre en una nueva ventana"
+    }
+  },
+  "screenRecording": {
+    "heading": "Graba esta llamada para más tarde",
+    "body": "Graba hasta {{max_duration}} de reunión.",
+    "bodyWithoutMaxDuration": "Graba tu reunión sin límite.",
+    "linkMore": "Abrir la documentación",
+    "linkAriaLabel": "Abrir la documentación sobre la grabación - se abre en una nueva ventana",
+    "details": {
+      "receiver": "La grabación se enviará al organizador y a los coorganizadores.",
+      "destination": "Esta grabación se conservará temporalmente en nuestros servidores",
+      "loading": "Iniciando la grabación",
+      "linkMore": "Más información",
+      "transcription": "Transcribir esta grabación"
+    },
+    "button": {
+      "start": "Empezar a grabar la reunión",
+      "stop": "Dejar de grabar la reunión",
+      "saving": "Guardando…",
+      "starting": "Iniciando…",
+      "anotherModeStarted": "Hay una transcripción en curso. <br/> Cambia de menú y deténla."
+    },
+    "notAdminOrOwner": {
+      "heading": "Acceso restringido",
+      "body": "Por razones de seguridad, solo el creador o un administrador de la reunión puede iniciar una grabación (beta).",
+      "linkMore": "Abrir la documentación",
+      "linkAriaLabel": "Abrir la documentación sobre el acceso a la grabación - se abre en una nueva ventana",
+      "dividerLabel": "O",
+      "login": {
+        "heading": "Inicio de sesión necesario",
+        "body": "Solo el creador de la reunión o un administrador puede iniciar la grabación. Inicia sesión para comprobar tus permisos."
+      },
+      "request": {
+        "heading": "Pedírselo al organizador",
+        "body": "El anfitrión recibirá una notificación y podrá iniciar la grabación por ti.",
+        "buttonLabel": "Solicitar"
+      }
+    },
+    "premium": {
+      "heading": "Función avanzada",
+      "body": "Esta función no está disponible para ti. Ponte en contacto con el soporte para obtener más información.",
+      "linkMore": "Abrir la documentación",
+      "dividerLabel": "O",
+      "login": {
+        "heading": "¡No has iniciado sesión!",
+        "body": "Debes haber iniciado sesión para usar esta función. Inicia sesión y vuelve a intentarlo."
+      },
+      "request": {
+        "heading": "Pedírselo al organizador",
+        "body": "El anfitrión recibirá una notificación y podrá iniciar la grabación por ti.",
+        "buttonLabel": "Solicitar"
+      },
+      "linkAriaLabel": "Abrir la documentación sobre la función avanzada - se abre en una nueva ventana"
+    },
+    "durationMessage": "(limitado a {{max_duration}}) "
+  },
+  "errorRecordingAlertDialog": {
+    "title": "Error de grabación",
+    "body": {
+      "stop": "No hemos podido detener la grabación. Inténtalo de nuevo dentro de unos instantes.",
+      "start": "No hemos podido iniciar la grabación. Inténtalo de nuevo dentro de unos instantes."
+    },
+    "button": "Aceptar"
+  },
+  "admin": {
+    "description": "Esta configuración de organizador te permite mantener el control de tu reunión. Solo los organizadores pueden acceder a estos controles.",
+    "access": {
+      "title": "Acceso a la reunión",
+      "description": "Esta configuración se aplicará también a las futuras ediciones de esta reunión.",
+      "type": "Tipo de acceso a la reunión",
+      "levels": {
+        "public": {
+          "label": "Abierta",
+          "description": "Cualquier persona puede unirse a la reunión sin autorización."
+        },
+        "trusted": {
+          "label": "Abierta a personas de confianza",
+          "description": "Las personas autenticadas no tienen que pedir permiso para unirse a la reunión."
+        },
+        "restricted": {
+          "label": "Restringida",
+          "description": "Las personas que no hayan sido invitadas a la reunión deben pedir unirse a ella."
+        }
+      }
+    },
+    "moderation": {
+      "title": "Moderación de la reunión",
+      "description": "Esta configuración limita las acciones que pueden realizar los colaboradores durante la reunión.",
+      "microphone": {
+        "label": "Encender el micrófono",
+        "description": ""
+      },
+      "camera": {
+        "label": "Activar el vídeo",
+        "description": ""
+      },
+      "screenshare": {
+        "label": "Compartir su pantalla",
+        "description": "Si desactivas esta opción, los participantes ya no podrán compartir su pantalla y cualquier pantalla compartida en curso se interrumpirá de inmediato."
+      },
+      "mute": {
+        "label": "Silenciar a los demás",
+        "description": "Si desactivas esta opción, los participantes ya no podrán silenciar a otros participantes."
+      }
+    }
+  },
+  "rating": {
+    "submit": "Enviar",
+    "question": "¿Qué te ha parecido la calidad de tu llamada?",
+    "levels": {
+      "min": "muy mala",
+      "max": "excelente"
+    }
+  },
+  "openFeedback": {
+    "question": "¿Qué podemos hacer para mejorar?",
+    "placeholder": "Describe los errores o comparte tus sugerencias…",
+    "submit": "Enviar",
+    "skip": "Omitir"
+  },
+  "confirmationMessage": {
+    "heading": "Gracias por tu opinión",
+    "body": "Nuestro equipo de producto se toma el tiempo de analizar atentamente tus respuestas. Nos pondremos en contacto contigo lo antes posible."
+  },
+  "authenticationMessage": {
+    "heading": "¿Cómo podemos ponernos en contacto contigo?",
+    "placeholder": "Tu correo electrónico",
+    "submit": "Enviar",
+    "ignore": "Ignorar"
+  },
+  "participants": {
+    "subheading": "En la reunión",
+    "you": "Tú",
+    "unknown": "Participante desconocido",
+    "contributors": "Colaboradores",
+    "host": "Organizador de la reunión",
+    "cohost": "Coorganizador",
+    "member": "Miembro",
+    "collapsable": {
+      "open": "Abrir la lista {{name}}",
+      "close": "Cerrar la lista {{name}}"
+    },
+    "unauthenticated": {
+      "badge": "Usuario no autenticado"
+    },
+    "muteYourself": "Silenciar tu micrófono",
+    "muteParticipant": "Silenciar el micrófono de {{name}}",
+    "muteParticipantAlert": {
+      "heading": "Silenciar el micrófono de {{name}}",
+      "description": "¿Silenciar el micrófono de {{name}} para todos los participantes? {{name}} es la única persona autorizada a reactivar su micrófono",
+      "confirm": "Silenciar el micrófono",
+      "cancel": "Cancelar"
+    },
+    "raisedHands": "Manos levantadas",
+    "lowerParticipantHand": "Bajar la mano de {{name}}",
+    "lowerParticipantsHand": "Bajar todas las manos",
+    "muteParticipants": "Silenciar todos los micrófonos",
+    "waiting": {
+      "title": "Sala de espera",
+      "accept": {
+        "button": "Aceptar",
+        "label": "Aceptar a {{name}} en la reunión",
+        "all": "Aceptar todo"
+      },
+      "deny": {
+        "button": "Rechazar",
+        "label": "Rechazar a {{name}} en la reunión",
+        "all": "Rechazar todo"
+      }
+    },
+    "moreOptions": "Más opciones"
+  },
+  "participantMenu": {
+    "remove": {
+      "label": "Expulsar de la llamada",
+      "ariaLabel": "Expulsar a {{name}} de la llamada"
+    },
+    "unpin": {
+      "label": "Dejar de fijar",
+      "ariaLabel": "Dejar de fijar a {{name}}"
+    },
+    "pin": {
+      "label": "Fijar",
+      "ariaLabel": "Fijar a {{name}}"
+    },
+    "promote": {
+      "label": "Nombrar coorganizador",
+      "ariaLabel": "Nombrar coorganizador a {{name}}"
+    },
+    "demote": {
+      "label": "Retirar el rol de coorganizador",
+      "ariaLabel": "Retirar el rol de coorganizador a {{name}}"
+    }
+  },
+  "pinAnnouncements": {
+    "pin": "El vídeo de {{name}} está fijado.",
+    "unpin": "El vídeo de {{name}} ya no está fijado.",
+    "self": {
+      "pin": "Tu vídeo está fijado.",
+      "unpin": "Tu vídeo ya no está fijado."
+    }
+  },
+  "recordingStateToast": {
+    "transcript": {
+      "started": "Transcripción en curso",
+      "starting": "Iniciando la transcripción",
+      "stopping": "Deteniendo la transcripción"
+    },
+    "screen_recording": {
+      "started": "Grabación en curso",
+      "starting": "Iniciando la grabación",
+      "stopping": "Deteniendo la grabación"
+    },
+    "any": {
+      "started": "Grabación en curso"
+    },
+    "limitReachedAlert": {
+      "title": "Límite de grabación superado",
+      "description": "La grabación ha superado la duración máxima permitida{{duration_message}}. Ahora se va a guardar automáticamente.",
+      "durationMessage": " de {{duration}}",
+      "button": "Aceptar"
+    }
+  },
+  "participantTileFocus": {
+    "containerLabel": "Opciones para {{name}}",
+    "toolbarHint": "{{shortcut}}: acceder directamente a los atajos.",
+    "pin": {
+      "enable": "Fijar",
+      "disable": "Cancelar la fijación"
+    },
+    "effects": "Fondos y efectos",
+    "muteParticipant": "Silenciar el micrófono de {{name}}",
+    "fullScreen": "Pantalla completa"
+  },
+  "shortcutsPanel": {
+    "title": "Atajos de teclado",
+    "categories": {
+      "navigation": "Navegación",
+      "media": "Multimedia",
+      "interaction": "Interacción"
+    },
+    "actions": {
+      "open-shortcuts": "Abrir la ayuda de atajos",
+      "focus-toolbar": "Poner el foco en la barra de herramientas inferior",
+      "toggle-microphone": "Activar o desactivar el micrófono",
+      "toggle-camera": "Activar o desactivar la cámara",
+      "push-to-talk": "Pulsar para hablar (mantener para reactivar)",
+      "reaction": "Panel de reacciones",
+      "fullscreen": "Cambiar a pantalla completa",
+      "recording": "Mostrar u ocultar el panel de grabación",
+      "raise-hand": "Levantar o bajar la mano",
+      "toggle-chat": "Mostrar/Ocultar el chat",
+      "toggle-participants": "Mostrar/Ocultar los participantes",
+      "open-shortcuts-settings": "Abrir los ajustes de los atajos"
+    },
+    "sr": {
+      "control": "Control",
+      "command": "Comando",
+      "alt": "Alt",
+      "option": "Opción",
+      "shift": "Mayúsculas",
+      "plus": "más",
+      "hold": "Mantener {{key}}",
+      "noShortcut": "Ningún atajo"
+    },
+    "visual": {
+      "hold": "Mantener {{key}}"
+    }
+  },
+  "fullScreenWarning": {
+    "message": "Para evitar el efecto de bucle infinito, no compartas toda tu pantalla. Comparte mejor una pestaña u otra ventana.",
+    "stop": "Detener la presentación",
+    "ignore": "Ignorar"
+  },
+  "participantTile": {
+    "screenShare": "Pantalla de {{name}}"
+  }
+}
@@ -0,0 +1,18 @@
+{
+  "createMeeting": {
+    "createButton": "Crear un enlace de Visio",
+    "joinButton": "Unirse con Visio",
+    "copyLinkTooltip": "Copiar el enlace",
+    "resetLabel": "Restablecer",
+    "participantLimit": "Hasta 150 participantes.",
+    "popupBlocked": "Se ha bloqueado la ventana emergente. Permite las ventanas emergentes para este sitio.",
+    "settingsTooltip": "Configuración de la reunión"
+  },
+  "roomSettings": {
+    "title": "Configuración de la reunión",
+    "description": "Configura la reunión {{roomSlug}}.",
+    "notAllowed": "No tienes permisos para modificar la configuración de esta reunión.",
+    "error": "No se ha podido cargar la configuración de la reunión.",
+    "closeButton": "Cerrar"
+  }
+}
@@ -0,0 +1,189 @@
+{
+  "account": {
+    "currentlyLoggedAs": "Actualmente has iniciado sesión como <0>{{user}}</0>",
+    "heading": "Cuenta",
+    "youAreNotLoggedIn": "No has iniciado sesión.",
+    "nameLabel": "Tu nombre",
+    "authentication": "Autenticación",
+    "nameError": "Tu nombre no puede estar vacío"
+  },
+  "preferences": {
+    "title": "Preferencias",
+    "idleDisconnectModal": {
+      "label": "Salir de las llamadas sin ningún otro participante",
+      "description": "Te saca de una llamada al cabo de unos minutos si ningún otro participante se une"
+    },
+    "autoMuteLargeRoom": {
+      "label": "Silenciar automáticamente mi micrófono",
+      "description": "Silencia automáticamente tu micrófono cuando te unes a una reunión numerosa."
+    }
+  },
+  "audio": {
+    "microphone": {
+      "heading": "Micrófono",
+      "label": "Dispositivo de entrada de audio",
+      "disabled": "Micrófono desactivado"
+    },
+    "noiseReduction": {
+      "label": "Reducción de ruido",
+      "heading": "Reducción de ruido",
+      "ariaLabel": {
+        "enable": "Activar la reducción de ruido",
+        "disable": "Desactivar la reducción de ruido"
+      }
+    },
+    "speakers": {
+      "heading": "Altavoces",
+      "label": "Dispositivo de salida de audio",
+      "test": "Probar",
+      "ongoingTest": "Probando el sonido…",
+      "safariWarning": "La selección del altavoz todavía no está disponible en Safari debido a limitaciones del navegador."
+    },
+    "permissionsRequired": "Permisos necesarios"
+  },
+  "video": {
+    "camera": {
+      "heading": "Cámara",
+      "label": "Dispositivo de entrada de vídeo",
+      "disabled": "Cámara desactivada",
+      "previewAriaLabel": {
+        "enabled": "Vista previa de vídeo activada",
+        "disabled": "Vista previa de vídeo desactivada"
+      }
+    },
+    "resolution": {
+      "heading": "Resolución",
+      "publish": {
+        "label": "Selecciona tu resolución de envío (máx.)",
+        "items": {
+          "high": "Alta definición",
+          "medium": "Definición estándar",
+          "low": "Baja definición"
+        }
+      },
+      "subscribe": {
+        "label": "Selecciona tu resolución de recepción (máx.)",
+        "items": {
+          "high": "Alta definición (automática)",
+          "medium": "Definición estándar",
+          "low": "Baja definición"
+        }
+      }
+    },
+    "permissionsRequired": "Permisos necesarios"
+  },
+  "transcription": {
+    "heading": "Transcripción",
+    "language": {
+      "label": "Idioma de la reunión",
+      "options": {
+        "french": "Francés (fr)",
+        "english": "Inglés (en)",
+        "dutch": "Neerlandés (nl)",
+        "german": "Alemán (de)",
+        "auto": "Automático"
+      }
+    }
+  },
+  "notifications": {
+    "heading": "Notificaciones sonoras",
+    "label": "la notificación sonora para",
+    "actions": {
+      "disable": "Desactivar",
+      "enable": "Activar"
+    },
+    "items": {
+      "participantJoined": {
+        "label": "Un nuevo participante"
+      },
+      "handRaised": {
+        "label": "Una mano levantada"
+      },
+      "messageReceived": {
+        "label": "Un mensaje recibido"
+      }
+    }
+  },
+  "shortcuts": {
+    "listLabel": "Lista de atajos de teclado",
+    "columnAction": "Acción",
+    "columnShortcut": "Atajo"
+  },
+  "dialog": {
+    "heading": "Configuración"
+  },
+  "language": {
+    "heading": "Idioma",
+    "label": "Idioma de la aplicación"
+  },
+  "settingsButtonLabel": "Configuración",
+  "accessibility": {
+    "announceReactions": {
+      "label": "Vocalizar las reacciones"
+    },
+    "font": {
+      "label": "Fuente de la interfaz",
+      "description": "Personaliza la fuente utilizada en la interfaz para mejorar tu comodidad de lectura.",
+      "options": {
+        "default": "Predeterminada",
+        "lexend": "Lexend (legibilidad mejorada)",
+        "atkinson-hyperlegible": "Atkinson Hyperlegible (baja visión)",
+        "opendyslexic": "OpenDyslexic (dislexia)"
+      }
+    },
+    "captions": {
+      "heading": "Subtítulos",
+      "textSize": {
+        "label": "Tamaño del texto de los subtítulos",
+        "options": {
+          "small": "Pequeño",
+          "medium": "Mediano",
+          "large": "Grande"
+        }
+      },
+      "fontColor": {
+        "label": "Color del texto",
+        "options": {
+          "default": "Predeterminado",
+          "white": "Blanco",
+          "black": "Negro",
+          "blue": "Azul",
+          "green": "Verde",
+          "red": "Rojo",
+          "yellow": "Amarillo",
+          "cyan": "Cian",
+          "magenta": "Magenta"
+        }
+      },
+      "backgroundColor": {
+        "label": "Color de fondo",
+        "options": {
+          "default": "Predeterminado",
+          "white": "Blanco",
+          "black": "Negro",
+          "blue": "Azul",
+          "green": "Verde",
+          "red": "Rojo",
+          "yellow": "Amarillo",
+          "cyan": "Cian",
+          "magenta": "Magenta"
+        }
+      }
+    }
+  },
+  "tabs": {
+    "account": "Perfil",
+    "audio": "Audio",
+    "video": "Vídeo",
+    "general": "General",
+    "notifications": "Notificaciones",
+    "accessibility": "Accesibilidad",
+    "transcription": "Transcripción",
+    "shortcuts": "Atajos",
+    "rooms": "Reuniones"
+  },
+  "roomDefaults": {
+    "heading": "Ajustes predeterminados de las reuniones",
+    "description": "Elige la configuración que se aplica de forma predeterminada a las nuevas reuniones que crees. Siempre podrás modificarla para cada reunión desde el menu de configuración."
+  }
+}
@@ -0,0 +1,130 @@
+{
+  "title": "Condiciones de uso de Visio",
+  "articles": {
+    "article1": {
+      "title": "1. Ámbito de aplicación",
+      "content": "Este documento define las condiciones de uso de Visio (en adelante, «Visio» o «la aplicación»), una aplicación de videoconferencia diseñada especialmente para las administraciones del Estado y los organismos bajo su tutela."
+    },
+    "article2": {
+      "title": "2. Objeto de la aplicación",
+      "content": "Visio permite favorecer la cooperación de los equipos de las administraciones del Estado y de los organismos bajo su tutela, así como el trabajo a distancia, y facilitar la organización de reuniones, conferencias o formaciones.",
+      "paragraphs": [
+        "Visio está desarrollada y operada por la Dirección Interministerial de lo Digital (DINUM).",
+        "La DINUM pone la aplicación a disposición de las administraciones del Estado y de los organismos bajo su tutela, destinada a sus empleados, colaboradores y proveedores invitados.",
+        "Todo uso de Visio debe respetar estas condiciones de uso y, en su caso, la doctrina de empleo de la administración de adscripción."
+      ]
+    },
+    "article3": {
+      "title": "3. Definiciones",
+      "paragraphs": [
+        "Visio es el producto cuyo uso se describe en estas condiciones y que se presenta en la siguiente página: https://visio.numerique.gouv.fr.",
+        "Los usuarios y usuarias de Visio son toda persona que utilice Visio con fines de comunicación por videoconferencia, ya sean empleados, colaboradores o proveedores de las administraciones de adscripción. La administración de adscripción es la administración del Estado y los organismos bajo su tutela que pone Visio a disposición de sus empleados, colaboradores o proveedores.",
+        "Los organizadores y organizadoras de sala son usuarios y usuarias responsables de una sala de videoconferencia tras haber iniciado sesión mediante ProConnect.",
+        "La administración de adscripción es la administración perteneciente al sistema de información y comunicación del Estado que pone Visio a disposición de sus empleados, colaboradores o proveedores."
+      ]
+    },
+    "article4": {
+      "title": "4. Acceso al servicio",
+      "definition": "Visio se pone a disposición de los usuarios y usuarias por parte de su administración de adscripción. Los organizadores y organizadoras pueden después transmitir un enlace que permite acceder a la sala a cualquier persona, bajo su responsabilidad."
+    },
+    "article5": {
+      "title": "5. Funcionalidades",
+      "sections": {
+        "section1": {
+          "title": "5.1. Funcionalidades abiertas a los organizadores y organizadoras",
+          "content": "Visio ofrece a los empleados de las administraciones del Estado y de los organismos bajo su tutela la posibilidad de crear una sala de videoconferencia desde un puesto de trabajo estándar, vinculado a su cuenta ProConnect.",
+          "paragraph1": "A continuación puede compartir el enlace de la reunión con otras personas, usuarios y usuarias, formen parte o no de la administración.",
+          "paragraph2": "A tal efecto, cada organizador u organizadora de sala puede:",
+          "capabilities": [
+            "Proteger el acceso a la sala mediante una sala de espera;",
+            "Autorizar la entrada de cada usuario y usuaria en la sala;",
+            "Silenciar los micrófonos y las cámaras de los usuarios y usuarias;",
+            "Expulsar a un usuario o usuaria de la sala;",
+            "Utilizar la herramienta de transcripción de la reunión tras haber obtenido la conformidad de los usuarios y usuarias, bajo su responsabilidad."
+          ],
+          "paragraph3": "Los empleados deben dirigirse a su administración de adscripción para asegurarse del marco de uso dentro de Visio, en particular en lo que respecta a las reuniones sujetas a obligaciones reforzadas de confidencialidad.",
+          "paragraph4": "Los organizadores y organizadoras pueden utilizar la herramienta de transcripción automática desde el menú de configuración de la sala. Corresponde a los organizadores y organizadoras asegurarse de la conformidad de los usuarios y usuarias que participan en la reunión transcrita. El idioma de transcripción puede modificarse desde el mismo menú. Al final de la reunión, se transmite al organizador u organizadora un enlace para acceder a la transcripción conservada en la herramienta denominada Docs, operada por la DINUM."
+        },
+        "section2": {
+          "title": "5.2. Funcionalidades abiertas a los usuarios y usuarias",
+          "content": "Visio permite a todo usuario y usuaria, sea o no empleado público, participar en cualquier sala de Visio a la que le invite un organizador u organizadora y disfrutar de las funcionalidades.",
+          "paragraph": "A tal efecto, cada usuario y usuaria puede:",
+          "capabilities": [
+            "facilitar una identidad mostrada al entrar en la sala;",
+            "comunicarse a distancia por audio o vídeo;",
+            "compartir su pantalla;",
+            "intercambiar mensajes durante la sesión de forma pública con todos los usuarios y usuarias de la misma;",
+            "acceder a información técnica sobre la sala y a funcionalidades de accesibilidad;",
+            "activar o desactivar su cámara o su micrófono en cualquier momento;",
+            "proteger la intimidad de su entorno en caso de activar la cámara, seleccionando y activando un fondo de pantalla antes de entrar en la sala o incluso durante la videoconferencia."
+          ]
+        }
+      }
+    },
+    "article6": {
+      "title": "6. Compromisos y responsabilidades de los usuarios y usuarias",
+      "sections": {
+        "section1": {
+          "title": "6.1 Usos conformes",
+          "paragraphs": [
+            "Visio se pone a disposición para facilitar los intercambios profesionales entre los empleados de las administraciones del Estado y sus organismos bajo tutela y los colaboradores externos a la administración.",
+            "El usuario o la usuaria es responsable de las imágenes y los sonidos que hace accesibles en la sala de videoconferencia. Esta responsabilidad se aplica tanto a lo que la cámara o el micrófono pueden difundir como a lo que su terminal puede hacer accesible a terceros. A tal fin, el usuario o la usuaria procura utilizar la aplicación en un entorno profesional y no difundir a terceros ninguna información cubierta por la obligación de discreción profesional (por ejemplo: uso de filtro de privacidad, de auriculares, etc.).",
+            "El usuario o la usuaria es responsable de los datos o contenidos que introduce en el servicio de mensajería de la sala de videoconferencia. Procura introducir únicamente mensajes apropiados."
+          ]
+        },
+        "section2": {
+          "title": "6.2 Usos prohibidos",
+          "paragraphs": [
+            "El usuario o la usuaria se compromete a no introducir en el servicio de mensajería de la sala de Visio ni hacer accesibles mediante imagen o sonido contenidos o información contrarios a las disposiciones legales y reglamentarias vigentes."
+          ]
+        }
+      }
+    },
+    "article7": {
+      "title": "7. Compromisos y responsabilidades de la DINUM",
+      "sections": {
+        "section1": {
+          "title": "7.1. Seguridad de la aplicación",
+          "paragraphs": [
+            "La DINUM se compromete a la protección de Visio, en particular adoptando todas las medidas necesarias para garantizar la seguridad y la confidencialidad de los intercambios.",
+            "La aplicación está homologada en las condiciones previstas por el decreto n.º 2010-112 modificado."
+          ]
+        },
+        "section2": {
+          "title": "7.2. Acceso a la aplicación",
+          "paragraphs": [
+            "La DINUM se compromete a proporcionar los medios necesarios y razonables para garantizar un acceso continuo a la aplicación.",
+            "El horario de apertura de la aplicación es 24 horas al día, 7 días a la semana, salvo en los periodos de indisponibilidad por mantenimiento.",
+            "La DINUM persigue un objetivo de disponibilidad anual de la aplicación del 99,5 %, sin contar las indisponibilidades planificadas. En caso de incidencia o mantenimiento, aspira a un plazo de restablecimiento de 72 horas en horas no laborables.",
+            "En el marco de un mantenimiento del entorno de ejecución de la aplicación, la DINUM se reserva el derecho de suspender temporalmente el funcionamiento de la aplicación. En la medida de lo posible, informa a los usuarios con un mínimo de 48 horas de antelación. En caso de urgencia, esta suspensión puede producirse sin previo aviso.",
+            "Estas interrupciones excepcionales pueden ser necesarias, por ejemplo, para operaciones de gestión de datos, de puesta en producción o de cambios de arquitectura.",
+            "La indisponibilidad de la aplicación no da derecho a compensación alguna de ninguna naturaleza."
+          ]
+        },
+        "section3": {
+          "title": "7.3. Gestión del soporte",
+          "paragraphs": [
+            "La DINUM presta el soporte de primer nivel a los usuarios y usuarias, exclusivamente sobre los aspectos técnicos de la aplicación.",
+            "Se puede contactar con este soporte mediante el formulario de contacto en línea.",
+            "El objetivo de respuesta a las solicitudes es de dos días laborales desde el envío del correo electrónico; este plazo puede variar según la complejidad y el número de solicitudes que deban tramitarse."
+          ]
+        },
+        "section4": {
+          "title": "7.4. Control del uso de la aplicación",
+          "paragraphs": [
+            "La DINUM se reserva el derecho de suspender o eliminar la cuenta de un usuario o usuaria que haya incumplido estas condiciones de uso, sin perjuicio de las eventuales acciones de responsabilidad penal y civil que pudieran emprenderse contra la persona afectada. Los elementos podrían transmitirse a la administración de adscripción del usuario o la usuaria, al ser esta responsable de la puesta a disposición de la aplicación.",
+            "La suspensión o revocación de una o varias cuentas no da lugar a compensación alguna de ningún tipo."
+          ]
+        },
+        "section5": {
+          "title": "7.5. Código abierto y licencias",
+          "content": "El código fuente del servicio es libre y está disponible aquí: https://github.com/suitenumerique/meet. Los contenidos propuestos por la DINUM están bajo Licencia Abierta 2.0, a excepción de los logotipos y de las representaciones iconográficas y fotográficas, que pueden regirse por sus propias licencias."
+        }
+      }
+    },
+    "article8": {
+      "title": "8. Evolución de las condiciones de uso",
+      "content": "Los términos de estas condiciones de uso pueden modificarse o completarse en cualquier momento, sin previo aviso, en función de las modificaciones introducidas en el servicio, de la evolución de la legislación o por cualquier otro motivo que se considere necesario.\nEstas modificaciones y actualizaciones se imponen al usuario o la usuaria, que debe, en consecuencia, consultar regularmente esta sección para comprobar las condiciones vigentes."
+    }
+  }
+}
@@ -1,13 +1,14 @@
 // Map frontend language codes to backend language codes

-export type BackendLanguage = 'en-us' | 'fr-fr' | 'nl-nl' | 'de-de'
-export type FrontendLanguage = 'en' | 'fr' | 'nl' | 'de'
+export type BackendLanguage = 'en-us' | 'fr-fr' | 'nl-nl' | 'de-de' | 'es-es'
+export type FrontendLanguage = 'en' | 'fr' | 'nl' | 'de' | 'es'

 const frontendToBackendMap: Record<FrontendLanguage, BackendLanguage> = {
  en: 'en-us',
  fr: 'fr-fr',
  nl: 'nl-nl',
  de: 'de-de',
+  es: 'es-es',
 }

 export const convertToBackendLanguage = (
@@ -186,8 +186,6 @@ backend:
    CELERY_BROKER_URL: redis://default:pass@redis-master:6379/1
    # Recording & Transcription
    RECORDING_ENABLE: True
-    RECORDING_STORAGE_EVENT_ENABLE: True
-    RECORDING_STORAGE_EVENT_TOKEN: password
    SUMMARY_SERVICE_ENDPOINT: http://meet-summary:80/api/v2/async-jobs/transcribe/
    SUMMARY_SERVICE_API_TOKEN: password
    SUMMARY_SERVICE_WEBHOOK_API_TOKEN: webhook-password
@@ -113,26 +113,3 @@ spec:
            exit 0
      restartPolicy: Never
  backoffLimit: 3
---
-apiVersion: batch/v1
-kind: Job
-metadata:
-  name: minio-webhook
-spec:
-  template:
-    spec:
-      containers:
-      - name: mc
-        image: minio/mc
-        command:
-          - /bin/sh
-          - -c
-          - |
-            /usr/bin/mc alias set meet http://minio:9000 meet password && \
-            /usr/bin/mc admin config set meet notify_webhook:meet-webhook endpoint="https://meet.127.0.0.1.nip.io/api/v1.0/recordings/storage-hook/" auth_token="Bearer password" && \
-            /usr/bin/mc admin service restart meet --wait --json && \
-            sleep 15 && \
-            /usr/bin/mc event add meet/meet-media-storage arn:minio:sqs::meet-webhook:webhook --event put --prefix "recordings" && \
-            exit 0
-      restartPolicy: Never
-  backoffLimit: 3
@@ -1,12 +1,12 @@
 {
  "name": "mail_mjml",
-  "version": "1.27.0",
+  "version": "1.29.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "mail_mjml",
-      "version": "1.27.0",
+      "version": "1.29.0",
      "license": "MIT",
      "dependencies": {
        "@html-to/text-cli": "0.6.1",
@@ -1,6 +1,6 @@
 {
  "name": "mail_mjml",
-  "version": "1.27.0",
+  "version": "1.29.0",
  "description": "An util to generate html and text django's templates from mjml templates",
  "type": "module",
  "dependencies": {
@@ -1,12 +1,12 @@
 {
  "name": "sdk",
-  "version": "1.27.0",
+  "version": "1.29.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sdk",
-      "version": "1.27.0",
+      "version": "1.29.0",
      "license": "ISC",
      "workspaces": [
        "./library",
@@ -1,6 +1,6 @@
 {
  "name": "sdk",
-  "version": "1.27.0",
+  "version": "1.29.0",
  "author": "",
  "license": "ISC",
  "description": "",
@@ -22,13 +22,6 @@ Configure your env values in `env.d/summary` to properly set up WhisperX and the
 make run
 ```

-When the stack is up, configure the MinIO webhook
-*(TODO: add this step to `make bootstrap`)*
-
-```sh
-make minio-webhook-setup
-```
-
 If you want to develop on the Celery workers with hot reloading, run:

 ```sh
@@ -1,7 +1,7 @@

 [project]
 name = "summary"
-version = "1.27.0"
+version = "1.29.0"
 dependencies = [
    "fastapi[standard]>=0.105.0",
    "uvicorn>=0.24.0",
@@ -1,9 +1,10 @@
 """Analytics classes."""

 import json
+import socket
 import time
 from collections import Counter
-from functools import lru_cache
+from functools import cached_property, lru_cache
 from urllib.parse import urlsplit, urlunsplit

 import redis
@@ -33,6 +34,10 @@ 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."""
@@ -43,6 +48,8 @@ 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
Author	SHA1	Message	Date
leo	c8acc4845f	♻️(devex) update Makefile lint targets and harmonize service naming The make lint target did not cover the summary and agents components. Update the linting workflow to include both services and harmonize Makefile target names. Harmonize Docker compose user declarations.	2026-08-31 14:41:52 +02:00
snyk-bot	826cfe0c62	⬆️(frontend) upgrade @fontsource-variable/lexend from 5.2.11 to 5.3.0 Snyk has created this PR to upgrade @fontsource-variable/lexend from 5.2.11 to 5.3.0. See this package in npm: @fontsource-variable/lexend See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-31 14:10:02 +02:00
Louis-Jean Teitelbaum	ab62ae71ea	🐛(frontend) fix chat text-area bug Whenever a character was typed, the caret would jump to the end of the textarea. Fixes #1656.	2026-08-31 13:59:39 +02:00
Miguel Victoria	3991235903	More natural language on interface	2026-08-31 13:59:21 +02:00
Miguel Victoria	d2a74a20fd	chore: improve backend translations	2026-08-31 13:59:21 +02:00
Miguel Victoria	0446d1e824	update comment lines on django.po files	2026-08-31 13:59:21 +02:00
Villaquiranm	a20a0a6b38	🌐(i18n) add Spanish language support Add Spanish to the language selection system on both trees, with 872 frontend phrases and 145 backend ones translated from the French source. The frontend to backend language map gains it too, so a Spanish browser does not write an empty language to the account on every load.	2026-08-31 13:59:21 +02:00
snyk-bot	564b3dc595	⬆️(frontend) upgrade posthog-js from 1.409.5 to 1.414.0 Snyk has created this PR to upgrade posthog-js from 1.409.5 to 1.414.0. See this package in npm: posthog-js See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-31 13:56:44 +02:00
leo	0a0cdae896	✨(agent) support Voxtral realtime as inference engine The Kyutai open-source model turned out not to be production-ready: it caused disruptions in the production environment, especially on long-running meeting sessions. Switch to the Voxtral realtime model, which looks like a credible competitor and behaves much better in our setup. For now, the code handling the Voxtral realtime API lives directly in the project. It could be extracted into an open-source package later. See PR #1277 for the full details of the implementation, proposed by @cameldev.	2026-08-28 12:18:52 +02:00
leo	c7e3168ba3	🔥(backend) remove the S3 storage-event webhook for recordings Recordings used to be finalized by an inbound notifications sent by S3. This tied the recording lifecycle to bucket notifications, adding complexity and dependency to limited S3 services. The LiveKit egress_ended webhook, added as a fallback in `aee1847`, does the same job without any object-storage dependency. Make it the only mechanism: RecordingEventsService.handle_complete is now called on EGRESS_COMPLETE / EGRESS_LIMIT_REACHED unconditionally, instead of only when RECORDING_STORAGE_EVENT_ENABLE is False. Remove the storage-event path entirely.	2026-08-27 23:09:48 +02:00
lebaudantoine	f1d3799434	🔖(minor) bump release to 1.29.0	2026-08-25 23:22:29 +02:00
lebaudantoine	e59aaaa998	📝(changelog) fix a minor changelog issue Wrongly added to an old section during a rebase.	2026-08-25 23:14:16 +02:00
lebaudantoine	76a24d4787	⚡️(backend) replace blocking Redis KEYS with cursor-based SCAN `cache.keys()` runs Redis `KEYS`, a full-keyspace scan on Redis's single thread that blocks everything else, including session reads in the same cache. Its cost scales with total keys, not matches, and some managed providers disable `KEYS` entirely. The trusted-lobby feature made this urgent: the waiting-list endpoint scanned on every poll, and its polling audience grows from a few admins to potentially every authenticated participant. Switch to cursor-based `SCAN` via two `core.utils` helpers, deleting in bounded batches so cleanup of a large room cannot block either. A single seam also lets us forbid raw `cache.keys()` going forward. `SCAN` still iterates the keyspace incrementally on the polled path. If monitoring flags it, the follow-up is a per-room set index — out of scope here since it changes the lobby storage model.	2026-08-25 22:48:47 +02:00
lebaudantoine	943b81676b	✨(frontend) let authenticated users manage the lobby on trusted rooms Frontend counterpart of the trusted-lobby backend feature: on `trusted` rooms, any authenticated participant sees the waiting notification and can accept or deny entry requests, not only admins and owners. Gating moves from role to capability: `useCanManageLobby` mirrors the backend permission and derives from `useRoomData()`. Room metadata is already synced into the query cache, so an access-level change mid-meeting recomputes the capability on every client with no new sync mechanism. It is only a UI gate; the backend re-checks everything per request and fails closed. Fetching moves into a single room-level `LobbyProvider`: the hook was previously instantiated by two components and only worked because React Query deduplicated their queries. The provider owns one query and an explicit state machine - ways in (connection established, ParticipantWaiting broadcast, panel opened, rights regained while the panel is open) all arm and fetch; ways out (rights lost, server 401/403) disarm and clear the cached list so nothing stale can render. Polling is tiered by audience since managers grow from a few admins to potentially the whole room: 1s when acting (panel open), 10s when the notification is shown, and zero when the list is empty - decided in the refetchInterval callback because structural sharing suppresses data-keyed effects on identical empty responses. A quiet room costs nothing; fetches are triggered by uncorrelated human events, never synchronized across the room (the rights-regained trigger is panel-gated for this reason).	2026-08-25 22:48:47 +02:00
lebaudantoine	7369379106	✨(backend) let any authenticated user manage the lobby on trusted rooms On rooms with the `trusted` access level, any authenticated user connected to the meeting can now manage the lobby. Requested by several organizations, and a step toward generalized lobby management once hubs and groups land (same organization only). Being authenticated is not enough to grant the capability: a `trusted` room means "trusted to join", not "trusted to decide who else joins from outside the call". The new `CanManageLobby` permission therefore also requires the requester to be currently connected to the meeting, verified against LiveKit and failing closed, like `IsPresentInMeeting`. The access level itself is never cached and always read fresh, so an owner switching the room back to `restricted` revokes the capability on the very next request - the one guarantee we did not want to trade for performance. Performance is traded elsewhere: the waiting list is polled by every lobby manager, and on a trusted room that audience grows from a few admins to potentially the whole meeting. Hitting LiveKit once per poll per participant would not survive that fan-out, so presence is memoized in Redis (`PresenceCache`, `PRESENCE_CACHE_TIMEOUT`, 1h). Entries are created lazily because only the minority of participants who actually manage a lobby ever need one, and only positive answers are cached because a sticky negative would lock out someone joining right after a miss for the whole TTL. Eager invalidation on `participant_left`, `room_finished` and admin kick keeps the cache honest; the TTL is the safety net when an event is lost, and its value bounds how long a departed participant could still act. Trade-offs in this v0: * `PRESENCE_CLEAR_ON_PARTICIPANT_LEFT` gates the eager invalidation on `participant_left`: its cost is one Redis DELETE per departure, for every departure, so we want to be able to measure it in production and turn it off independently of the feature. When disabled, invalidation relies on `room_finished` and the TTL only, widening the stale window above. * This can put non-trivial pressure on the cache at scale; the rollout will need to be monitored closely. * The `participant_left` webhook must be enabled in the LiveKit deployment, otherwise eager invalidation silently degrades to the TTL-only behavior.	2026-08-25 22:48:47 +02:00
lebaudantoine	c02d54b6ff	⚡️(frontend) apply frugal constraint to the active meeting audio track Apply the `VOICE_AUDIO_CONSTRAINTS` to the audio track used during the active meeting to reduce bandwidth usage. * Originally proposed by trummerschlunk to reduce bandwidth, but previously restricted to the join screen preview. * Backport the standard voice constraints (48 kHz sample rate, mono channel, 16-bit sample size) to the active call session, as requested by the BBBA team.	2026-08-25 22:33:42 +02:00
Florent Chehab	cec2eb5a10	✨(summary) add hostname to analytics properties This helps track down what was the source of events. This can be usefull when checking perf of different workers for instance.	2026-08-25 14:48:06 +02:00
snyk-bot	2858d141f4	⬆️(frontend) upgrade posthog-js from 1.404.1 to 1.409.5 Snyk has created this PR to upgrade posthog-js from 1.404.1 to 1.409.5. See this package in npm: posthog-js See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-24 16:15:15 +02:00
snyk-bot	f10429581b	⬆️(frontend) upgrade @pandacss/preset-panda from 1.11.3 to 1.12.0 Snyk has created this PR to upgrade @pandacss/preset-panda from 1.11.3 to 1.12.0. See this package in npm: @pandacss/preset-panda See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-24 15:58:10 +02:00
snyk-bot	b3369cddf7	⬆️(frontend) upgrade @tanstack/react-query from 5.101.1 to 5.101.4 Snyk has created this PR to upgrade @tanstack/react-query from 5.101.1 to 5.101.4. See this package in npm: @tanstack/react-query See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-24 15:50:19 +02:00
snyk-bot	cfffadc780	⬆️(frontend) upgrade i18next-resources-to-backend from 1.2.1 to 1.2.3 Snyk has created this PR to upgrade i18next-resources-to-backend from 1.2.1 to 1.2.3. See this package in npm: i18next-resources-to-backend See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-24 15:41:16 +02:00
snyk-bot	4ae31b3297	⬆️(frontend) upgrade @fontsource-variable/atkinson-hyperlegible-next Snyk has created this PR to upgrade @fontsource-variable/atkinson-hyperlegible-next from 5.2.6 to 5.3.0. See this package in npm: @fontsource-variable/atkinson-hyperlegible-next See this project in Snyk: https://app.eu.snyk.io/org/lasuite-dinum-default/project/96ea03d8-8d09-493d-86bf-363f274e129e?utm_source=github&utm_medium=referral&page=upgrade-pr	2026-08-24 15:20:49 +02:00
lebaudantoine	954991c7c3	📱(frontend) improve feedback screen responsiveness on mobile Tighten the feedback screen layout on mobile viewports so it fits comfortably on small phone screens and reads naturally without horizontal scroll or cramped controls.	2026-08-24 14:51:07 +02:00
lebaudantoine	6e2a7f0ca6	📱(frontend) stack idle modal buttons in a column on mobile Wrap the buttons in the idle modal so they stack vertically on mobile viewports. The horizontal layout was cramped on small screens; a column layout gives each button a comfortable touch target and reads more naturally on narrow displays.	2026-08-24 14:51:07 +02:00
lebaudantoine	24404e4ea2	📱(frontend) collapse mobile control bar items on narrow viewports Apply the same approach as the PiP screen to the mobile control bar: make sure it never overflows on small phone screens by collapsing some controls into the overflow menu when there is not enough horizontal room.	2026-08-24 14:51:07 +02:00
lebaudantoine	f18d784615	🔖(minor) bump release to 1.28.0	2026-08-24 11:32:06 +02:00
lebaudantoine	1bfe6b8977	🔇(frontend) suppress leaked WebSocket error events from livekit-client livekit-client leaks the raw WebSocket error Event as an unhandled rejection when the signal WebSocket errors after connect. This is mostly seen on Firefox and coincides with signal reconnects. The event carries zero diagnostic content — the close reason is already logged by the SDK — so it only adds noise to error tracking. Filter it out from our reporting. Upstream issue: https://github.com/livekit/client-sdk-js/issues/2062	2026-08-23 18:12:18 +02:00