🔒️(backend) reject inactive users in resource server backend

The resource server backend returned any user matching the token's `sub` claim without checking `User.is_active`. The upstream lasuite backend only validates the token's introspection `active` claim, so a deactivated Django account kept API access until its token expired. Raise `SuspiciousOperation` in `get_or_create_user` when the user is inactive, which the authentication class turns into a 401, consistent with `BaseJWTAuthentication`. Add unit and end-to-end tests.
2026-09-29 14:09:17 +00:00 · 2026-09-09 13:47:13 +02:00
104 changed files with 594 additions and 3122 deletions
@@ -252,13 +252,13 @@ jobs:

      - name: Start MinIO
        run: |
-          docker pull quay.io/minio/minio
+          docker pull minio/minio
          docker run -d --name minio \
            -p 9000:9000 \
            -e "MINIO_ACCESS_KEY=meet" \
            -e "MINIO_SECRET_KEY=password" \
            -v /data/media:/data \
-            quay.io/minio/minio server --console-address :9001 /data
+            minio/minio server --console-address :9001 /data

      # Tool to wait for a service to be ready
      - name: Install Dockerize
@@ -86,7 +86,3 @@ docker/livekit/rootCA.pem

 # Frontend rollup-plugin-visualizer
 /src/frontend/rollup-plugin-visualizer/*
-
-# NixOS
-.devenv
-.pre-commit-config.yaml
@@ -8,55 +8,17 @@ and this project adheres to

 ## [Unreleased]

-## [1.32.1] - 2026-09-25
-
-### Fixed
-
- 🔒️(backend) fix CVE-2026-73228 and CVE-2026-73229 in drf
- 🔒️(agent) fix CRITICAL CVE-2026-63072 / CVE-2026-63073 in libssl3t64
-
-## [1.32.0] - 2026-09-25
-
-### Added
-
- ✨(backend) make the LiveKit default video codec configurable
- 🔧(dev) add support for Bureautix workstations
- ✨(frontend) add screen share zoom controls #1498
-
 ### Changed

- 🔥(backend) remove unused API viewset and permission helpers
- 🔊(backend) pin the dockerflow logger level to WARNING
- 🚑️(summary) serve health endpoints with the dockerflow router
- ♻️(backend) serve the dockerflow views early in the middleware stack
 - 📈(frontend) include LiveKit SIDs in the connection analytics event
 - 🔇(backend) silence expected 401 warnings on /me
 - 🔇(backend) silence noisy request summary info logs
- ⚡️(frontend) defer loading the Crisp script until idle
- ⬆️(frontend) upgrade react-i18next from 17.0.10 to 17.0.12
- ⬆️(frontend) upgrade posthog-js from 1.414.0 to 1.418.10
- ⬆️(addons) upgrade i18next from 26.3.6 to 26.4.0
- ⬆️(frontend) upgrade humanize-duration from 3.33.2 to 3.34.1
- ⬆️(addons) upgrade i18next from 26.4.0 to 26.4.2
- 🔖(helm) release chart 0.0.28
- ♻️(backend) decouple recording event handling from LiveKit egress statuses

 ### Fixed

- 🐛(helm) probe liveness on __lbheartbeat__ and readiness on __heartbeat__
- 🐛(helm) render periodSeconds and failureThreshold on probes
- 🐛(backend) report the app release to Sentry instead of "NA"
- 🐛(frontend) play the waiting room notification sound on every arrival
- 🐛(frontend) apply saved reception resolution when joining a meeting #1714
 - 🐛(backend) acknowledge unknown LiveKit webhook events instead of 422
 - 🔒️(backend) enforce display name setting on rename API
 - 🔒️(backend) reject inactive users in resource server backend
- 🐛(frontend) fix file permissions in the Docker image
- 🚸(frontend) inform user that recording waits until a track is published
- 🔒(backend) upgrade base image to python:3.13.5-alpine3.24
- 🐛(backend) handle failed and aborted egresses
- 🩹(frontend) notify participants when a recording fails or is aborted
- 🔒️(frontend) fix HIGH CVE-2026-93990 in libexpat

 ## [1.31.0] - 2026-09-08

@@ -1,7 +1,7 @@
 # Django Meet

 # ---- base image to inherit from ----
-FROM python:3.13.15-alpine3.24 AS base
+FROM python:3.13.5-alpine3.21 AS base

 # Upgrade pip to its latest release to speed up dependencies installation
 RUN python -m pip install --upgrade pip
@@ -292,7 +292,7 @@ shell: ## connect to database shell
 # -- Database

 dbshell: ## connect to database shell
-	@$(COMPOSE_EXEC_APP) python manage.py dbshell
+	docker compose exec app-dev python manage.py dbshell
 .PHONY: dbshell

 resetdb: FLUSH_ARGS ?=
@@ -5,7 +5,7 @@ set -eo pipefail
 REPO_DIR="$(cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd)"
 UNSET_USER=0

-export COMPOSE_FILE="${COMPOSE_FILE:-${REPO_DIR}/compose.yml}"
+COMPOSE_FILE="${REPO_DIR}/compose.yml"
 COMPOSE_PROJECT="meet"


@@ -42,6 +42,7 @@ function _docker_compose() {
    echo "🐳(compose) project: '${COMPOSE_PROJECT}' file: '${COMPOSE_FILE}'"
    docker compose \
        -p "${COMPOSE_PROJECT}" \
+        -f "${COMPOSE_FILE}" \
        --project-directory "${REPO_DIR}" \
        "$@"
 }
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+# shellcheck source=bin/_config.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
+
+_docker_compose "$@"
@@ -17,7 +17,7 @@ services:

  minio:
    user: ${DOCKER_USER:-1000}
-    image: quay.io/minio/minio
+    image: minio/minio
    environment:
      - MINIO_ROOT_USER=meet
      - MINIO_ROOT_PASSWORD=password
@@ -35,7 +35,7 @@ services:
      - ./data/media:/data

  createbuckets:
-    image: quay.io/minio/mc
+    image: minio/mc
    depends_on:
      minio:
        condition: service_healthy
@@ -1,86 +0,0 @@
-{
-  "nodes": {
-    "devenv": {
-      "locked": {
-        "dir": "src/modules",
-        "lastModified": 1778705847,
-        "narHash": "sha256-EQnZCy7r4VMO6KDoytxHBa0mFbM1D9g1kaDfs/s0YZA=",
-        "ref": "refs/tags/v2.1.2",
-        "rev": "ea3d94ac9d6bf6a1313773170122ca4e2ef5a0be",
-        "revCount": 6569,
-        "type": "git",
-        "url": "https://github.com/cachix/devenv"
-      },
-      "original": {
-        "dir": "src/modules",
-        "ref": "refs/tags/v2.1.2",
-        "type": "git",
-        "url": "https://github.com/cachix/devenv"
-      }
-    },
-    "flake-compat": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1767039857,
-        "narHash": "sha256-vNpUSpF5Nuw8xvDLj2KCwwksIbjua2LZCqhV1LNRDns=",
-        "owner": "NixOS",
-        "repo": "flake-compat",
-        "rev": "5edf11c44bc78a0d334f6334cdaf7d60d732daab",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "flake-compat",
-        "type": "github"
-      }
-    },
-    "git-hooks": {
-      "inputs": {
-        "flake-compat": "flake-compat",
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1790091288,
-        "narHash": "sha256-2dUuLTiQrf2gUFVLlayDq/hgluitplAMv6Y9bYwQQ+c=",
-        "ref": "refs/heads/master",
-        "rev": "0d3997c4d3253505f77c9bcea63904bb575da3c5",
-        "shallow": true,
-        "type": "git",
-        "url": "https://github.com/cachix/git-hooks.nix"
-      },
-      "original": {
-        "shallow": true,
-        "type": "git",
-        "url": "https://github.com/cachix/git-hooks.nix"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1790218706,
-        "narHash": "sha256-6e4Na3z008XpdVyOXgfasXIn1aN+z8AXFG+jXdQSyuI=",
-        "ref": "nixos-26.05",
-        "rev": "c508844df6c28fa6dabc1b6af70f3ccbd65c5201",
-        "shallow": true,
-        "type": "git",
-        "url": "https://github.com/NixOS/nixpkgs"
-      },
-      "original": {
-        "ref": "nixos-26.05",
-        "shallow": true,
-        "type": "git",
-        "url": "https://github.com/NixOS/nixpkgs"
-      }
-    },
-    "root": {
-      "inputs": {
-        "devenv": "devenv",
-        "git-hooks": "git-hooks",
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
@@ -1,267 +0,0 @@
-# =============================================================================
-#  devenv.nix — La Suite Meet ("Visio") developer environment
-# =============================================================================
-{
-  pkgs,
-  lib,
-  config,
-  ...
-}:
-
-let
-  python = pkgs.python313;
-  nodejs = pkgs.nodejs_22;
-
-  backendDir = "src/backend";
-  agentsDir = "src/agents";
-  summaryDir = "src/summary";
-  frontendDir = "src/frontend";
-
-  readDotEnv =
-    file:
-    let
-      lines = lib.splitString "\n" (builtins.readFile file);
-      unquote =
-        v:
-        let
-          len = builtins.stringLength v;
-        in
-        if len >= 2 && lib.hasPrefix "\"" v && lib.hasSuffix "\"" v then
-          builtins.substring 1 (len - 2) v
-        else if len >= 2 && lib.hasPrefix "'" v && lib.hasSuffix "'" v then
-          builtins.substring 1 (len - 2) v
-        else
-          v;
-      parseLine =
-        line:
-        let
-          m = builtins.match "[ \t]*([A-Za-z_][A-Za-z0-9_]*)[ \t]*=[ \t]*(.*)" line;
-        in
-        if m == null then null else { name = builtins.elemAt m 0; value = unquote (builtins.elemAt m 1); };
-    in
-    builtins.listToAttrs (builtins.filter (x: x != null) (map parseLine lines));
-
-  # Reuse existing .env
-  dotEnv =
-    (readDotEnv ./env.d/development/common.dist)
-    // (readDotEnv ./env.d/development/postgresql.dist);
-
-  sharedEnv = builtins.removeAttrs dotEnv [ "PYTHONPATH" ]; # only makes sense inside the backend container.
-in
-{
-  options.meet = {
-    agents.enable = lib.mkEnableOption "tooling for the LiveKit agents in src/agents";
-    summary.enable = lib.mkEnableOption "tooling for the summary service in src/summary";
-    k8s.enable = lib.mkEnableOption "Kubernetes dev utilities";
-  };
-
-  config = {
-    # Profile can be activated with devenv --profile <profile> shell
-    profiles = {
-      agents.module = {
-        meet.agents.enable = true;
-      };
-      summary.module = {
-        meet.summary.enable = true;
-      };
-      k8s.module = {
-        meet.k8s.enable = true;
-      };
-    };
-    languages.python = {
-      enable = true;
-      package = python;
-      directory = backendDir;
-      manylinux.enable = pkgs.stdenv.hostPlatform.isLinux;
-
-      libraries = [
-        "${config.devenv.dotfile}/profile"
-        pkgs.file
-        pkgs.zlib
-        pkgs.libffi
-        pkgs.openssl
-      ];
-
-      uv.enable = true;
-      uv.sync.enable = false;
-      venv.enable = false;
-      lsp.enable = true;
-    };
-
-    languages.javascript = {
-      enable = true;
-      package = nodejs;
-      directory = frontendDir;
-
-      npm.enable = true;
-      yarn.enable = true;
-      corepack.enable = false;
-    };
-
-    languages.typescript.enable = false;
-    languages.nix.enable = true;
-
-    git-hooks.hooks.gitlint.enable = true;
-
-    packages =
-      with pkgs;
-      [
-        gnumake
-        file
-        shared-mime-info
-        gettext
-        postgresql_16
-        git
-        curl
-        jq
-        podman
-        podman-compose
-        docker-client
-      ]
-
-      # -- LiveKit agents
-      ++ lib.optionals config.meet.agents.enable [
-        glib
-        portaudio
-        livekit-cli
-      ]
-
-      # -- summary service
-      ++ lib.optionals config.meet.summary.enable [
-        redis
-      ]
-
-      # -- Kubernetes tools
-      ++ lib.optionals config.meet.k8s.enable [
-        kubectl
-        kubernetes-helm
-        helmfile
-        tilt
-        kind
-        mkcert
-      ];
-
-    env = sharedEnv // {
-      UV_LINK_MODE = "copy";
-
-      PYTHONDONTWRITEBYTECODE = "1";
-      PYTHONUNBUFFERED = "1";
-
-      UV_PROJECT_ENVIRONMENT = lib.mkForce ".venv";
-
-      COMPOSE_PROJECT_NAME = "meet";
-
-      DJANGO_DATA_DIR = "${config.devenv.root}/data";
-
-      # Database / Pgsql
-      DB_HOST = "127.0.0.1";
-      DB_PORT = "15432";
-      PGHOST = "127.0.0.1";
-      PGPORT = "15432";
-      PGDATABASE = sharedEnv.DB_NAME;
-      PGUSER = sharedEnv.DB_USER;
-      PGPASSWORD = sharedEnv.DB_PASSWORD;
-
-      REDIS_URL = "redis://127.0.0.1:6379/1";
-      CELERY_BROKER_URL = "redis://127.0.0.1:6379/0";
-
-      # S3 / MinIO
-      AWS_S3_ENDPOINT_URL = "http://127.0.0.1:9000";
-
-      # OIDC
-      OIDC_OP_JWKS_ENDPOINT = "http://localhost:8083/realms/meet/protocol/openid-connect/certs";
-      OIDC_OP_TOKEN_ENDPOINT = "http://localhost:8083/realms/meet/protocol/openid-connect/token";
-      OIDC_OP_USER_ENDPOINT = "http://localhost:8083/realms/meet/protocol/openid-connect/userinfo";
-      OIDC_OP_INTROSPECTION_ENDPOINT = "http://localhost:8083/realms/meet/protocol/openid-connect/token/introspect";
-
-      # summary service
-      SUMMARY_SERVICE_ENDPOINT = "http://127.0.0.1:8001/api/v2/async-jobs/transcribe/";
-      SUMMARY_SERVICE_VERSION = "2";
-
-      # Mail
-      DJANGO_EMAIL_HOST = "127.0.0.1";
-    };
-
-    scripts = {
-
-      meet-venv = {
-        description = "Create/refresh meet uv virtualenvs for backend, agents and summary";
-        exec = ''
-          set -euo pipefail
-          cd "$DEVENV_ROOT"
-
-          echo "==> ${backendDir} (uv sync --locked, dependency-groups)"
-          ( cd "${backendDir}" && uv sync --locked --all-groups )
-
-          echo "==> ${agentsDir} (uv sync --locked --all-extras)"
-          ( cd "${agentsDir}" && uv sync --locked --all-extras )
-
-          echo "==> ${summaryDir} (uv sync --locked --all-extras)"
-          ( cd "${summaryDir}" && uv sync --locked --all-extras )
-
-          echo
-          echo "Synced the following virtualenvs successfully:"
-          echo "  ${backendDir}/.venv"
-          echo "  ${agentsDir}/.venv"
-          echo "  ${summaryDir}/.venv"
-        '';
-      };
-    };
-
-    enterShell = ''
-      # Make podman socket accessible in order to launch regular docker commands.
-      # Set MEET_PODMAN_SOCKET=0 to keep the DOCKER_HOST of the calling environment.
-      case "''${MEET_PODMAN_SOCKET:-1}" in
-        0|false|no|off) ;;
-        *)
-          _rundir="''${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
-          export DOCKER_HOST="unix://$_rundir/podman/podman.sock"
-          unset _rundir
-          ;;
-      esac
-
-      # Compose files to merge
-      _compose_dir="${config.devenv.root}/docker/compose.d"
-      _compose_files="${config.devenv.root}/compose.yml"
-
-      export DOCKER_USER="$(id -u):$(id -g)"
-
-      case "''${DOCKER_HOST:-}" in
-        *podman*)
-          _compose_files="$_compose_files:$_compose_dir/compose.podman.yml"
-
-          # Build images with Podman/Buildah rather than BuildKit. `docker
-          # compose build` otherwise has buildx boot a moby/buildkit container,
-          # and that container lands in its own network namespace with neither
-          # the proxy in its environment nor any route to it.
-          # Buildah has neither problem: base images are resolved by the Podman systemd
-          # service, which inherits the proxy from its systemd socket activated unit, and
-          # RUN steps execute in the *host* network namespace
-
-          export DOCKER_BUILDKIT=0
-          export COMPOSE_BAKE=false
-          ;;
-      esac
-
-
-      # Apply Bureautix override
-      if [ -n "''${http_proxy:-}" ]; then
-        _compose_files="$_compose_files:$_compose_dir/compose.bureautix.yml"
-      fi
-
-      export COMPOSE_FILE="$_compose_files"
-      unset _compose_dir _compose_files
-
-      # Make binaries accessible
-      for _d in \
-        "$DEVENV_ROOT/${backendDir}/.venv/bin" \
-        "$DEVENV_ROOT/${agentsDir}/.venv/bin" \
-        "$DEVENV_ROOT/${summaryDir}/.venv/bin" \
-        "$DEVENV_ROOT/${frontendDir}/node_modules/.bin"
-      do
-        [ -d "$_d" ] && export PATH="$_d:$PATH"
-      done
-      unset _d
-    '';
-  };
-}
@@ -1,10 +0,0 @@
-inputs:
-  nixpkgs:
-    url: git+https://github.com/NixOS/nixpkgs?ref=nixos-26.05&shallow=1
-  devenv:
-    url: git+https://github.com/cachix/devenv?ref=refs/tags/v2.1.2&dir=src/modules
-  git-hooks:
-    url: git+https://github.com/cachix/git-hooks.nix?shallow=1
-    inputs:
-      nixpkgs:
-        follows: nixpkgs
@@ -1,48 +0,0 @@
-# Bureautix proxy overrides
-#
-# Builds submitted through the Docker API of the Podman service get none of
-# the proxy variables in their RUN steps. We need to pass the http_proxy explicitely
-# otherwise all connections fail during the build.
-
-x-proxy-vars: &proxy-vars
-  http_proxy: ${http_proxy:-}
-  https_proxy: ${https_proxy:-}
-  no_proxy: ${no_proxy:-}
-
-services:
-  app:
-    build:
-      args:
-        <<: *proxy-vars
-  app-dev:
-    build:
-      args:
-        <<: *proxy-vars
-  frontend:
-    build:
-      args:
-        <<: *proxy-vars
-  metadata-collector-dev:
-    build:
-      args:
-        <<: *proxy-vars
-  multi-user-transcriber-dev:
-    build:
-      args:
-        <<: *proxy-vars
-  app-summary-dev:
-    build:
-      args:
-        <<: *proxy-vars
-  celery-summary-transcribe:
-    build:
-      args:
-        <<: *proxy-vars
-  celery-summary-summarize:
-    build:
-      args:
-        <<: *proxy-vars
-  # The local proxy listens on 8080 and collides with Keycloak's published admin port.
-  keycloak:
-    ports: !override
-      - "8081:8080"
@@ -1,33 +0,0 @@
-# Rootless Podman override for compose.yml.
-#
-# Rootless Podman maps container UID 0 to the host user and every other
-# container UID to a subuid that owns nothing in the worktree. Meet compose.ymlruns
-# its containers as DOCKER_USER=$(id -u):$(id -g), which would land on such a
-# subuid and make every bind mount effectively read-only.
-#
-# `userns_mode: keep-id` maps the host user to the same UID and GID inside the
-# container instead, so DOCKER_USER keeps its Docker value and files written
-# through a bind mount are owned by the host user on both sides.
-#
-# Only the services that mount the worktree and run as DOCKER_USER are listed.
-
-x-keep-id: &keep-id
-  userns_mode: keep-id
-
-services:
-  app-dev:
-    <<: *keep-id
-  celery-dev:
-    <<: *keep-id
-  minio:
-    <<: *keep-id
-  node:
-    <<: *keep-id
-  crowdin:
-    <<: *keep-id
-  metadata-collector-dev:
-    <<: *keep-id
-  multi-user-transcriber-dev:
-    <<: *keep-id
-  app-summary-dev:
-    <<: *keep-id
@@ -57,8 +57,7 @@ RUN npx webpack --mode production
 FROM nginxinc/nginx-unprivileged:1.30.4-alpine3.24 AS frontend-production

 USER root
-RUN apk upgrade --no-cache libexpat && \
-    apk del curl
+RUN apk del curl
 USER nginx

 USER nginx
@@ -21,10 +21,3 @@ turn:
    - 192.168.0.0/16
    - 172.16.0.0/12

-rtc:
-  node_ip: 127.0.0.1
-  advertise_internal_ip: true
-  udp_port: 7882
-  tcp_port: 7881
-  use_external_ip: false
-
@@ -10,7 +10,7 @@
      "license": "MIT",
      "dependencies": {
        "core-js": "3.50.0",
-        "i18next": "26.4.2",
+        "i18next": "26.3.6",
        "i18next-browser-languagedetector": "8.2.1",
        "regenerator-runtime": "0.14.1"
      },
@@ -9367,9 +9367,9 @@
      }
    },
    "node_modules/i18next": {
-      "version": "26.4.2",
-      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.4.2.tgz",
-      "integrity": "sha512-RX+R0VLg13IbvRuJSxnqykUFS9vQZTl8wYpWPCIUDWVrSGjsQywB5Y+pjzrkboxGAuYfJZVH1InFTdgBdxq6ug==",
+      "version": "26.3.6",
+      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.6.tgz",
+      "integrity": "sha512-Bu5Z2nAXgfVyM8xvW3jk9EKRIuX37PudsrBViThNFx7CR7aaYTpP01cxNB/E4c4UUzTDiAZRstEhsRfPOL/8xA==",
      "funding": [
        {
          "type": "individual",
@@ -27,7 +27,7 @@
  },
  "dependencies": {
    "core-js": "3.50.0",
-    "i18next": "26.4.2",
+    "i18next": "26.3.6",
    "i18next-browser-languagedetector": "8.2.1",
    "regenerator-runtime": "0.14.1"
  },
@@ -1,11 +1,9 @@
 FROM python:3.14.6-slim AS base

-# Install system dependencies required by LiveKit, fetching packages over HTTPS only for Bureautix proxy
-RUN sed -i "s|^URIs: http://|URIs: https://|" /etc/apt/sources.list.d/debian.sources \
-    && apt-get update && apt-get install -y --no-install-recommends  \
+# Install system dependencies required by LiveKit
+RUN apt-get update && apt-get install -y \
    libglib2.0-0 \
    libgobject-2.0-0 \
-    libssl3t64 \
    && rm -rf /var/lib/apt/lists/*


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

 [project]
 name = "agents"
-version = "1.32.1"
+version = "1.31.0"
 requires-python = ">=3.12"
 dependencies = [
    "livekit-agents==1.6.7",
@@ -9,7 +9,7 @@ resolution-markers = [

 [[package]]
 name = "agents"
-version = "1.32.1"
+version = "1.31.0"
 source = { virtual = "." }
 dependencies = [
    { name = "httpx" },
@@ -71,7 +71,6 @@ def get_frontend_configuration(request):
            "force_wss_protocol": settings.LIVEKIT_FORCE_WSS_PROTOCOL,
            "enable_firefox_proxy_workaround": settings.LIVEKIT_ENABLE_FIREFOX_PROXY_WORKAROUND,
            "default_sources": settings.LIVEKIT_DEFAULT_SOURCES,
-            "default_video_codec": settings.LIVEKIT_DEFAULT_VIDEO_CODEC,
        },
        "authenticated_users_can_edit_display_name": (
            settings.AUTHENTICATED_PARTICIPANTS_CAN_EDIT_DISPLAY_NAME
@@ -12,6 +12,10 @@ from ..services.participants_management import (
    ParticipantsManagementException,
 )

+ACTION_FOR_METHOD_TO_PERMISSION = {
+    "versions_detail": {"DELETE": "versions_destroy", "GET": "versions_retrieve"}
+}
+

 class IsAuthenticated(permissions.BasePermission):
    """
@@ -23,6 +27,15 @@ class IsAuthenticated(permissions.BasePermission):
        return bool(request.auth) or request.user.is_authenticated


+class IsAuthenticatedOrSafe(IsAuthenticated):
+    """Allows access to authenticated users (or anonymous users but only on safe methods)."""
+
+    def has_permission(self, request, view):
+        if request.method in permissions.SAFE_METHODS:
+            return True
+        return super().has_permission(request, view)
+
+
 class IsSelf(IsAuthenticated):
    """
    Allows access only to authenticated users. Alternative method checking the presence
@@ -95,6 +95,60 @@ from .feature_flag import FeatureFlag
 logger = getLogger(__name__)


+class NestedGenericViewSet(viewsets.GenericViewSet):
+    """
+    A generic Viewset aims to be used in a nested route context.
+    e.g: `/api/v1.0/resource_1/<resource_1_pk>/resource_2/<resource_2_pk>/`
+
+    It allows to define all url kwargs and lookup fields to perform the lookup.
+    """
+
+    lookup_fields: list[str] = ["pk"]
+    lookup_url_kwargs: list[str] = []
+
+    def __getattribute__(self, file):
+        """
+        This method is overridden to allow to get the last lookup field or lookup url kwarg
+        when accessing the `lookup_field` or `lookup_url_kwarg` attribute. This is useful
+        to keep compatibility with all methods used by the parent class `GenericViewSet`.
+        """
+        if file in ["lookup_field", "lookup_url_kwarg"]:
+            return getattr(self, file + "s", [None])[-1]
+
+        return super().__getattribute__(file)
+
+    def get_queryset(self):
+        """
+        Get the list of files for this view.
+
+        `lookup_fields` attribute is enumerated here to perform the nested lookup.
+        """
+        queryset = super().get_queryset()
+
+        # The last lookup field is removed to perform the nested lookup as it corresponds
+        # to the object pk, it is used within get_object method.
+        lookup_url_kwargs = (
+            self.lookup_url_kwargs[:-1]
+            if self.lookup_url_kwargs
+            else self.lookup_fields[:-1]
+        )
+
+        filter_kwargs = {}
+        for index, lookup_url_kwarg in enumerate(lookup_url_kwargs):
+            if lookup_url_kwarg not in self.kwargs:
+                raise KeyError(
+                    f"Expected view {self.__class__.__name__} to be called with a URL "
+                    f'keyword argument named "{lookup_url_kwarg}". Fix your URL conf, or '
+                    "set the `.lookup_fields` attribute on the view correctly."
+                )
+
+            filter_kwargs.update(
+                {self.lookup_fields[index]: self.kwargs[lookup_url_kwarg]}
+            )
+
+        return queryset.filter(**filter_kwargs)
+
+
 class SerializerPerActionMixin:
    """
    A mixin to allow to define serializer classes for each action.
@@ -1,18 +0,0 @@
-# Generated by Django 5.2.16 on 2026-09-23 16:49
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0022_user_default_room_access_level_and_more'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='recording',
-            name='status',
-            field=models.CharField(choices=[('initiated', 'Initiated'), ('active', 'Active'), ('stopped', 'Stopped'), ('saved', 'Saved'), ('aborted', 'Aborted'), ('failed', 'Failed'), ('failed_to_start', 'Failed to Start'), ('failed_to_stop', 'Failed to Stop'), ('notification_succeeded', 'Notification succeeded'), ('external_process_successful', 'External process successful'), ('external_process_failed', 'External process failed')], default='initiated', max_length=50),
-        ),
-    ]
@@ -58,7 +58,6 @@ class RecordingStatusChoices(models.TextChoices):
    STOPPED = "stopped", _("Stopped")
    SAVED = "saved", _("Saved")
    ABORTED = "aborted", _("Aborted")
-    FAILED = "failed", _("Failed")
    FAILED_TO_START = "failed_to_start", _("Failed to Start")
    FAILED_TO_STOP = "failed_to_stop", _("Failed to Stop")
    NOTIFICATION_SUCCEEDED = "notification_succeeded", _("Notification succeeded")
@@ -80,13 +79,17 @@ class RecordingStatusChoices(models.TextChoices):
            cls.STOPPED,
            cls.SAVED,
            cls.ABORTED,
-            cls.FAILED,
            cls.EXTERNAL_PROCESS_SUCCESSFUL,
            cls.EXTERNAL_PROCESS_FAILED,
            cls.FAILED_TO_START,
            cls.FAILED_TO_STOP,
        }

+    @classmethod
+    def is_unsuccessful(cls, status):
+        """Determine if the recording status represents an unsuccessful state."""
+        return status in {cls.ABORTED, cls.FAILED_TO_START, cls.FAILED_TO_STOP}
+

 class RecordingModeChoices(models.TextChoices):
    """Recording mode choices."""
@@ -579,7 +582,6 @@ class Recording(BaseModel):
    4. NOTIFICATION_SUCCEEDED: External service has been notified of this recording

    Error States:
-    - FAILED: Egress failed mid-recording
    - FAILED_TO_START: Worker failed to initialize recording
    - FAILED_TO_STOP: Worker failed during stop operation
    - ABORTED: Recording was terminated before completion
@@ -8,50 +8,3 @@ class FileExtension(Enum):

    OGG = "ogg"
    MP4 = "mp4"
-
-
-class RecordingWorkerEvent(Enum):
-    """Lifecycle events a recording worker reports about a recording.
-
-    It is intended to be free of SFU-specific vocabulary.
-    """
-
-    # The worker accepted the request but is not recording yet.
-    STARTING = "starting"
-    # The worker is recording.
-    STARTED = "started"
-    # The worker stopped recording and is flushing the media file.
-    SAVING = "saving"
-
-    # The recording ended, its media file is available.
-    COMPLETED = "completed"
-    # The recording ended on its configured limit, its media file is available.
-    LIMIT_REACHED = "limit reached"
-    # The worker stopped before it ever started recording, there is no media file.
-    ABORTED = "aborted"
-    # The worker hit a runtime error once recording had started; its media file
-    # may be available.
-    FAILED = "failed"
-
-    @classmethod
-    def is_terminal(cls, event):
-        """Determine if the event ends the recording's lifecycle (successful or not)."""
-
-        return event in TERMINAL_EVENTS
-
-
-SUCCESSFUL_EVENTS = frozenset(
-    {
-        RecordingWorkerEvent.COMPLETED,
-        RecordingWorkerEvent.LIMIT_REACHED,
-    }
-)
-
-UNSUCCESSFUL_EVENTS = frozenset(
-    {
-        RecordingWorkerEvent.ABORTED,
-        RecordingWorkerEvent.FAILED,
-    }
-)
-
-TERMINAL_EVENTS = SUCCESSFUL_EVENTS | UNSUCCESSFUL_EVENTS
@@ -1,13 +1,13 @@
-"""Recording-related Events Service"""
+"""Recording-related LiveKit Events Service"""
+
+# pylint: disable=no-member

 from logging import getLogger

+from livekit import api
+
 from core import models, utils
 from core.models import Recording
-from core.recording.enums import (
-    UNSUCCESSFUL_EVENTS,
-    RecordingWorkerEvent,
-)
 from core.recording.event.notification import notification_service
 from core.services.room_management import (
    RoomManagement,
@@ -26,110 +26,22 @@ class RecordingNotSavableError(Exception):
    """Recording cannot be saved because it is either in an error state or has already been saved"""


-# Notification sent to the room's participants, per event and recording mode.
-NOTIFICATION_PREFIXES = {
-    models.RecordingModeChoices.SCREEN_RECORDING: "screenRecording",
-    models.RecordingModeChoices.TRANSCRIPT: "transcription",
-}
-NOTIFICATION_SUFFIXES = {
-    RecordingWorkerEvent.LIMIT_REACHED: "LimitReached",
-    RecordingWorkerEvent.FAILED: "Failed",
-    RecordingWorkerEvent.ABORTED: "Aborted",
-}
-
-
-def get_notification_type(recording_mode, event):
-    """Generate corresponding notification type string."""
-    try:
-        return f"{NOTIFICATION_PREFIXES[recording_mode]}{NOTIFICATION_SUFFIXES[event]}"
-    except KeyError:
-        return None
-
-
-# Recording status in the room's metadata, per event.
-ROOM_METADATA_RECORDING_STATUSES = {
-    RecordingWorkerEvent.STARTED: "started",
-    RecordingWorkerEvent.SAVING: "saving",
-}
-
-
 class RecordingEventsService:
-    """Handles recording-related worker events.
-
-    Two entry points: `handle_update` for the events a running recording
-    reports, and `handle_terminal_event` for the one ending it.
-    """
+    """Handles recording-related LiveKit webhook events."""

    @staticmethod
-    def log_worker_error(recording, event, error=None, error_code=None):
-        """Log FAILED at error level and expected ABORTED outcomes at info level."""
-
-        if event == RecordingWorkerEvent.FAILED:
-            log = logger.error
-        elif event == RecordingWorkerEvent.ABORTED:
-            log = logger.info
-        else:
-            return
-
-        log(
-            "Recording worker reported %s for recording %s (room=%s, mode=%s): %s (error_code=%s)",
-            event.value,
-            recording.id,
-            recording.room.id,
-            recording.mode,
-            error or "no error reported",
-            error_code or "no error_code reported",
-        )
-
-    @staticmethod
-    def _notify_participants(recording: Recording, event: RecordingWorkerEvent):
-        """Notify the room's participants that a recording ended on the given event."""
-        recording_mode = recording.options.get("original_mode", None) or recording.mode
-
-        notification_type = get_notification_type(recording_mode, event)
-        if not notification_type:
-            logger.warning(
-                "Could not find notification type for: "
-                "room=%s, recording_id=%s, mode=%s, event=%s",
-                recording.room.id,
-                recording.id,
-                recording_mode,
-                event.value,
-            )
-            return
-
-        try:
-            utils.notify_participants(
-                room_name=str(recording.room.id),
-                notification_data={"type": notification_type},
-            )
-        except utils.NotificationError as e:
-            raise RecordingEventsError(
-                f"Failed to notify participants in room '{recording.room.id}' about "
-                f"recording {event.value} (recording_id={recording.id})"
-            ) from e
-
-    @staticmethod
-    def _log_notification_failure(recording, event: RecordingWorkerEvent):
-        """Log a participant notification error on an unsuccessful recording."""
-
-        logger.exception(
-            "Failed to notify participants that recording %s %s (room=%s)",
-            recording.id,
-            event.value,
-            recording.room.id,
-        )
-
-    @staticmethod
-    def handle_update(recording: Recording, event: RecordingWorkerEvent):
-        """Handle non-terminal worker events and sync recording state to room metadata.
-
-        Terminal events are dispatched through `handle_terminal_event` instead.
-        """
+    def handle_update(recording: Recording, egress_status):
+        """Handle egress status updates and sync recording state to room metadata."""

        room_name = str(recording.room.id)

-        recording_status = ROOM_METADATA_RECORDING_STATUSES.get(event)
+        status_mapping = {
+            api.EgressStatus.EGRESS_ACTIVE: "started",
+            api.EgressStatus.EGRESS_ENDING: "saving",
+            api.EgressStatus.EGRESS_ABORTED: "aborted",
+        }
+
+        recording_status = status_mapping.get(egress_status)
        if recording_status:
            try:
                RoomManagement.update_metadata(
@@ -143,113 +55,42 @@ class RecordingEventsService:
            except RoomManagementException as e:
                logger.exception("Failed to update room's metadata: %s", e)

-    def handle_terminal_event(self, recording: Recording, event: RecordingWorkerEvent):
-        """Run the appropriate handlers for a terminal event, given the recording's state."""
-
-        if not RecordingWorkerEvent.is_terminal(event):
-            logger.warning(
-                "Ignoring non-terminal event %s dispatched as a terminal event "
-                "for recording %s.",
-                event.value,
-                recording.id,
-            )
-            return
-
-        if event in UNSUCCESSFUL_EVENTS:
-            self._flag_unsuccessful_recording(recording, event)
-        else:
-            self._save_successful_recording(recording, event)
-
-    def _flag_unsuccessful_recording(
-        self, recording: Recording, event: RecordingWorkerEvent
-    ):
-        """Persist the outcome of a recording the worker announced as unsuccessful."""
-
-        # Aborted
-        if event == RecordingWorkerEvent.ABORTED:
-            if recording.status == models.RecordingStatusChoices.ACTIVE:
-                self._apply_outcome(recording, event, self._handle_aborted)
-            return
-
-        # Failed
-        if event == RecordingWorkerEvent.FAILED:
-            if recording.is_savable():
-                self._apply_outcome(recording, event, self._handle_failed)
-            return
-
-        logger.error(
-            "Unsuccessful event %s has no handler; recording %s keeps status '%s'.",
-            event.value,
-            recording.id,
-            recording.status,
-        )
-
-    def _save_successful_recording(
-        self, recording: Recording, event: RecordingWorkerEvent
-    ):
-        """Save a recording whose media file the worker made available."""
-
-        # Limit reached
-        if (
-            event == RecordingWorkerEvent.LIMIT_REACHED
-            and recording.status == models.RecordingStatusChoices.ACTIVE
-        ):
-            self._apply_outcome(recording, event, self._handle_limit_reached)
-
-        try:
-            self._handle_successful(recording)
-        except RecordingNotSavableError:
-            logger.warning(
-                "Recording %s is not savable on a completed recording "
-                "(already saved or in an error state); ignoring.",
-                recording.id,
-            )
-
-    def _apply_outcome(
-        self, recording: Recording, event: RecordingWorkerEvent, handler
-    ):
-        """Keep notification failure non-fatal."""
-
-        try:
-            handler(recording)
-        except RecordingEventsError:
-            self._log_notification_failure(recording, event)
-
-    @classmethod
-    def _handle_limit_reached(cls, recording: Recording):
+    @staticmethod
+    def handle_limit_reached(recording: Recording):
        """Stop recording and notify participants when limit is reached."""

        recording.status = models.RecordingStatusChoices.STOPPED
        recording.save()

-        cls._notify_participants(recording, RecordingWorkerEvent.LIMIT_REACHED)
+        notification_mapping = {
+            models.RecordingModeChoices.SCREEN_RECORDING: "screenRecordingLimitReached",
+            models.RecordingModeChoices.TRANSCRIPT: "transcriptionLimitReached",
+        }

-    @classmethod
-    def _handle_failed(cls, recording: Recording):
-        """Set recording status to failed, matching the worker event, and notify participants.
+        notification_type = notification_mapping.get(recording.mode)
+        if not notification_type:
+            return

-        FAILED: used when an actual runtime/pipeline error occurs after the
-        recording has started
-        """
-        recording.status = models.RecordingStatusChoices.FAILED
-        recording.save()
-
-        cls._notify_participants(recording, RecordingWorkerEvent.FAILED)
-
-    @classmethod
-    def _handle_aborted(cls, recording: Recording):
-        """Set recording status to aborted, matching the worker event, and notify participants.
-
-        ABORTED: used when the worker stops before it ever became
-        active/recording
-        """
-        recording.status = models.RecordingStatusChoices.ABORTED
-        recording.save()
-
-        cls._notify_participants(recording, RecordingWorkerEvent.ABORTED)
+        try:
+            utils.notify_participants(
+                room_name=str(recording.room.id),
+                notification_data={"type": notification_type},
+            )
+        except utils.NotificationError as e:
+            logger.exception(
+                "Failed to notify participants about recording limit reached: "
+                "room=%s, recording_id=%s, mode=%s",
+                recording.room.id,
+                recording.id,
+                recording.mode,
+            )
+            raise RecordingEventsError(
+                f"Failed to notify participants in room '{recording.room.id}' about "
+                f"recording limit reached (recording_id={recording.id})"
+            ) from e

    @staticmethod
-    def _handle_successful(recording: Recording):
+    def handle_complete(recording: Recording):
        """Notify external services and save recording."""

        if not recording.is_savable():
@@ -2,8 +2,6 @@

 # pylint: disable=no-member

-import logging
-
 from asgiref.sync import async_to_sync
 from livekit import api as livekit_api

@@ -12,8 +10,6 @@ from ..enums import FileExtension
 from .exceptions import WorkerConnectionError, WorkerResponseError
 from .factories import WorkerServiceConfig

-logger = logging.getLogger(__name__)
-

 class BaseEgressService:
    """Base egress defining common methods to manage and interact with LiveKit egress processes."""
@@ -53,22 +49,6 @@ class BaseEgressService:
        finally:
            await lkapi.aclose()

-    @staticmethod
-    def _log_egress_error(response, event: str):
-        """Log the reason LiveKit reported an unsuccessful egress on stop.
-
-        Mirrors the logging done in the 'egress_ended' webhook. The
-        StopEgress response carries the same error fields.
-        """
-        logger.error(
-            "Egress %s on stop (egress_id=%s, status=%s): %s (error_code=%s)",
-            event,
-            response.egress_id,
-            livekit_api.EgressStatus.Name(response.status),
-            response.error or "no error reported",
-            response.error_code or "no error_code reported",
-        )
-
    def stop(self, worker_id: str) -> str:
        """Stop an ongoing egress worker.
        The StopEgressRequest is shared among all types of egress,
@@ -86,26 +66,14 @@ class BaseEgressService:
                "LiveKit response is missing the recording status."
            )

+        # To avoid exposing EgressStatus values and coupling with LiveKit outside of this class,
+        # the response status is mapped to simpler "ABORTED", "STOPPED" or "FAILED_TO_STOP" strings.
+        if response.status == livekit_api.EgressStatus.EGRESS_ABORTED:
+            return "ABORTED"
+
        if response.status == livekit_api.EgressStatus.EGRESS_ENDING:
            return "STOPPED"

-        if response.status == livekit_api.EgressStatus.EGRESS_LIMIT_REACHED:
-            return "STOPPED"
-
-        # Cases below should be very infrequent as status changes should be
-        # received and processed by `handle_ended`, thus `stop` would not
-        # be called (unless failure and stop are very close in time).
-        # We therefore accept not to notify the user in this code branch.
-        # This could be fixed in a future refactoring.
-        if response.status == livekit_api.EgressStatus.EGRESS_ABORTED:
-            self._log_egress_error(response, "aborted")
-            return "ABORTED"
-
-        if response.status == livekit_api.EgressStatus.EGRESS_FAILED:
-            self._log_egress_error(response, "failed")
-            return "FAILED"
-
-        self._log_egress_error(response, "failed to stop")
        return "FAILED_TO_STOP"

    def start(self, room_name, recording_id):
@@ -12,12 +12,15 @@ from django.conf import settings
 from livekit import api

 from core import models
-from core.recording.enums import RecordingWorkerEvent
 from core.recording.services.metadata_collector import (
    MetadataCollectorException,
    MetadataCollectorService,
 )
-from core.recording.services.recording_events import RecordingEventsService
+from core.recording.services.recording_events import (
+    RecordingEventsError,
+    RecordingEventsService,
+    RecordingNotSavableError,
+)

 from .lobby import LobbyService
 from .presence import PresenceCache
@@ -81,30 +84,6 @@ class LiveKitWebhookEventType(Enum):
    INGRESS_ENDED = "ingress_ended"


-# LiveKit egress statuses mapped to recording worker event statuses
-EGRESS_STATUS_TO_RECORDING_EVENT = {
-    api.EgressStatus.EGRESS_STARTING: RecordingWorkerEvent.STARTING,
-    api.EgressStatus.EGRESS_ACTIVE: RecordingWorkerEvent.STARTED,
-    api.EgressStatus.EGRESS_ENDING: RecordingWorkerEvent.SAVING,
-    api.EgressStatus.EGRESS_COMPLETE: RecordingWorkerEvent.COMPLETED,
-    api.EgressStatus.EGRESS_LIMIT_REACHED: RecordingWorkerEvent.LIMIT_REACHED,
-    api.EgressStatus.EGRESS_ABORTED: RecordingWorkerEvent.ABORTED,
-    api.EgressStatus.EGRESS_FAILED: RecordingWorkerEvent.FAILED,
-}
-
-
-def to_recording_event(egress_status):
-    """Translate a LiveKit egress status into a recording worker event."""
-
-    event = EGRESS_STATUS_TO_RECORDING_EVENT.get(egress_status)
-    if event is None:
-        logger.warning(
-            "Unmapped LiveKit egress status '%s', ignoring the event.",
-            egress_status,
-        )
-    return event
-
-
 class LiveKitEventsService:
    """Service for processing and handling LiveKit webhook events and notifications."""

@@ -194,20 +173,12 @@ class LiveKitEventsService:
                f"Recording with worker ID {egress_id} does not exist"
            ) from err

-        event = to_recording_event(data.egress_info.status)
-        if event is None:
-            return
-
-        self.recording_events.handle_update(recording, event)
+        egress_status = data.egress_info.status
+        self.recording_events.handle_update(recording, egress_status)

    def _handle_egress_ended(self, data):
-        """Handle 'egress_ended' event.
+        """Handle 'egress_ended' event."""

-        Egress ended is sent with one of these statuses:
-        EGRESS_COMPLETE, EGRESS_FAILED, EGRESS_ABORTED, EGRESS_LIMIT_REACHED
-        """
-
-        # Fetch recording
        try:
            recording = models.Recording.objects.select_related("room").get(
                worker_id=data.egress_info.egress_id
@@ -217,17 +188,6 @@ class LiveKitEventsService:
                f"Recording with worker ID {data.egress_info.egress_id} does not exist"
            ) from err

-        event = to_recording_event(data.egress_info.status)
-
-        # Log if/why the recording failed
-        self.recording_events.log_worker_error(
-            recording,
-            event,
-            error=data.egress_info.error,
-            error_code=data.egress_info.error_code,
-        )
-
-        # Update room
        try:
            room_name = str(recording.room.id)
            RoomManagement.update_metadata(
@@ -241,17 +201,38 @@ class LiveKitEventsService:
        except RoomManagementException as e:
            logger.exception("Failed to update room's metadata: %s", e)

-        # Stop metadata collector
        if recording.options.get("metadata_collector_dispatch_id", None) is not None:
            try:
                MetadataCollectorService().stop(recording)
            except MetadataCollectorException:
                logger.warning("Failed to stop the MetadataCollectorService")

-        if event is None:
-            return
+        if (
+            data.egress_info.status == api.EgressStatus.EGRESS_LIMIT_REACHED
+            and recording.status == models.RecordingStatusChoices.ACTIVE
+        ):
+            try:
+                self.recording_events.handle_limit_reached(recording)
+            except RecordingEventsError as e:
+                raise ActionFailedError(
+                    f"Failed to process limit reached event for recording {recording}"
+                ) from e

-        self.recording_events.handle_terminal_event(recording, event)
+        # 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,
+        ]:
+            try:
+                self.recording_events.handle_complete(recording)
+            except RecordingNotSavableError:
+                logger.warning(
+                    "Recording %s is not savable on egress complete "
+                    "(already saved or in an error state); ignoring.",
+                    recording.id,
+                )
+
+        # Silently ignoring EGRESS_ABORTED, EGRESS_FAILED

    @staticmethod
    def _is_connection_test_room(room_name: str) -> bool:
@@ -76,6 +76,10 @@ class RoomManagement:

        except TwirpError as e:
            if e.code == "not_found":
+                logger.warning(
+                    "Room %s not found in LiveKit, skipping metadata update",
+                    room_name,
+                )
                raise RoomNotFoundException("Room does not exist") from e

            logger.exception(
@@ -2,23 +2,18 @@
 Test RecordingEventsService service.
 """

-# pylint: disable=redefined-outer-name,protected-access
+# pylint: disable=redefined-outer-name

-import logging
 from unittest import mock

 import pytest

 from core.factories import RecordingFactory
-from core.recording.enums import RecordingWorkerEvent
 from core.recording.services.recording_events import (
    RecordingEventsError,
    RecordingEventsService,
    RecordingNotSavableError,
 )
-from core.services.room_management import (
-    RoomManagementException,
-)
 from core.utils import NotificationError

 pytestmark = pytest.mark.django_db
@@ -39,10 +34,10 @@ def service():
 )
@mock.patch("core.utils.notify_participants")
 def test_handle_limit_reached_success(mock_notify, mode, notification_type, service):
-    """Test _handle_limit_reached stops recording and notifies participants."""
+    """Test handle_limit_reached stops recording and notifies participants."""

    recording = RecordingFactory(status="active", mode=mode)
-    service._handle_limit_reached(recording)
+    service.handle_limit_reached(recording)

    assert recording.status == "stopped"
    mock_notify.assert_called_once_with(
@@ -53,69 +48,13 @@ def test_handle_limit_reached_success(mock_notify, mode, notification_type, serv
@pytest.mark.parametrize(
    ("mode", "notification_type"),
    (
-        ("screen_recording", "screenRecordingFailed"),
-        ("transcript", "transcriptionFailed"),
+        ("screen_recording", "screenRecordingLimitReached"),
+        ("transcript", "transcriptionLimitReached"),
    ),
 )
@mock.patch("core.utils.notify_participants")
-def test_handle_failed_success(mock_notify, mode, notification_type, service):
-    """Test _handle_failed marks recording as failed and notifies participants."""
-
-    recording = RecordingFactory(status="active", mode=mode)
-    service._handle_failed(recording)
-
-    assert recording.status == "failed"
-    mock_notify.assert_called_once_with(
-        room_name=str(recording.room.id), notification_data={"type": notification_type}
-    )
-
-
-@pytest.mark.parametrize(
-    ("mode", "notification_type"),
-    (
-        ("screen_recording", "screenRecordingAborted"),
-        ("transcript", "transcriptionAborted"),
-    ),
-)
-@mock.patch("core.utils.notify_participants")
-def test_handle_aborted_success(mock_notify, mode, notification_type, service):
-    """Test _handle_aborted marks recording as aborted and notifies participants."""
-
-    recording = RecordingFactory(status="active", mode=mode)
-    service._handle_aborted(recording)
-
-    assert recording.status == "aborted"
-    mock_notify.assert_called_once_with(
-        room_name=str(recording.room.id), notification_data={"type": notification_type}
-    )
-
-
-@pytest.mark.parametrize(
-    ("mode", "notification_prefix"),
-    (("screen_recording", "screenRecording"), ("transcript", "transcription")),
-)
-@pytest.mark.parametrize(
-    ("handler", "expected_status", "event", "notification_suffix"),
-    (
-        ("_handle_limit_reached", "stopped", "limit reached", "LimitReached"),
-        ("_handle_failed", "failed", "failed", "Failed"),
-        ("_handle_aborted", "aborted", "aborted", "Aborted"),
-    ),
-)
-@mock.patch("core.utils.notify_participants")
-def test_handle_event_notification_error(  # noqa: PLR0913, PLR0917
-    mock_notify,
-    handler,
-    expected_status,
-    event,
-    notification_suffix,
-    mode,
-    notification_prefix,
-    service,
-):  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    """Test handlers raise RecordingEventsError when notifying participants fails,
-    while still applying the recording status of their event.
-    """
+def test_handle_limit_reached_error(mock_notify, mode, notification_type, service):
+    """Test handle_limit_reached raises RecordingEventsError when notification fails."""

    mock_notify.side_effect = NotificationError("Error notifying")

@@ -123,15 +62,14 @@ def test_handle_event_notification_error(  # noqa: PLR0913, PLR0917

    with pytest.raises(
        RecordingEventsError,
-        match=rf"Failed to notify participants in room '.+' "
-        rf"about recording {event} \(recording_id=.+\)",
+        match=r"Failed to notify participants in room '.+' "
+        r"about recording limit reached \(recording_id=.+\)",
    ):
-        getattr(service, handler)(recording)
+        service.handle_limit_reached(recording)

-    assert recording.status == expected_status
+    assert recording.status == "stopped"
    mock_notify.assert_called_once_with(
-        room_name=str(recording.room.id),
-        notification_data={"type": f"{notification_prefix}{notification_suffix}"},
+        room_name=str(recording.room.id), notification_data={"type": notification_type}
    )


@@ -144,19 +82,19 @@ def test_handle_event_notification_error(  # noqa: PLR0913, PLR0917
    "core.recording.services.recording_events.notification_service."
    "notify_external_services"
 )
-def test_handle_successful_saves_recording(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+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_successful notifies external services and saves a savable recording."""
+    """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_successful(recording)
+    service.handle_complete(recording)

    mock_notify_external_services.assert_called_once_with(recording)

@@ -166,293 +104,23 @@ def test_handle_successful_saves_recording(  # pylint: disable=too-many-argument

@pytest.mark.parametrize(
    "status",
-    [
-        "initiated",
-        "saved",
-        "notification_succeeded",
-        "aborted",
-        "failed",
-        "failed_to_start",
-    ],
+    ["initiated", "saved", "notification_succeeded", "aborted", "failed_to_start"],
 )
@mock.patch(
    "core.recording.services.recording_events.notification_service."
    "notify_external_services"
 )
-def test_handle_successful_non_savable_recording(
+def test_handle_complete_non_savable_recording(
    mock_notify_external_services, status, service
 ):
-    """Test _handle_successful refuses recordings that are already saved or in error."""
+    """Test handle_complete refuses recordings that are already saved or in error."""

    recording = RecordingFactory(status=status)

    with pytest.raises(RecordingNotSavableError):
-        service._handle_successful(recording)
+        service.handle_complete(recording)

    mock_notify_external_services.assert_not_called()

    recording.refresh_from_db()
    assert recording.status == status
-
-
-@pytest.mark.parametrize(
-    ("event", "recording_status"),
-    (
-        (RecordingWorkerEvent.STARTED, "started"),
-        (RecordingWorkerEvent.SAVING, "saving"),
-    ),
-)
-@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_update_syncs_room_metadata(
-    mock_update_metadata, event, recording_status, service
-):
-    """Test handle_update updates the room's metadata."""
-
-    recording = RecordingFactory(status="active")
-    service.handle_update(recording, event)
-
-    mock_update_metadata.assert_called_once_with(
-        str(recording.room.id), {"recording_status": recording_status}
-    )
-
-
-@pytest.mark.parametrize(
-    "event",
-    (
-        RecordingWorkerEvent.STARTING,
-        RecordingWorkerEvent.COMPLETED,
-        RecordingWorkerEvent.LIMIT_REACHED,
-        RecordingWorkerEvent.ABORTED,
-        RecordingWorkerEvent.FAILED,
-    ),
-)
-@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_update_ignores_events_without_a_metadata_status(
-    mock_update_metadata, event, service
-):
-    """Test handle_update doesn't update metadata for events it doesn't match."""
-
-    recording = RecordingFactory(status="active")
-    service.handle_update(recording, event)
-
-    mock_update_metadata.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    ("event", "initial_status", "expected_status", "notification_type"),
-    (
-        (RecordingWorkerEvent.LIMIT_REACHED, "active", "saved", "LimitReached"),
-        (RecordingWorkerEvent.LIMIT_REACHED, "stopped", "saved", None),
-        (RecordingWorkerEvent.LIMIT_REACHED, "saved", "saved", None),
-        (RecordingWorkerEvent.ABORTED, "active", "aborted", "Aborted"),
-        (RecordingWorkerEvent.ABORTED, "failed_to_stop", "failed_to_stop", None),
-        (RecordingWorkerEvent.FAILED, "active", "failed", "Failed"),
-        (RecordingWorkerEvent.FAILED, "stopped", "failed", "Failed"),
-        (RecordingWorkerEvent.FAILED, "aborted", "aborted", None),
-        (RecordingWorkerEvent.COMPLETED, "active", "saved", None),
-        (RecordingWorkerEvent.COMPLETED, "saved", "saved", None),
-    ),
-)
-@mock.patch(
-    "core.recording.services.recording_events.notification_service."
-    "notify_external_services"
-)
-@mock.patch("core.utils.notify_participants")
-def test_handle_terminal_event_dispatches_on_event_and_status(  # noqa: PLR0913, PLR0917
-    mock_notify,
-    mock_notify_external_services,
-    event,
-    initial_status,
-    expected_status,
-    notification_type,
-    service,
-):  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    """Test handle_terminal_event chooses the right handler from the event and status."""
-
-    mock_notify_external_services.return_value = False
-
-    recording = RecordingFactory(status=initial_status, mode="screen_recording")
-    service.handle_terminal_event(recording, event)
-
-    recording.refresh_from_db()
-    assert recording.status == expected_status
-
-    if notification_type is None:
-        mock_notify.assert_not_called()
-    else:
-        mock_notify.assert_called_once_with(
-            room_name=str(recording.room.id),
-            notification_data={"type": f"screenRecording{notification_type}"},
-        )
-
-
-@pytest.mark.parametrize(
-    "event",
-    (
-        RecordingWorkerEvent.STARTING,
-        RecordingWorkerEvent.STARTED,
-        RecordingWorkerEvent.SAVING,
-    ),
-)
-@mock.patch(
-    "core.recording.services.recording_events.notification_service."
-    "notify_external_services"
-)
-@mock.patch("core.utils.notify_participants")
-def test_handle_terminal_event_ignores_non_terminal_events(
-    mock_notify, mock_notify_external_services, event, service, caplog
-):
-    """Test handle_terminal_event refuses non-terminal events."""
-
-    recording = RecordingFactory(status="active")
-
-    with caplog.at_level(logging.WARNING):
-        service.handle_terminal_event(recording, event)
-
-    assert f"Ignoring non-terminal event {event.value}" in caplog.text
-    mock_notify.assert_not_called()
-    mock_notify_external_services.assert_not_called()
-
-    recording.refresh_from_db()
-    assert recording.status == "active"
-
-
-@pytest.mark.parametrize(
-    ("event", "expected_status"),
-    (
-        (RecordingWorkerEvent.LIMIT_REACHED, "saved"),
-        (RecordingWorkerEvent.ABORTED, "aborted"),
-        (RecordingWorkerEvent.FAILED, "failed"),
-    ),
-)
-@mock.patch(
-    "core.recording.services.recording_events.notification_service."
-    "notify_external_services"
-)
-@mock.patch("core.utils.notify_participants")
-def test_handle_terminal_event_survives_a_notification_failure(  # noqa: PLR0913, PLR0917
-    mock_notify,
-    mock_notify_external_services,
-    event,
-    expected_status,
-    service,
-    caplog,
-):  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    """Test handle_terminal_event logs a notification failure instead of raising.
-
-    The recording status must still be persisted: participants missing their
-    notification should not disturb recording.
-    """
-
-    mock_notify_external_services.return_value = False
-    mock_notify.side_effect = NotificationError("Error notifying")
-
-    recording = RecordingFactory(status="active")
-
-    with caplog.at_level(logging.ERROR):
-        service.handle_terminal_event(recording, event)
-
-    assert f"Failed to notify participants that recording {recording.id}" in caplog.text
-
-    recording.refresh_from_db()
-    assert recording.status == expected_status
-
-
-@pytest.mark.parametrize(
-    "status",
-    ["failed_to_start", "aborted", "failed", "failed_to_stop", "saved", "initiated"],
-)
-@mock.patch(
-    "core.recording.services.recording_events.notification_service."
-    "notify_external_services"
-)
-def test_handle_terminal_event_ignores_a_non_savable_recording(
-    mock_notify_external_services, status, service, caplog
-):
-    """Test handle_terminal_event handles a redelivered event idempotently.
-
-    A terminal event may be redelivered for an already finalized recording;
-    this must not raise, otherwise the webhook would 500 and be retried.
-    """
-
-    recording = RecordingFactory(status=status)
-
-    with caplog.at_level(logging.WARNING):
-        service.handle_terminal_event(recording, RecordingWorkerEvent.COMPLETED)
-
-    assert f"Recording {recording.id} is not savable" in caplog.text
-    mock_notify_external_services.assert_not_called()
-
-    recording.refresh_from_db()
-    assert recording.status == status
-
-
-@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_update_survives_a_metadata_failure(
-    mock_update_metadata, service, caplog
-):
-    """Test handle_update logs a metadata failure instead of raising."""
-
-    mock_update_metadata.side_effect = RoomManagementException("Error updating")
-
-    recording = RecordingFactory(status="active")
-
-    with caplog.at_level(logging.ERROR):
-        service.handle_update(recording, RecordingWorkerEvent.SAVING)
-
-    assert "Failed to update room's metadata" in caplog.text
-
-
-@pytest.mark.parametrize(
-    ("event", "expected_level"),
-    (
-        (RecordingWorkerEvent.ABORTED, logging.INFO),
-        (RecordingWorkerEvent.FAILED, logging.ERROR),
-    ),
-)
-def test_log_worker_error_reports_an_unsuccessful_event(
-    event, expected_level, service, caplog
-):
-    """Test log_worker_error records the reason the recording did not succeed."""
-
-    recording = RecordingFactory(status="active", mode="screen_recording")
-
-    with caplog.at_level(logging.INFO):
-        service.log_worker_error(
-            recording, event, error="could not connect to the room", error_code=500
-        )
-
-    assert (
-        f"Recording worker reported {event.value} for recording {recording.id}"
-        in caplog.text
-    )
-    assert "could not connect to the room" in caplog.text
-    assert "error_code=500" in caplog.text
-    worker_logs = [
-        record
-        for record in caplog.records
-        if record.name == "core.recording.services.recording_events"
-    ]
-    assert [record.levelno for record in worker_logs] == [expected_level]
-
-
-@pytest.mark.parametrize(
-    "event",
-    (
-        RecordingWorkerEvent.STARTING,
-        RecordingWorkerEvent.STARTED,
-        RecordingWorkerEvent.SAVING,
-        RecordingWorkerEvent.COMPLETED,
-        RecordingWorkerEvent.LIMIT_REACHED,
-        None,
-    ),
-)
-def test_log_worker_error_stays_quiet_on_anything_else(event, service, caplog):
-    """Test log_worker_error ignores events other than FAILED and ABORTED."""
-
-    recording = RecordingFactory(status="active")
-
-    with caplog.at_level(logging.INFO):
-        service.log_worker_error(recording, event, error="some error", error_code=500)
-
-    assert "Recording worker reported" not in caplog.text
@@ -224,7 +224,6 @@ def test_api_recording_retrieve_expired(settings):
        RecordingStatusChoices.INITIATED,
        RecordingStatusChoices.ACTIVE,
        RecordingStatusChoices.SAVED,
-        RecordingStatusChoices.FAILED,
        RecordingStatusChoices.FAILED_TO_START,
        RecordingStatusChoices.FAILED_TO_STOP,
        RecordingStatusChoices.ABORTED,
@@ -4,7 +4,6 @@ Test worker service classes.

 # pylint: disable=protected-access,redefined-outer-name,unused-argument,no-member

-import logging
 from unittest.mock import AsyncMock, Mock, patch

 import pytest
@@ -155,9 +154,9 @@ def test_base_egress_filepath_construction(service, filename, extension, expecte
    "response_status,expected_result",
    [
        (livekit_api.EgressStatus.EGRESS_ABORTED, "ABORTED"),
-        (livekit_api.EgressStatus.EGRESS_FAILED, "FAILED"),
        (livekit_api.EgressStatus.EGRESS_COMPLETE, "FAILED_TO_STOP"),
        (livekit_api.EgressStatus.EGRESS_ENDING, "STOPPED"),
+        (livekit_api.EgressStatus.EGRESS_FAILED, "FAILED_TO_STOP"),
    ],
 )
 def test_base_egress_stop_with_status(service, response_status, expected_result):
@@ -176,32 +175,6 @@ def test_base_egress_stop_with_status(service, response_status, expected_result)
    assert result == expected_result


-@pytest.mark.parametrize(
-    "response_status,event",
-    [
-        (livekit_api.EgressStatus.EGRESS_ABORTED, "aborted"),
-        (livekit_api.EgressStatus.EGRESS_FAILED, "failed"),
-        (livekit_api.EgressStatus.EGRESS_COMPLETE, "failed to stop"),
-    ],
-)
-def test_base_egress_stop_logs_livekit_error(service, response_status, event, caplog):
-    """Should log the reason LiveKit reported for an unsuccessful stop."""
-    mock_response = Mock(
-        status=response_status,
-        egress_id="test_worker_id",
-        error="could not connect to the room",
-        error_code=500,
-    )
-    service._handle_request = Mock(return_value=mock_response)
-
-    with caplog.at_level(logging.ERROR):
-        service.stop("test_worker_id")
-
-    assert f"Egress {event} on stop (egress_id=test_worker_id" in caplog.text
-    assert "could not connect to the room" in caplog.text
-    assert "error_code=500" in caplog.text
-
-
 def test_base_egress_stop_missing_status(service):
    """Test stop method when response is missing status"""
    # Mock _handle_request with missing status
@@ -117,11 +117,9 @@ def test_start_subtitle_invalid_token():
    assert response.json() == {"detail": "Invalid LiveKit token: Not enough segments"}


-def test_start_subtitle_disabled_by_default(mock_livekit_token, settings):
+def test_start_subtitle_disabled_by_default(mock_livekit_token):
    """Test that subtitle functionality is disabled when feature flag is off."""

-    settings.ROOM_SUBTITLE_ENABLED = False
-
    room = RoomFactory()
    user = UserFactory()
    client = APIClient()
@@ -3,7 +3,6 @@ Test LiveKitEvents service.
 """
 # pylint: disable=W0621,W0613, W0212, E0611

-import logging
 import uuid
 from unittest import mock

@@ -11,16 +10,13 @@ import pytest
 from livekit.api import EgressStatus

 from core.factories import RecordingFactory, RoomFactory
-from core.recording.enums import RecordingWorkerEvent
 from core.recording.services.recording_events import RecordingEventsService
 from core.services.livekit_events import (
-    EGRESS_STATUS_TO_RECORDING_EVENT,
    ActionFailedError,
    AuthenticationError,
    InvalidPayloadError,
    LiveKitEventsService,
    api,
-    to_recording_event,
 )
 from core.services.lobby import LobbyService
 from core.services.room_management import RoomManagementException
@@ -81,7 +77,7 @@ def test_initialization(
 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 notify all participant."""
+    """Should successfully stop recording and notifies all participant."""

    recording = RecordingFactory(worker_id="worker-1", mode=mode, status="active")
    mock_data = mock.MagicMock()
@@ -108,6 +104,7 @@ def test_handle_egress_ended_success(  # pylint: disable=too-many-arguments, too
    (
        (EgressStatus.EGRESS_ACTIVE, "started"),
        (EgressStatus.EGRESS_ENDING, "saving"),
+        (EgressStatus.EGRESS_ABORTED, "aborted"),
    ),
 )
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
@@ -128,6 +125,29 @@ def test_handle_egress_updated_success(
    )


+@pytest.mark.parametrize(
+    "egress_status",
+    (
+        EgressStatus.EGRESS_FAILED,
+        EgressStatus.EGRESS_LIMIT_REACHED,
+    ),
+)
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
+def test_handle_egress_updated_non_handled(
+    mock_update_metadata, egress_status, service
+):
+    """Should ignore certain egress status and don't trigger metadata updates."""
+
+    recording = RecordingFactory(worker_id="worker-1", status="initiated")
+    mock_data = mock.MagicMock()
+    mock_data.egress_info.egress_id = recording.worker_id
+    mock_data.egress_info.status = egress_status
+
+    service._handle_egress_updated(mock_data)
+
+    mock_update_metadata.assert_not_called()
+
+
@pytest.mark.parametrize(
    ("mode", "notification_type"),
    (
@@ -160,38 +180,33 @@ def test_handle_egress_ended_metadata_update_fails(  # pylint: disable=too-many-
    assert recording.status == "saved"


-@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")
 def test_handle_egress_ended_notification_fails(
-    mock_update_metadata, mock_notify, mock_notify_external_services, service
+    mock_update_metadata, mock_notify, service
 ):
-    """Should still stop and save the recording when notifying participants fails."""
-
-    mock_notify_external_services.return_value = False
-    mock_notify.side_effect = NotificationError("Error notifying")
+    """Should raise ActionFailedError when notification fails but still stop recording."""

    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 = EgressStatus.EGRESS_LIMIT_REACHED

-    service._handle_egress_ended(mock_data)
+    mock_notify.side_effect = NotificationError("Error notifying")
+
+    with pytest.raises(
+        ActionFailedError,
+        match=r"Failed to process limit reached event for recording .+",
+    ):
+        service._handle_egress_ended(mock_data)
+
+    recording.refresh_from_db()
+    assert recording.status == "stopped"

-    mock_notify.assert_called_once_with(
-        room_name=str(recording.room.id),
-        notification_data={"type": "screenRecordingLimitReached"},
-    )
    mock_update_metadata.assert_called_once_with(
        str(recording.room.id), remove_keys=["recording_mode", "recording_status"]
    )

-    recording.refresh_from_db()
-    assert recording.status == "saved"
-

@mock.patch("core.utils.notify_participants")
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
@@ -217,25 +232,17 @@ def test_handle_egress_ended_recording_not_found(
    assert recording.status == "active"


-@pytest.mark.parametrize(
-    "egress_status",
-    (
-        EgressStatus.EGRESS_FAILED,
-        EgressStatus.EGRESS_ABORTED,
-        EgressStatus.EGRESS_LIMIT_REACHED,
-    ),
-)
@mock.patch("core.utils.notify_participants")
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_recording_should_not_be_saved(
-    mock_update_metadata, mock_notify, egress_status, service
+def test_handle_egress_ended_recording_not_active(
+    mock_update_metadata, mock_notify, service
 ):
-    """Don't update status for recordings that must not be saved."""
+    """Should ignore non-active recordings."""

    recording = RecordingFactory(worker_id="worker-1", status="failed_to_stop")
    mock_data = mock.MagicMock()
    mock_data.egress_info.egress_id = "worker-1"
-    mock_data.egress_info.status = egress_status
+    mock_data.egress_info.status = EgressStatus.EGRESS_LIMIT_REACHED

    service._handle_egress_ended(mock_data)

@@ -248,24 +255,12 @@ def test_handle_egress_ended_recording_should_not_be_saved(
    assert recording.status == "failed_to_stop"


-@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")
-def test_handle_egress_ended_complete_does_not_notify_participants(
-    mock_update_metadata, mock_notify, mock_notify_external_services, service
+def test_handle_egress_ended_recording_not_limit_reached(
+    mock_update_metadata, mock_notify, service
 ):
-    """Shouldn't notify participants on a successful egress.
-
-    EGRESS_COMPLETE is the only ended status that notifies no one: limit
-    reached, aborted and failed egresses each send their own notification.
-    A stopped recording is simply finalized, which is the nominal flow once
-    the egress uploaded the file of a user-initiated stop.
-    """
-
-    mock_notify_external_services.return_value = False
+    """Should ignore egress non-limit-reached statuses."""

    recording = RecordingFactory(worker_id="worker-1", status="stopped")
    mock_data = mock.MagicMock()
@@ -278,10 +273,7 @@ def test_handle_egress_ended_complete_does_not_notify_participants(
    mock_update_metadata.assert_called_once_with(
        str(recording.room.id), remove_keys=["recording_mode", "recording_status"]
    )
-    mock_notify_external_services.assert_called_once_with(recording)
-
-    recording.refresh_from_db()
-    assert recording.status == "saved"
+    assert recording.status == "stopped"


@mock.patch("core.services.livekit_events.MetadataCollectorService")
@@ -341,163 +333,96 @@ def test_handle_egress_ended_does_not_call_metadata_collector_stop_when_conditio
    mock_collector.stop.assert_not_called()


-@pytest.mark.parametrize(
-    ("egress_status", "recording_status", "event", "expected_level"),
-    (
-        (EgressStatus.EGRESS_ABORTED, "active", "aborted", logging.INFO),
-        (EgressStatus.EGRESS_FAILED, "active", "failed", logging.ERROR),
-        # The synchronous stop may already have persisted the terminal status,
-        # and the error details exist only in the webhook payload.
-        (EgressStatus.EGRESS_ABORTED, "aborted", "aborted", logging.INFO),
-        (EgressStatus.EGRESS_FAILED, "failed", "failed", logging.ERROR),
-    ),
-)
-@mock.patch("core.utils.notify_participants")
-@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_logs_livekit_error(  # noqa: PLR0913, PLR0917
-    mock_update_metadata,
-    mock_notify,
-    egress_status,
-    recording_status,
-    event,
-    expected_level,
-    service,
-    caplog,
-):  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    """Should log the reason LiveKit reported an unsuccessful egress."""
-
-    recording = RecordingFactory(worker_id="worker-1", status=recording_status)
-    mock_data = mock.MagicMock()
-    mock_data.egress_info.egress_id = recording.worker_id
-    mock_data.egress_info.status = egress_status
-    mock_data.egress_info.error = "could not connect to the room"
-    mock_data.egress_info.error_code = 500
-
-    with caplog.at_level(logging.INFO):
-        service._handle_egress_ended(mock_data)
-
-    assert (
-        f"Recording worker reported {event} for recording {recording.id}" in caplog.text
-    )
-    assert "could not connect to the room" in caplog.text
-    assert "error_code=500" in caplog.text
-
-    worker_logs = [
-        record
-        for record in caplog.records
-        if record.name == "core.recording.services.recording_events"
-    ]
-    assert [record.levelno for record in worker_logs] == [expected_level]
-
-
-@pytest.mark.parametrize(
-    "egress_status",
-    (EgressStatus.EGRESS_COMPLETE, EgressStatus.EGRESS_LIMIT_REACHED),
-)
@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")
-def test_handle_egress_ended_does_not_log_error_on_successful_egress(  # noqa: PLR0913, PLR0917
+@pytest.mark.parametrize(
+    "egress_status",
+    [EgressStatus.EGRESS_COMPLETE, EgressStatus.EGRESS_LIMIT_REACHED],
+)
+@pytest.mark.parametrize(
+    "notify_return_value, recording_status",
+    [(True, "notification_succeeded"), (False, "saved")],
+)
+def test_handle_egress_ended_finalizes_recording(  # noqa: PLR0913, PLR0917
    mock_update_metadata,
    mock_notify,
    mock_notify_external_services,
+    notify_return_value,
+    recording_status,
    egress_status,
    service,
-    caplog,
 ):  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    """Shouldn't log an egress error when LiveKit reports a successful egress."""
+    """Should notify external services and save the recording on egress completion
+    (EGRESS_COMPLETE or EGRESS_LIMIT_REACHED).
+    """
+    mock_notify_external_services.return_value = notify_return_value

    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

-    with caplog.at_level(logging.ERROR):
-        service._handle_egress_ended(mock_data)
+    service._handle_egress_ended(mock_data)

-    assert "Recording worker reported" not in caplog.text
+    mock_notify_external_services.assert_called_once_with(recording)
+
+    recording.refresh_from_db()
+    assert recording.status == recording_status


-@mock.patch("core.utils.notify_participants")
+@pytest.mark.parametrize(
+    "egress_status",
+    [
+        EgressStatus.EGRESS_STARTING,
+        EgressStatus.EGRESS_ACTIVE,
+        EgressStatus.EGRESS_ENDING,
+        EgressStatus.EGRESS_FAILED,
+        EgressStatus.EGRESS_ABORTED,
+    ],
+)
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_ended_logs_livekit_error_before_cleaning_up(
-    mock_update_metadata, mock_notify, service, caplog
+def test_handle_egress_ended_does_not_save_on_wrong_status(
+    mock_update_metadata, egress_status, service
 ):
-    """Should log the failure reason even when the cleanup fails afterwards."""
-
-    mock_update_metadata.side_effect = RuntimeError("LiveKit is unreachable")
+    """Shouldn't save on invalid status."""

    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 = EgressStatus.EGRESS_FAILED
-    mock_data.egress_info.error = "could not connect to the room"
-    mock_data.egress_info.error_code = 500
+    mock_data.egress_info.status = egress_status

-    with caplog.at_level(logging.ERROR), pytest.raises(RuntimeError):
-        service._handle_egress_ended(mock_data)
+    service._handle_egress_ended(mock_data)

-    assert (
-        f"Recording worker reported failed for recording {recording.id}" in caplog.text
-    )
-    assert "could not connect to the room" in caplog.text
-
-
-def test_egress_status_mapping_covers_every_livekit_status():
-    """Every egress status LiveKit can report must translate to a recording event."""
-
-    unmapped = [
-        name
-        for name in EgressStatus.keys()
-        if getattr(EgressStatus, name) not in EGRESS_STATUS_TO_RECORDING_EVENT
-    ]
-
-    assert not unmapped
+    recording.refresh_from_db()
+    assert recording.status == "active"


@pytest.mark.parametrize(
-    ("egress_status", "expected_event"),
-    (
-        (EgressStatus.EGRESS_STARTING, RecordingWorkerEvent.STARTING),
-        (EgressStatus.EGRESS_ACTIVE, RecordingWorkerEvent.STARTED),
-        (EgressStatus.EGRESS_ENDING, RecordingWorkerEvent.SAVING),
-        (EgressStatus.EGRESS_COMPLETE, RecordingWorkerEvent.COMPLETED),
-        (EgressStatus.EGRESS_LIMIT_REACHED, RecordingWorkerEvent.LIMIT_REACHED),
-        (EgressStatus.EGRESS_ABORTED, RecordingWorkerEvent.ABORTED),
-        (EgressStatus.EGRESS_FAILED, RecordingWorkerEvent.FAILED),
-    ),
+    "status", ["failed_to_start", "aborted", "failed_to_stop", "saved", "initiated"]
 )
-def test_to_recording_event_translates_egress_status(egress_status, expected_event):
-    """Should translate a LiveKit egress status into a recording worker event."""
-
-    assert to_recording_event(egress_status) == expected_event
-
-
-def test_to_recording_event_returns_none_on_unmapped_status(caplog):
-    """Should warn and return None when LiveKit reports an unknown status."""
-
-    with caplog.at_level(logging.WARNING):
-        event = to_recording_event(999)
-
-    assert event is None
-    assert "Unmapped LiveKit egress status" in caplog.text
-
-
@mock.patch("core.services.room_management.RoomManagement.update_metadata")
-def test_handle_egress_updated_ignores_unmapped_status(mock_update_metadata, service):
-    """Shouldn't touch the room's metadata when the egress status is unknown."""
+def test_handle_egress_ended_ignores_non_savable_recording(
+    mock_update_metadata, status, service
+):
+    """Should handle non-savable recordings idempotently without raising.

-    RecordingFactory(worker_id="worker-1", status="active")
+    '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.
+    """
+
+    recording = RecordingFactory(worker_id="worker-1", status=status)
    mock_data = mock.MagicMock()
-    mock_data.egress_info.egress_id = "worker-1"
-    mock_data.egress_info.status = 999
+    mock_data.egress_info.egress_id = recording.worker_id
+    mock_data.egress_info.status = EgressStatus.EGRESS_COMPLETE

-    service._handle_egress_updated(mock_data)
+    service._handle_egress_ended(mock_data)

-    mock_update_metadata.assert_not_called()
+    recording.refresh_from_db()
+    assert recording.status == status


@mock.patch.object(LobbyService, "clear_room_cache")
@@ -1,78 +0,0 @@
-"""Tests for the Dockerflow health endpoints backing the Kubernetes probes."""
-
-from unittest import mock
-
-from django.core import checks
-from django.test.utils import override_settings
-
-import pytest
-from dockerflow.django.views import django_check_registry
-
-pytestmark = pytest.mark.django_db
-
-
-@pytest.mark.parametrize("path", ["/__lbheartbeat__", "/__heartbeat__"])
-def test_dockerflow_endpoints_are_anonymous(client, path):
-    """Both endpoints answer without authentication."""
-    response = client.get(path)
-
-    assert response.status_code == 200
-
-
-def test_dockerflow_lbheartbeat_is_a_liveness_signal(client, django_assert_num_queries):
-    """The load balancer heartbeat answers 200 without touching the database."""
-    with django_assert_num_queries(0):
-        response = client.get("/__lbheartbeat__")
-
-    assert response.status_code == 200
-
-
-def test_dockerflow_lbheartbeat_ignores_allowed_hosts(client):
-    """The probes are served before ALLOWED_HOSTS is enforced."""
-    response = client.get("/__lbheartbeat__", headers={"host": "1.2.3.4:8000"})
-
-    assert response.status_code == 200
-
-
-def test_dockerflow_heartbeat_reports_the_configured_checks(client):
-    """The heartbeat runs the database, migrations and redis checks."""
-    with override_settings(DEBUG=True):
-        response = client.get("/__heartbeat__")
-
-    assert response.status_code == 200
-
-    payload = response.json()
-    assert payload["status"] == "ok"
-    assert payload["details"] == {}
-    assert payload["checks"]["check_database_connected"] == "ok"
-    assert payload["checks"]["check_migrations_applied"] == "ok"
-
-
-def test_dockerflow_heartbeat_is_a_readiness_signal(client):
-    """A check reporting an error takes the heartbeat down with a 500."""
-
-    def failing_check(**kwargs):
-        return [checks.Error("Could not connect to database", id="health.E001")]
-
-    with mock.patch.object(
-        django_check_registry, "get_checks", return_value=[failing_check]
-    ):
-        response = client.get("/__heartbeat__")
-
-    assert response.status_code == 500
-    assert response.json()["status"] == "error"
-
-
-def test_dockerflow_heartbeat_tolerates_warnings(client):
-    """A warning in the check should not affect the probes."""
-
-    def warning_check(**kwargs):
-        return [checks.Warning("Unapplied migration", id="health.W001")]
-
-    with mock.patch.object(
-        django_check_registry, "get_checks", return_value=[warning_check]
-    ):
-        response = client.get("/__heartbeat__")
-
-    assert response.status_code == 200
-    assert response.json()["status"] == "warning"
@@ -157,7 +157,6 @@ def test_models_recording_is_savable_normal():
@pytest.mark.parametrize(
    "status",
    [
-        RecordingStatusChoices.FAILED,
        RecordingStatusChoices.FAILED_TO_STOP,
        RecordingStatusChoices.FAILED_TO_START,
        RecordingStatusChoices.ABORTED,
@@ -280,7 +279,6 @@ def test_models_recording_is_saved_false_initiated():
@pytest.mark.parametrize(
    "status",
    [
-        RecordingStatusChoices.FAILED,
        RecordingStatusChoices.FAILED_TO_STOP,
        RecordingStatusChoices.FAILED_TO_START,
        RecordingStatusChoices.ABORTED,
@@ -1,47 +0,0 @@
-"""Unit tests for the get_release settings helper."""
-
-import re
-
-import pytest
-
-from meet.settings import get_release
-
-
-@pytest.fixture(name="base_dir")
-def fixture_empty_base_dir(tmp_path, monkeypatch):
-    """Point get_release at an empty directory."""
-    monkeypatch.setattr("meet.settings.BASE_DIR", str(tmp_path))
-    return tmp_path
-
-
-def test_get_release_reads_project_pyproject():
-    """Should return the semantic version of the backend's pyproject.toml."""
-    assert re.fullmatch(r"\d+\.\d+\.\d+", get_release())
-
-
-def test_get_release_reads_pyproject_version(base_dir):
-    """Should return the version declared in the [project] table."""
-    (base_dir / "pyproject.toml").write_text(
-        '[project]\nname = "meet"\nversion = "1.2.3"\n', encoding="utf-8"
-    )
-    assert get_release() == "1.2.3"
-
-
-@pytest.mark.usefixtures("base_dir")
-def test_get_release_missing_pyproject():
-    """Should fall back to "NA" without a pyproject.toml."""
-    assert get_release() == "NA"
-
-
-@pytest.mark.parametrize(
-    "content",
-    [
-        '[project]\nname = "meet"\n',  # no version
-        "[tool.uv]\npackage = true\n",  # no [project] table
-        "[project\nversion = ",  # malformed TOML
-    ],
-)
-def test_get_release_unreadable_version(base_dir, content):
-    """Should fall back to "NA" without a readable version in pyproject.toml."""
-    (base_dir / "pyproject.toml").write_text(content, encoding="utf-8")
-    assert get_release() == "NA"
@@ -1,22 +0,0 @@
-"""Unit tests for the LIVEKIT_DEFAULT_VIDEO_CODEC setting value."""
-
-import pytest
-
-from meet.settings import VideoCodecValue
-
-
-@pytest.mark.parametrize(
-    "raw,expected",
-    [("vp9", "vp9"), ("AV1", "av1"), ("  h264  ", "h264")],
-)
-def test_video_codec_value_normalizes(raw, expected):
-    """Whitespace is trimmed and the name is lowercased before it is checked."""
-    # environ=False keeps __new__ from resolving the value, so the instance survives.
-    assert VideoCodecValue(environ=False).to_python(raw) == expected
-
-
-@pytest.mark.parametrize("raw", ["vp10", "", "h.264"])
-def test_video_codec_value_rejects_unsupported(raw):
-    """A name outside the accepted list stops the settings module loading."""
-    with pytest.raises(ValueError, match="Unsupported video codec"):
-        VideoCodecValue(environ=False).to_python(raw)
@@ -12,7 +12,7 @@ https://docs.djangoproject.com/en/3.1/ref/settings/

 # pylint: disable=too-many-lines

-import tomllib
+import json
 import warnings
 from os import path
 from socket import gethostbyname, gethostname
@@ -37,34 +37,22 @@ GB = 1024 * MB
 def get_release():
    """
    Get the current release of the application
+
+    By release, we mean the release from the version.json file à la Mozilla [1]
+    (if any). If this file has not been found, it defaults to "NA".
+
+    [1]
+    https://github.com/mozilla-services/Dockerflow/blob/master/docs/version_object.md
    """
+    # Try to get the current release from the version.json file generated by the
+    # CI during the Docker image build
    try:
-        with open(path.join(BASE_DIR, "pyproject.toml"), "rb") as pyproject:
-            return tomllib.load(pyproject)["project"]["version"]
-    except (FileNotFoundError, KeyError, tomllib.TOMLDecodeError):
+        with open(path.join(BASE_DIR, "version.json"), encoding="utf8") as version:
+            return json.load(version)["version"]
+    except FileNotFoundError:
        return "NA"  # Default: not available


-class VideoCodecValue(values.Value):
-    """
-    A video codec name, normalized to lowercase and validated against the codecs
-    supported by the LiveKit client, so that a typo fails at startup instead of
-    silently downgrading every publisher to another codec.
-    """
-
-    codecs = frozenset(("vp8", "h264", "vp9", "av1"))
-
-    def to_python(self, value):
-        """Normalize the codec name and ensure it is a supported one."""
-        codec = super().to_python(value).strip().lower()
-        if codec not in self.codecs:
-            raise ValueError(
-                f"Unsupported video codec {value!r}, "
-                f"expected one of: {', '.join(sorted(self.codecs))}."
-            )
-        return codec
-
-
 class Base(Configuration):
    """
    This is the base configuration every configuration (aka environment) should inherit from. It
@@ -287,7 +275,6 @@ class Base(Configuration):

    MIDDLEWARE = [
        "django.middleware.security.SecurityMiddleware",
-        "dockerflow.django.middleware.DockerflowMiddleware",
        "whitenoise.middleware.WhiteNoiseMiddleware",
        "django.contrib.sessions.middleware.SessionMiddleware",
        "django.middleware.locale.LocaleMiddleware",
@@ -297,6 +284,7 @@ class Base(Configuration):
        "django.middleware.csrf.CsrfViewMiddleware",
        "django.contrib.auth.middleware.AuthenticationMiddleware",
        "django.contrib.messages.middleware.MessageMiddleware",
+        "dockerflow.django.middleware.DockerflowMiddleware",
    ]

    AUTHENTICATION_BACKENDS = [
@@ -481,9 +469,6 @@ class Base(Configuration):

    # Sentry
    SENTRY_DSN = values.Value(None, environ_name="SENTRY_DSN")
-    SENTRY_TRACES_SAMPLE_RATE = values.FloatValue(
-        0.0, environ_name="SENTRY_TRACES_SAMPLE_RATE", environ_prefix=None
-    )

    # Easy thumbnails
    THUMBNAIL_EXTENSION = "webp"
@@ -690,9 +675,6 @@ class Base(Configuration):
        environ_prefix=None,
        default=False,
    )
-    LIVEKIT_DEFAULT_VIDEO_CODEC = VideoCodecValue(
-        "vp9", environ_name="LIVEKIT_DEFAULT_VIDEO_CODEC", environ_prefix=None
-    )
    CONNECTION_TEST_ENABLED = values.BooleanValue(
        environ_name="CONNECTION_TEST_ENABLED",
        environ_prefix=None,
@@ -1173,13 +1155,6 @@ class Base(Configuration):
                    environ_prefix="",
                )
            },
-            "dockerflow": {
-                "level": values.Value(
-                    "WARNING",
-                    environ_name="LOGGING_LEVEL_DOCKERFLOW",
-                    environ_prefix="",
-                )
-            },
            "core": {
                "handlers": ["console"],
                "level": values.Value(
@@ -1255,14 +1230,7 @@ class Base(Configuration):
                dsn=cls.SENTRY_DSN,
                environment=cls.__name__.lower(),  # build, test, development, production
                release=get_release(),
-                traces_sample_rate=cls.SENTRY_TRACES_SAMPLE_RATE,
-                integrations=[
-                    DjangoIntegration(
-                        transaction_style="url",
-                        middleware_spans=True,
-                        cache_spans=True,
-                    )
-                ],
+                integrations=[DjangoIntegration()],
            )
            sentry_sdk.set_tag("application", "backend")

@@ -7,7 +7,7 @@ build-backend = "uv_build"

 [project]
 name = "meet"
-version = "1.32.1"
+version = "1.31.0"
 authors = [{ "name" = "DINUM", "email" = "dev@mail.numerique.gouv.fr" }]
 classifiers = [
    "Development Status :: 5 - Production/Stable",
@@ -41,7 +41,7 @@ dependencies = [
    "django-timezone-field>=5.1",
    "django-pydantic-field==0.5.4",
    "django==5.2.16",
-    "djangorestframework==3.17.2",
+    "djangorestframework==3.17.1",
    "drf_spectacular==0.30.0",
    "dockerflow==2026.3.4",
    "easy_thumbnails==2.10.1",
@@ -754,14 +754,14 @@ wheels = [

 [[package]]
 name = "djangorestframework"
-version = "3.17.2"
+version = "3.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "django" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3b/35/c96055e700fdff25da3a7b7756cfd1d4dc54f38b9bc6d6c5e19e3a0fdc20/djangorestframework-3.17.2.tar.gz", hash = "sha256:89ed713b6dc83e1539f214b7d10808ae19bb8511004beba886225da6d5c9dafa", size = 906683, upload-time = "2026-08-05T07:47:22.5Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/d7/c016e69fac19ff8afdc89db9d31d9ae43ae031e4d1993b20aca179b8301a/djangorestframework-3.17.1.tar.gz", hash = "sha256:a6def5f447fe78ff853bff1d47a3c59bf38f5434b031780b351b0c73a62db1a5", size = 905742, upload-time = "2026-03-24T16:58:33.705Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/46/c14108e400b208c394325eb63fbae06c81341b6447fa1a6f9da718b17fe7/djangorestframework-3.17.2-py3-none-any.whl", hash = "sha256:cb0546a7415d5b46c04e0f4fe0a54b2109f4fdd5e83ca773c8c6183a6493d042", size = 899109, upload-time = "2026-08-05T07:47:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/e1/2c516bdc83652b1a60c6119366ac2c0607b479ed05cd6093f916ca8928f8/djangorestframework-3.17.1-py3-none-any.whl", hash = "sha256:c3c74dd3e83a5a3efc37b3c18d92bd6f86a6791c7b7d4dff62bb068500e76457", size = 898844, upload-time = "2026-03-24T16:58:31.845Z" },
 ]

 [[package]]
@@ -1187,7 +1187,7 @@ wheels = [

 [[package]]
 name = "meet"
-version = "1.32.1"
+version = "1.31.0"
 source = { editable = "." }
 dependencies = [
    { name = "aiohttp" },
@@ -1273,7 +1273,7 @@ requires-dist = [
    { name = "django-redis", specifier = "==7.0.0" },
    { name = "django-storages", extras = ["s3"], specifier = "==1.14.6" },
    { name = "django-timezone-field", specifier = ">=5.1" },
-    { name = "djangorestframework", specifier = "==3.17.2" },
+    { name = "djangorestframework", specifier = "==3.17.1" },
    { name = "dockerflow", specifier = "==2026.3.4" },
    { name = "drf-spectacular", specifier = "==0.30.0" },
    { name = "easy-thumbnails", specifier = "==2.10.1" },
@@ -4,12 +4,12 @@ USER node

 WORKDIR /home/frontend/

-COPY --chown=node:node ./src/frontend/package.json ./package.json
-COPY --chown=node:node ./src/frontend/package-lock.json ./package-lock.json
+COPY ./src/frontend/package.json ./package.json
+COPY ./src/frontend/package-lock.json ./package-lock.json

 RUN npm ci

-COPY --chown=node:node .dockerignore ./.dockerignore
+COPY .dockerignore ./.dockerignore
 COPY --chown=node:node ./src/frontend/ .

 ### ---- Front-end builder image ----
@@ -45,8 +45,7 @@ RUN npm run build
 FROM nginxinc/nginx-unprivileged:1.30.4-alpine3.24 AS frontend-production

 USER root
-RUN apk upgrade --no-cache libexpat && \
-    apk del curl
+RUN apk del curl
 USER nginx

 # Un-privileged user running the application
@@ -1,12 +1,12 @@
 {
  "name": "meet",
-  "version": "1.32.1",
+  "version": "1.31.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "meet",
-      "version": "1.32.1",
+      "version": "1.31.0",
      "dependencies": {
        "@fontsource-variable/atkinson-hyperlegible-next": "5.3.0",
        "@fontsource-variable/lexend": "5.3.0",
@@ -23,18 +23,18 @@
        "@timephy/rnnoise-wasm": "1.0.0",
        "crisp-sdk-web": "1.1.2",
        "hoofd": "1.7.3",
-        "humanize-duration": "3.34.1",
+        "humanize-duration": "3.33.2",
        "i18next": "26.3.6",
        "i18next-browser-languagedetector": "8.2.1",
        "i18next-parser": "9.4.0",
        "i18next-resources-to-backend": "1.2.3",
        "livekit-client": "2.21.0",
-        "posthog-js": "1.418.10",
+        "posthog-js": "1.414.0",
        "react": "18.3.1",
        "react-aria": "3.50.0",
        "react-aria-components": "1.19.0",
        "react-dom": "18.3.1",
-        "react-i18next": "17.0.12",
+        "react-i18next": "17.0.10",
        "react-stately": "3.48.0",
        "use-sound": "5.0.0",
        "valtio": "2.3.2",
@@ -1720,28 +1720,28 @@
      "license": "MIT"
    },
    "node_modules/@posthog/browser-common": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/@posthog/browser-common/-/browser-common-0.5.2.tgz",
-      "integrity": "sha512-8GvfEshFdeKIccuy3kpp6mDBxawQtRamMYRCwzy1r1ixLKQVLAGs3afhOf6r75yp59ZQBi5mtXQgUJ2Jz8eHuw==",
+      "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/core": "^1.48.11",
-        "@posthog/types": "^1.405.3"
+        "@posthog/core": "^1.46.8",
+        "@posthog/types": "^1.402.0"
      }
    },
    "node_modules/@posthog/core": {
-      "version": "1.53.2",
-      "resolved": "https://registry.npmjs.org/@posthog/core/-/core-1.53.2.tgz",
-      "integrity": "sha512-Knx8442G2LyPVIzLvhcBX/TIdeHpZhrYrtZou3Uw8FWfbr9gQtQeOZDCog3MWcDxJ+4vAnMAAOzf5cYpc7Gxyw==",
+      "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.411.1"
+        "@posthog/types": "^1.407.0"
      }
    },
    "node_modules/@posthog/types": {
-      "version": "1.411.1",
-      "resolved": "https://registry.npmjs.org/@posthog/types/-/types-1.411.1.tgz",
-      "integrity": "sha512-Gd7tnSYctcSXup3naVlAgavvenByRao6rsSYdMgWgP35KE9jFn+rMHNRJeI5LNjJuLzMXHEVcgzAN7xcATefdw==",
+      "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": {
@@ -6354,12 +6354,11 @@
      "integrity": "sha512-iARIBPgcQrwtEr+tALF+rapJ8qSc+Set2GJQl7xT1MQzWaVkFebdJhR3alVlSiUf5U7nAANKuj3aWpwerocD5w=="
    },
    "node_modules/html-parse-stringify": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/html-parse-stringify/-/html-parse-stringify-4.0.1.tgz",
-      "integrity": "sha512-0zHsZJrK7S3K2aucXWL6ycoYJ/iNtIcFHC/nYQgFklPtrv5LpJctIiSCroWZWeuoXvuyFdzp6KzjJQ+OT5MfFw==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://locize.com"
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/html-parse-stringify/-/html-parse-stringify-3.0.1.tgz",
+      "integrity": "sha512-KknJ50kTInJ7qIScF3jeaFRpMpE8/lfiTdzf/twXyPBLAGrLRTmkz3AdTnKeh40X8k9L2fdYwEp/42WGXIRGcg==",
+      "dependencies": {
+        "void-elements": "3.1.0"
      }
    },
    "node_modules/htmlparser2": {
@@ -6402,9 +6401,9 @@
      }
    },
    "node_modules/humanize-duration": {
-      "version": "3.34.1",
-      "resolved": "https://registry.npmjs.org/humanize-duration/-/humanize-duration-3.34.1.tgz",
-      "integrity": "sha512-YIiigjQ+O31rvcyDJPK1ptTZtvSErjBtmHy93VhbwxB/VwMG0FszKs2IB667tFxmOhNapePQQxa24luQRDkKFQ==",
+      "version": "3.33.2",
+      "resolved": "https://registry.npmjs.org/humanize-duration/-/humanize-duration-3.33.2.tgz",
+      "integrity": "sha512-K7Ny/ULO1hDm2nnhvAY+SJV1skxFb61fd073SG1IWJl+D44ULrruCuTyjHKjBVVcSuTlnY99DKtgEG39CM5QOQ==",
      "license": "Unlicense",
      "funding": {
        "url": "https://github.com/sponsors/EvanHahn"
@@ -9132,16 +9131,16 @@
      "license": "MIT"
    },
    "node_modules/posthog-js": {
-      "version": "1.418.10",
-      "resolved": "https://registry.npmjs.org/posthog-js/-/posthog-js-1.418.10.tgz",
-      "integrity": "sha512-XMvmmnuFoesSPjFo+wvzXkvuzYqIho8CVqxugG1Wt768offFARYNZDd1/xWfm9vk/pJTJ4RhUEHRzLpggmGx9Q==",
+      "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/browser-common": "^0.5.0",
-        "@posthog/core": "^1.48.8",
-        "@posthog/types": "^1.405.1",
+        "@posthog/browser-common": "^0.4.0",
+        "@posthog/core": "^1.46.9",
+        "@posthog/types": "^1.402.2",
        "core-js": "^3.49.0",
-        "dompurify": "^3.4.13",
+        "dompurify": "^3.4.12",
        "fflate": "^0.4.8",
        "preact": "^10.29.3",
        "query-selector-shadow-dom": "^1.0.1",
@@ -9436,13 +9435,13 @@
      }
    },
    "node_modules/react-i18next": {
-      "version": "17.0.12",
-      "resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.12.tgz",
-      "integrity": "sha512-lFWPEGkxQ6RhusdUkysFBD58VHfSSzvHBzqMgN0SvfVpdQGfwtNkStTqdy08/sJd7s807qqutgx93fRpD0DJ3Q==",
+      "version": "17.0.10",
+      "resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.10.tgz",
+      "integrity": "sha512-XneHftyYA774MJkkccSkZ5oKrUpCnXIPmxio3wemqrVzCRLWiGXOMbIzObrer03fNDEnm8g8R5yYls4HcE+esg==",
      "license": "MIT",
      "dependencies": {
-        "@babel/runtime": "^7.29.7",
-        "html-parse-stringify": "^4.0.1",
+        "@babel/runtime": "^7.29.2",
+        "html-parse-stringify": "^3.0.1",
        "use-sync-external-store": "^1.6.0"
      },
      "peerDependencies": {
@@ -11609,6 +11608,14 @@
        "url": "https://github.com/sponsors/jonschlinkert"
      }
    },
+    "node_modules/void-elements": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/void-elements/-/void-elements-3.1.0.tgz",
+      "integrity": "sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
    "node_modules/walk-sync": {
      "version": "2.2.0",
      "resolved": "https://registry.npmjs.org/walk-sync/-/walk-sync-2.2.0.tgz",
@@ -1,7 +1,7 @@
 {
  "name": "meet",
  "private": true,
-  "version": "1.32.1",
+  "version": "1.31.0",
  "type": "module",
  "scripts": {
    "dev": "panda codegen && vite",
@@ -30,18 +30,18 @@
    "@timephy/rnnoise-wasm": "1.0.0",
    "crisp-sdk-web": "1.1.2",
    "hoofd": "1.7.3",
-    "humanize-duration": "3.34.1",
+    "humanize-duration": "3.33.2",
    "i18next": "26.3.6",
    "i18next-browser-languagedetector": "8.2.1",
    "i18next-parser": "9.4.0",
    "i18next-resources-to-backend": "1.2.3",
    "livekit-client": "2.21.0",
-    "posthog-js": "1.418.10",
+    "posthog-js": "1.414.0",
    "react": "18.3.1",
    "react-aria": "3.50.0",
    "react-aria-components": "1.19.0",
    "react-dom": "18.3.1",
-    "react-i18next": "17.0.12",
+    "react-i18next": "17.0.10",
    "react-stately": "3.48.0",
    "use-sound": "5.0.0",
    "valtio": "2.3.2",
@@ -3,7 +3,7 @@ import { keys } from './queryKeys'
 import { useQuery } from '@tanstack/react-query'
 import { RecordingMode } from '@/features/recording'
 import type { ApiAccessLevel } from '@/features/rooms/api/ApiRoom'
-import type { Track, VideoCodec } from 'livekit-client'
+import type { Track } from 'livekit-client'
 type Source = Track.Source

 export interface ApiConfig {
@@ -62,7 +62,6 @@ export interface ApiConfig {
    force_wss_protocol: boolean
    enable_firefox_proxy_workaround: boolean
    default_sources: Source[]
-    default_video_codec: VideoCodec
  }
  transcription_destination?: string
  max_participants_for_sound: number
@@ -96,10 +96,6 @@ export const MainNotificationToast = () => {
        case NotificationType.ScreenRecordingStopped:
        case NotificationType.TranscriptionLimitReached:
        case NotificationType.ScreenRecordingLimitReached:
-        case NotificationType.TranscriptionFailed:
-        case NotificationType.ScreenRecordingFailed:
-        case NotificationType.TranscriptionAborted:
-        case NotificationType.ScreenRecordingAborted:
          toastQueue.add(
            {
              participant,
@@ -1,6 +1,5 @@
 import { Div } from '@/primitives'
 import { ToastProvider } from './components/ToastProvider'
-import { RecordingWaitingForTracksNotification } from './components/RecordingWaitingForTracksNotification'
 import { WaitingParticipantNotification } from './components/WaitingParticipantNotification'

 export const NotificationProvider = ({
@@ -13,6 +12,5 @@ export const NotificationProvider = ({
  <Div position="absolute" bottom={bottom} right={right} zIndex={1000}>
    <ToastProvider />
    <WaitingParticipantNotification />
-    <RecordingWaitingForTracksNotification />
  </Div>
 )
@@ -10,15 +10,11 @@ export enum NotificationType {
  TranscriptionStarted = 'transcriptionStarted',
  TranscriptionStopped = 'transcriptionStopped',
  TranscriptionLimitReached = 'transcriptionLimitReached',
-  TranscriptionFailed = 'transcriptionFailed',
-  TranscriptionAborted = 'transcriptionAborted',
  TranscriptionRequested = 'transcriptionRequested',
  ScreenRecordingStarted = 'screenRecordingStarted',
  ScreenRecordingStopped = 'screenRecordingStopped',
  ScreenRecordingRequested = 'screenRecordingRequested',
  ScreenRecordingLimitReached = 'screenRecordingLimitReached',
-  ScreenRecordingFailed = 'screenRecordingFailed',
-  ScreenRecordingAborted = 'screenRecordingAborted',
  RecordingSaving = 'recordingSaving',
  PermissionsRemoved = 'permissionsRemoved',
  RoleChanged = 'roleChanged',
@@ -1,41 +0,0 @@
-import { useTranslation } from 'react-i18next'
-import { Text } from '@/primitives'
-import { css } from '@/styled-system/css'
-import { HStack } from '@/styled-system/jsx'
-import { RecordingMode } from '@/features/recording'
-import { useRecordingWaitingForTracks } from '@/features/recording/hooks/useRecordingWaitingForTracks'
-import { StyledToastContainer } from './StyledToastContainer'
-
-export const RecordingWaitingForTracksNotification = () => {
-  const { t } = useTranslation('notifications')
-  const isTranscriptWaiting = useRecordingWaitingForTracks(
-    RecordingMode.Transcript
-  )
-  const isScreenRecordingWaiting = useRecordingWaitingForTracks(
-    RecordingMode.ScreenRecording
-  )
-
-  if (!isTranscriptWaiting && !isScreenRecordingWaiting) return null
-
-  return (
-    <StyledToastContainer role="status">
-      <HStack padding={14}>
-        <Text
-          margin={false}
-          className={css({
-            maxWidth: '22rem',
-            wordBreak: 'break-word',
-            overflowWrap: 'break-word',
-            whiteSpace: 'normal',
-          })}
-        >
-          {t(
-            isTranscriptWaiting
-              ? 'transcript.waitingForTracks'
-              : 'screenRecording.waitingForTracks'
-          )}
-        </Text>
-      </HStack>
-    </StyledToastContainer>
-  )
-}
@@ -22,20 +22,12 @@ export function ToastAnyRecording({ state, ...props }: Readonly<ToastProps>) {
        return 'transcript.stopped'
      case NotificationType.TranscriptionLimitReached:
        return 'transcript.limitReached'
-      case NotificationType.TranscriptionFailed:
-        return 'transcript.failed'
-      case NotificationType.TranscriptionAborted:
-        return 'transcript.aborted'
      case NotificationType.ScreenRecordingStarted:
        return 'screenRecording.started'
      case NotificationType.ScreenRecordingStopped:
        return 'screenRecording.stopped'
      case NotificationType.ScreenRecordingLimitReached:
        return 'screenRecording.limitReached'
-      case NotificationType.ScreenRecordingFailed:
-        return 'screenRecording.failed'
-      case NotificationType.ScreenRecordingAborted:
-        return 'screenRecording.aborted'
      default:
        return
    }
@@ -58,10 +58,6 @@ const renderToast = (
    case NotificationType.ScreenRecordingStarted:
    case NotificationType.ScreenRecordingStopped:
    case NotificationType.ScreenRecordingLimitReached:
-    case NotificationType.TranscriptionFailed:
-    case NotificationType.ScreenRecordingFailed:
-    case NotificationType.TranscriptionAborted:
-    case NotificationType.ScreenRecordingAborted:
      return <ToastAnyRecording key={toast.key} toast={toast} state={state} />

    case NotificationType.TranscriptionRequested:
@@ -34,15 +34,6 @@ export const WaitingParticipantNotification = () => {
  const isParticipantListEmpty = (p?: WaitingParticipant[]) => p?.length == 0

  useEffect(() => {
-    const previousIds = new Set(prevWaitingParticipant?.map(({ id }) => id))
-    const hasNewWaitingParticipant = waitingParticipants.some(
-      ({ id }) => !previousIds.has(id)
-    )
-
-    if (hasNewWaitingParticipant) {
-      triggerNotificationSound(NotificationType.ParticipantWaiting)
-    }
-
    // Show notification when the first participant enters the waiting room
    if (
      !isParticipantListEmpty(waitingParticipants) &&
@@ -51,6 +42,8 @@ export const WaitingParticipantNotification = () => {
    ) {
      setShowQuickActionsMessage(true)

+      triggerNotificationSound(NotificationType.ParticipantJoined)
+
      if (timerRef.current !== null) {
        clearTimeout(timerRef.current)
      }
@@ -11,7 +11,7 @@ export const useNotificationSound = () => {
      participantJoined: [0, 1150],
      handRaised: [1400, 180],
      messageReceived: [1580, 300],
-      participantWaiting: [2039, 710],
+      waiting: [2039, 710],
      success: [2740, 1304],
    },
    volume: notificationsSnap.soundNotificationVolume,
@@ -20,7 +20,6 @@ import { Track } from 'livekit-client'
 import { ParticipantPlaceholder } from './ParticipantPlaceholder'
 import { ParticipantTileFocus } from './participantTileFocus/ParticipantTileFocus'
 import { FullScreenShareWarning } from './FullScreenShareWarning'
-import { ScreenShareZoomableVideo } from '@/features/rooms/livekit/components/ScreenShareZoomableVideo'
 import { useTranslation } from 'react-i18next'
 import { getShortcutDescriptorById } from '@/features/shortcuts/catalog'
 import { formatShortcutLabel } from '@/features/shortcuts/formatLabels'
@@ -90,8 +89,6 @@ export const ParticipantTile: (
  )

  const isScreenShare = trackReference.source != Track.Source.Camera
-  const isRemoteScreenShare =
-    isScreenShare && !trackReference.participant.isLocal
  const [hasKeyboardFocus, setHasKeyboardFocus] = React.useState(false)

  const participantColor = getParticipantColor(trackReference.participant)
@@ -101,23 +98,11 @@ export const ParticipantTile: (
  })
  const participantName = name || identity || 'Unknown'

-  // tileRef: fullscreen target, and the node the focus overlay listens on.
-  // setRefs merges it with the forwarded ref on the same node.
-  const tileRef = React.useRef<HTMLDivElement>(null)
-  const setRefs = React.useCallback(
-    (node: HTMLDivElement | null) => {
-      ;(tileRef as React.MutableRefObject<HTMLDivElement | null>).current = node
-      if (typeof ref === 'function') ref(node)
-      else if (ref)
-        (ref as React.MutableRefObject<HTMLDivElement | null>).current = node
-    },
-    [ref]
-  )
-
  const { t } = useTranslation('rooms', { keyPrefix: 'participantTileFocus' })

  const interactiveProps = {
    ...elementProps,
+    // Ensure the tile is focusable to expose contextual controls to keyboard users.
    tabIndex: 0,
    'aria-label': t('containerLabel', { name: participantName }),
    onFocus: (event: React.FocusEvent<HTMLDivElement>) => {
@@ -135,41 +120,8 @@ export const ParticipantTile: (
    },
  }

-  const isVideoTrack =
-    isTrackReference(trackReference) &&
-    trackReference.publication.kind === 'video'
-
-  let trackMedia: React.ReactNode = null
-  if (isVideoTrack) {
-    const videoTrack = (
-      <VideoTrack
-        trackRef={trackReference}
-        onSubscriptionStatusChanged={handleSubscribe}
-        manageSubscription={autoManageSubscription}
-      />
-    )
-    // Zoom toolbar stays out of picture-in-picture: that window has its own
-    // document and the fullscreen API is off. Follow-up PR can restore zoom
-    // there without the dead fullscreen button.
-    trackMedia =
-      isRemoteScreenShare && !disableTileControls ? (
-        <ScreenShareZoomableVideo tileRef={tileRef}>
-          {videoTrack}
-        </ScreenShareZoomableVideo>
-      ) : (
-        videoTrack
-      )
-  } else if (isTrackReference(trackReference)) {
-    trackMedia = (
-      <AudioTrack
-        trackRef={trackReference}
-        onSubscriptionStatusChanged={handleSubscribe}
-      />
-    )
-  }
-
  return (
-    <div ref={setRefs} style={{ position: 'relative' }} {...interactiveProps}>
+    <div ref={ref} style={{ position: 'relative' }} {...interactiveProps}>
      <TrackRefContextIfNeeded trackRef={trackReference}>
        <ParticipantContextIfNeeded participant={trackReference.participant}>
          {trackReference.participant.isLocal && (
@@ -177,7 +129,23 @@ export const ParticipantTile: (
          )}
          {children ?? (
            <>
-              {trackMedia}
+              {isTrackReference(trackReference) &&
+              (trackReference.publication?.kind === 'video' ||
+                trackReference.source === Track.Source.Camera ||
+                trackReference.source === Track.Source.ScreenShare) ? (
+                <VideoTrack
+                  trackRef={trackReference}
+                  onSubscriptionStatusChanged={handleSubscribe}
+                  manageSubscription={autoManageSubscription}
+                />
+              ) : (
+                isTrackReference(trackReference) && (
+                  <AudioTrack
+                    trackRef={trackReference}
+                    onSubscriptionStatusChanged={handleSubscribe}
+                  />
+                )
+              )}
              <div className="lk-participant-placeholder">
                <ParticipantPlaceholder
                  color={participantColor}
@@ -196,7 +164,6 @@ export const ParticipantTile: (
          {!disableMetadata && !disableTileControls && (
            <ParticipantTileFocus
              trackRef={trackReference}
-              tileRef={tileRef}
              hasKeyboardFocus={hasKeyboardFocus}
            />
          )}
@@ -7,64 +7,38 @@ import { useCanMute } from '@/features/rooms/livekit/hooks/useCanMute'
 import { FocusButton } from './FocusButton'
 import { EffectsButton } from './EffectsButton'
 import { MuteButton } from './MuteButton'
+import { ZoomButton } from './ZoomButton'

 const MOUSE_IDLE_TIME = 3000

 type FadeOverlayProps = {
  children: ReactNode
  hasKeyboardFocus: boolean
-  tileRef: React.RefObject<HTMLDivElement | null>
 }

-// Pointer-events none so this overlay doesn't block the zoom surface below.
-// The tile node still gets the mouse events, so we listen on it directly
-// rather than lifting the state up: this keeps mouse moves from re-rendering
-// the tile and the video it contains.
-const FadeOverlay = ({
-  children,
-  hasKeyboardFocus,
-  tileRef,
-}: FadeOverlayProps) => {
+const FadeOverlay = ({ children, hasKeyboardFocus }: FadeOverlayProps) => {
  const [active, setActive] = useState(false)
  const idleTimerRef = useRef<number | null>(null)

-  useEffect(() => {
-    const tile = tileRef.current
-    if (!tile) return
+  const clearIdleTimer = () => {
+    if (idleTimerRef.current) window.clearTimeout(idleTimerRef.current)
+  }

-    const clearIdleTimer = () => {
-      if (idleTimerRef.current) window.clearTimeout(idleTimerRef.current)
-      idleTimerRef.current = null
-    }
-
-    const handleActivity = () => {
-      setActive(true)
-      clearIdleTimer()
-      idleTimerRef.current = window.setTimeout(
-        () => setActive(false),
-        MOUSE_IDLE_TIME
-      )
-    }
-
-    const handleLeave = () => {
-      clearIdleTimer()
+  const armIdleTimer = () => {
+    clearIdleTimer()
+    idleTimerRef.current = window.setTimeout(() => {
      setActive(false)
-    }
+    }, MOUSE_IDLE_TIME)
+  }

-    tile.addEventListener('mouseenter', handleActivity)
-    tile.addEventListener('mousemove', handleActivity)
-    tile.addEventListener('mouseleave', handleLeave)
+  const handleActivity = () => {
+    setActive(true)
+    armIdleTimer()
+  }

-    return () => {
-      clearIdleTimer()
-      tile.removeEventListener('mouseenter', handleActivity)
-      tile.removeEventListener('mousemove', handleActivity)
-      tile.removeEventListener('mouseleave', handleLeave)
-    }
-  }, [tileRef])
+  useEffect(() => clearIdleTimer, [])

  const isVisible = hasKeyboardFocus || active
-
  return (
    <div
      className={css({
@@ -76,10 +50,15 @@ const FadeOverlay = ({
        alignItems: 'center',
        width: '100%',
        height: '100%',
-        pointerEvents: 'none',
      })}
      data-visible={isVisible || undefined}
      aria-hidden={!isVisible}
+      onMouseEnter={handleActivity}
+      onMouseMove={handleActivity}
+      onMouseLeave={() => {
+        clearIdleTimer()
+        setActive(false)
+      }}
    >
      {isVisible && children}
    </div>
@@ -88,11 +67,9 @@ const FadeOverlay = ({

 export const ParticipantTileFocus = ({
  trackRef,
-  tileRef,
  hasKeyboardFocus,
 }: {
  trackRef: TrackReferenceOrPlaceholder
-  tileRef: React.RefObject<HTMLDivElement | null>
  hasKeyboardFocus: boolean
 }) => {
  const participant = trackRef.participant
@@ -101,7 +78,7 @@ export const ParticipantTileFocus = ({
  const canMute = useCanMute(participant)

  return (
-    <FadeOverlay hasKeyboardFocus={hasKeyboardFocus} tileRef={tileRef}>
+    <FadeOverlay hasKeyboardFocus={hasKeyboardFocus}>
      <div
        className={css({
          backgroundColor: 'primaryDark.50',
@@ -110,7 +87,6 @@ export const ParticipantTileFocus = ({
          display: 'flex',
          opacity: 0.6,
          animation: 'overlayIn 200ms linear 300ms backwards',
-          pointerEvents: 'auto',
          _hover: {
            opacity: 0.95,
          },
@@ -118,7 +94,7 @@ export const ParticipantTileFocus = ({
      >
        <HStack gap={0.5} padding={0.5}>
          <FocusButton trackRef={trackRef} />
-          {!isScreenShare && (
+          {!isScreenShare ? (
            <>
              {isLocal ? (
                <EffectsButton />
@@ -126,6 +102,8 @@ export const ParticipantTileFocus = ({
                canMute && <MuteButton participant={participant} />
              )}
            </>
+          ) : (
+            !isLocal && <ZoomButton trackRef={trackRef} />
          )}
        </HStack>
      </div>
@@ -0,0 +1,32 @@
+import { TrackReferenceOrPlaceholder } from '@livekit/components-core'
+import { useTranslation } from 'react-i18next'
+import { useFullScreen } from '@/features/rooms/livekit/hooks/useFullScreen'
+import { Button } from '@/primitives'
+import { RiFullscreenLine } from '@remixicon/react'
+
+export const ZoomButton = ({
+  trackRef,
+}: {
+  trackRef: TrackReferenceOrPlaceholder
+}) => {
+  const { t } = useTranslation('rooms', { keyPrefix: 'participantTileFocus' })
+  const { toggleFullScreen, isFullscreenAvailable } = useFullScreen({
+    trackRef,
+  })
+
+  if (!isFullscreenAvailable) {
+    return
+  }
+
+  return (
+    <Button
+      size="sm"
+      variant="primaryTextDark"
+      square
+      tooltip={t('fullScreen')}
+      onPress={() => toggleFullScreen()}
+    >
+      <RiFullscreenLine />
+    </Button>
+  )
+}
@@ -1,29 +0,0 @@
-import { useEffect, useState } from 'react'
-import { useTracks } from '@livekit/components-react'
-import { Track } from 'livekit-client'
-import { RecordingMode } from '@/features/recording'
-import { useRecordingStatuses } from './useRecordingStatuses'
-
-const STARTING_NOTIFICATION_DELAY = 15_000
-
-export const useRecordingWaitingForTracks = (mode: RecordingMode) => {
-  const { isStarting } = useRecordingStatuses(mode)
-  const tracks = useTracks(
-    mode === RecordingMode.Transcript ? [Track.Source.Microphone] : undefined,
-    { onlySubscribed: false }
-  )
-  const [delayElapsed, setDelayElapsed] = useState(false)
-
-  useEffect(() => {
-    setDelayElapsed(false)
-    if (!isStarting) return
-
-    const timeout = window.setTimeout(
-      () => setDelayElapsed(true),
-      STARTING_NOTIFICATION_DELAY
-    )
-    return () => window.clearTimeout(timeout)
-  }, [isStarting, mode])
-
-  return isStarting && delayElapsed && tracks.length === 0
-}
@@ -9,9 +9,8 @@ export enum RecordingStatus {
  Stopped = 'stopped',
  Saved = 'saved',
  Aborted = 'aborted',
-  Failed = 'failed',
-  FailedToStart = 'failed_to_start',
-  FailedToStop = 'failed_to_stop',
+  FailedToStart = 'failedToStart',
+  FailedToStop = 'failedToStop',
  NotificationSucceed = 'notification_succeeded',
  ExternalProcessSuccessful = 'external_process_successful',
  ExternalProcessFailed = 'external_process_failed',
@@ -107,7 +107,7 @@ export const Conference = ({
      adaptiveStream: true,
      dynacast: true,
      publishDefaults: {
-        videoCodec: apiConfig?.livekit.default_video_codec ?? 'vp9',
+        videoCodec: 'vp9',
      },
      videoCaptureDefaults: {
        deviceId: userConfig.videoDeviceId ?? undefined,
@@ -129,7 +129,6 @@ export const Conference = ({
    userConfig.videoPublishResolution,
    userConfig.audioDeviceId,
    userConfig.audioOutputDeviceId,
-    apiConfig?.livekit.default_video_codec,
  ])

  const room = useMemo(() => new Room(roomOptions), [roomOptions])
@@ -1,76 +0,0 @@
-import { Button } from '@/primitives'
-import { RiCollapseDiagonalLine, RiExpandDiagonalLine } from '@remixicon/react'
-import { memo, useCallback, useEffect, useRef, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-import { useScreenReaderAnnounce } from '@/hooks/useScreenReaderAnnounce'
-
-// Keeps the fullscreen state here rather than on the toolbar, so entering or
-// leaving fullscreen does not re-render the zoom controls.
-export const ScreenShareFullscreenButton = memo(
-  ({
-    containerRef,
-  }: {
-    containerRef: React.RefObject<HTMLDivElement | null>
-  }) => {
-    const { t } = useTranslation('rooms', { keyPrefix: 'screenShareZoom' })
-    const announce = useScreenReaderAnnounce()
-
-    const [isFullscreen, setIsFullscreen] = useState(false)
-    // Tracks whether this tile's container triggered fullscreen (vs another share's).
-    const wasThisTileFullscreen = useRef(false)
-
-    // Covers Esc and browser UI exits, not just this button.
-    // Only this tile's instance announces to avoid duplicates with multiple shares.
-    useEffect(() => {
-      const onChange = () => {
-        const isThisTileFullscreen =
-          document.fullscreenElement === containerRef.current
-        setIsFullscreen(isThisTileFullscreen)
-
-        if (isThisTileFullscreen) {
-          wasThisTileFullscreen.current = true
-          announce(t('fullScreenEntered'), 'assertive')
-        } else if (wasThisTileFullscreen.current) {
-          wasThisTileFullscreen.current = false
-          announce(t('fullScreenExited'), 'assertive')
-        }
-      }
-      document.addEventListener('fullscreenchange', onChange)
-      return () => document.removeEventListener('fullscreenchange', onChange)
-    }, [announce, t, containerRef])
-
-    const toggleFullScreen = useCallback(async () => {
-      try {
-        if (document.fullscreenElement === containerRef.current) {
-          await document.exitFullscreen()
-        } else {
-          // Tile container so zoom controls stay visible in fullscreen.
-          await containerRef.current?.requestFullscreen()
-        }
-      } catch (error) {
-        console.error('Error toggling fullscreen:', error)
-      }
-    }, [containerRef])
-
-    if (!document.fullscreenEnabled) return null
-
-    return (
-      <Button
-        size="sm"
-        variant="primaryTextDark"
-        square
-        tooltip={isFullscreen ? t('exitFullScreen') : t('fullScreen')}
-        aria-label={isFullscreen ? t('exitFullScreen') : t('fullScreen')}
-        onPress={toggleFullScreen}
-      >
-        {isFullscreen ? (
-          <RiCollapseDiagonalLine size={20} />
-        ) : (
-          <RiExpandDiagonalLine size={20} />
-        )}
-      </Button>
-    )
-  }
-)
-
-ScreenShareFullscreenButton.displayName = 'ScreenShareFullscreenButton'
@@ -1,165 +0,0 @@
-import { css } from '@/styled-system/css'
-import { Button } from '@/primitives'
-import {
-  RiFullscreenExitLine,
-  RiZoomInLine,
-  RiZoomOutLine,
-} from '@remixicon/react'
-import { useTranslation } from 'react-i18next'
-import { Toolbar } from 'react-aria-components'
-import { useEffect, useRef } from 'react'
-import { isMacintosh } from '@/utils/livekit'
-import { srOnly } from '@/styles/a11y'
-import { ScreenShareFullscreenButton } from './ScreenShareFullscreenButton'
-
-interface ScreenShareZoomControlsProps {
-  containerRef: React.RefObject<HTMLDivElement | null>
-  isZoomed: boolean
-  zoomPercentage: number
-  canZoomIn: boolean
-  canZoomOut: boolean
-  onZoomIn: () => void
-  onZoomOut: () => void
-  onResetZoom: () => void
-}
-
-export const ScreenShareZoomControls = ({
-  containerRef,
-  isZoomed,
-  zoomPercentage,
-  canZoomIn,
-  canZoomOut,
-  onZoomIn,
-  onZoomOut,
-  onResetZoom,
-}: ScreenShareZoomControlsProps) => {
-  const { t } = useTranslation('rooms', { keyPrefix: 'screenShareZoom' })
-
-  const zoomInButtonRef = useRef<HTMLButtonElement>(null)
-  const hadFocusInCollapsibleRef = useRef(false)
-
-  // Back at 100 % the collapsible controls are disabled and hidden, which drops
-  // keyboard focus on the body. Hand it to the zoom in button instead, the only
-  // control of that group still reachable.
-  useEffect(() => {
-    if (isZoomed || !hadFocusInCollapsibleRef.current) return
-    hadFocusInCollapsibleRef.current = false
-    zoomInButtonRef.current?.focus()
-  }, [isZoomed])
-
-  const wheelShortcut = t(isMacintosh() ? 'wheelShortcutMac' : 'wheelShortcut')
-
-  return (
-    <div
-      className={css({
-        position: 'absolute',
-        bottom: '12px',
-        right: '12px',
-        zIndex: 2,
-        pointerEvents: 'auto',
-      })}
-    >
-      <Toolbar
-        aria-label={t('toolbarLabel')}
-        className={css({
-          display: 'flex',
-          alignItems: 'center',
-          backgroundColor: 'primaryDark.50',
-          borderRadius: '2rem',
-          padding: '0.5rem',
-          opacity: 0.7,
-          transition: 'opacity 200ms linear',
-          _hover: {
-            opacity: 0.95,
-          },
-        })}
-      >
-        <span className={srOnly}>
-          {t(isMacintosh() ? 'wheelShortcutHintMac' : 'wheelShortcutHint')}
-        </span>
-        {/* Animated wrapper: collapses to 0 when not zoomed. padding/margin
-            trick keeps overflow:hidden from clipping focus rings. */}
-        <div
-          className={css({
-            display: 'flex',
-            alignItems: 'center',
-            overflow: 'hidden',
-            transition: 'max-width 200ms ease-out, opacity 200ms ease-out',
-            padding: '3px',
-            margin: '-3px',
-          })}
-          style={{
-            maxWidth: isZoomed ? '12rem' : '0',
-            opacity: isZoomed ? 1 : 0,
-          }}
-          aria-hidden={!isZoomed}
-          onFocus={() => {
-            hadFocusInCollapsibleRef.current = true
-          }}
-          onBlur={(e) => {
-            // Disabling a focused button blurs it with no relatedTarget, so the
-            // flag must survive that case for the effect above to rescue focus.
-            if (e.relatedTarget) hadFocusInCollapsibleRef.current = false
-          }}
-        >
-          <Button
-            size="sm"
-            variant="primaryTextDark"
-            square
-            tooltip={t('fitToWindow')}
-            aria-label={t('fitToWindow')}
-            isDisabled={!isZoomed}
-            onPress={onResetZoom}
-          >
-            <RiFullscreenExitLine size={20} />
-          </Button>
-          <Button
-            size="sm"
-            variant="primaryTextDark"
-            square
-            tooltip={t('zoomOutWithShortcut', {
-              shortcut: wheelShortcut,
-            })}
-            aria-label={t('zoomOut')}
-            isDisabled={!isZoomed || !canZoomOut}
-            onPress={onZoomOut}
-          >
-            <RiZoomOutLine size={20} />
-          </Button>
-          {/* Visual only - zoom level is announced via useScreenReaderAnnounce. */}
-          <span
-            aria-hidden="true"
-            className={css({
-              color: 'white',
-              fontSize: '0.8125rem',
-              fontWeight: 500,
-              minWidth: '3.25rem',
-              textAlign: 'center',
-              userSelect: 'none',
-              display: 'flex',
-              alignItems: 'center',
-              justifyContent: 'center',
-              padding: '0 0.25rem',
-              whiteSpace: 'nowrap',
-            })}
-          >
-            {zoomPercentage} %
-          </span>
-        </div>
-        <Button
-          ref={zoomInButtonRef}
-          size="sm"
-          variant="primaryTextDark"
-          square
-          tooltip={t('zoomInWithShortcut', { shortcut: wheelShortcut })}
-          aria-label={t('zoomIn')}
-          isDisabled={!canZoomIn}
-          onPress={onZoomIn}
-        >
-          <RiZoomInLine size={20} />
-        </Button>
-        <ScreenShareFullscreenButton containerRef={containerRef} />
-      </Toolbar>
-    </div>
-  )
-}
@@ -1,98 +0,0 @@
-import { css } from '@/styled-system/css'
-import { useEffect, useRef, type ReactNode } from 'react'
-import { useTranslation } from 'react-i18next'
-import { useScreenShareZoom } from '../hooks/useScreenShareZoom'
-import { useScreenReaderAnnounce } from '@/hooks/useScreenReaderAnnounce'
-import { ScreenShareZoomControls } from './ScreenShareZoomControls'
-
-interface ScreenShareZoomableVideoProps {
-  tileRef: React.RefObject<HTMLDivElement | null>
-  children: ReactNode
-}
-
-// The video comes in as children so that a zoom change, which only re-renders
-// this wrapper, leaves the video subtree untouched.
-export const ScreenShareZoomableVideo = ({
-  tileRef,
-  children,
-}: ScreenShareZoomableVideoProps) => {
-  const zoom = useScreenShareZoom()
-  const { t } = useTranslation('rooms', { keyPrefix: 'screenShareZoom' })
-  const announce = useScreenReaderAnnounce()
-
-  // SR announcement: announce zoom level on change, with a one-time pan hint
-  // on the first zoom above 100 % per session.
-  const prevZoomRef = useRef(zoom.zoomPercentage)
-  const hasAnnouncedPanHint = useRef(false)
-  useEffect(() => {
-    if (prevZoomRef.current === zoom.zoomPercentage) return
-    const wasAtDefault = prevZoomRef.current <= 100
-    prevZoomRef.current = zoom.zoomPercentage
-
-    if (wasAtDefault && zoom.isZoomed && !hasAnnouncedPanHint.current) {
-      hasAnnouncedPanHint.current = true
-      announce(t('panHint', { level: zoom.zoomPercentage }), 'polite')
-    } else {
-      announce(t('currentZoomLevel', { level: zoom.zoomPercentage }), 'polite')
-    }
-
-    if (!zoom.isZoomed) hasAnnouncedPanHint.current = false
-  }, [zoom.zoomPercentage, zoom.isZoomed, announce, t])
-
-  // Attach keyboard listener on the tile container (has tabIndex=0).
-  useEffect(() => {
-    const el = tileRef.current
-    if (!el) return
-    el.addEventListener('keydown', zoom.handleKeyDown)
-    return () => el.removeEventListener('keydown', zoom.handleKeyDown)
-  }, [tileRef, zoom.handleKeyDown])
-
-  // Native wheel listener with { passive: false } so preventDefault works.
-  useEffect(() => {
-    const el = zoom.surfaceElRef.current
-    if (!el) return
-    el.addEventListener('wheel', zoom.handleWheel, { passive: false })
-    return () => el.removeEventListener('wheel', zoom.handleWheel)
-  }, [zoom.handleWheel, zoom.surfaceElRef])
-
-  return (
-    <>
-      <div
-        ref={zoom.surfaceElRef}
-        className={css({
-          width: '100%',
-          height: '100%',
-          overflow: 'hidden',
-          position: 'relative',
-          userSelect: 'none',
-          // Leaves the browser's native pinch-zoom available on touch devices
-          // while still routing single-pointer drags to useMove for panning.
-          touchAction: 'pinch-zoom',
-        })}
-        {...zoom.moveProps}
-      >
-        <div
-          ref={zoom.transformElRef}
-          style={{
-            width: '100%',
-            height: '100%',
-            pointerEvents: 'none',
-            transformOrigin: 'center center',
-          }}
-        >
-          {children}
-        </div>
-      </div>
-      <ScreenShareZoomControls
-        containerRef={tileRef}
-        isZoomed={zoom.isZoomed}
-        zoomPercentage={zoom.zoomPercentage}
-        canZoomIn={zoom.canZoomIn}
-        canZoomOut={zoom.canZoomOut}
-        onZoomIn={zoom.zoomIn}
-        onZoomOut={zoom.zoomOut}
-        onResetZoom={zoom.resetZoom}
-      />
-    </>
-  )
-}
@@ -1,16 +1,17 @@
 import { useEffect } from 'react'
 import { useRoomContext } from '@livekit/components-react'
 import {
-  type RemoteTrack,
+  type RemoteParticipant,
  type RemoteTrackPublication,
  RoomEvent,
  Track,
+  VideoQuality,
 } from 'livekit-client'
 import { useSnapshot } from 'valtio'
 import { userChoicesStore } from '@/stores/userChoices'

 /**
- * Applies the saved reception quality to every remote camera.
+ * Sets initial video quality for new participants as they join.
 * LiveKit doesn't allow handling video quality preferences at the room level.
 */
 export const VideoResolutionSubscription = () => {
@@ -18,40 +19,30 @@ export const VideoResolutionSubscription = () => {
  const room = useRoomContext()

  useEffect(() => {
-    if (!room || videoSubscribeQuality === undefined) return
+    if (!room) return

-    const applyQuality = (publication: RemoteTrackPublication) => {
+    const handleTrackPublished = (
+      publication: RemoteTrackPublication,
+      _participant: RemoteParticipant
+    ) => {
+      // By default, the maximum quality is set to high
      if (
-        publication.kind !== Track.Kind.Video ||
-        publication.source === Track.Source.ScreenShare ||
-        publication.videoQuality === videoSubscribeQuality
-      ) {
+        videoSubscribeQuality === undefined ||
+        videoSubscribeQuality === VideoQuality.HIGH
+      )
        return
+
+      if (
+        publication.kind === Track.Kind.Video &&
+        publication.source !== Track.Source.ScreenShare
+      ) {
+        publication.setVideoQuality(videoSubscribeQuality)
      }
-      publication.setVideoQuality(videoSubscribeQuality)
    }

-    // Cameras we are already receiving: those published before this effect ran,
-    // and all of them again whenever the preference changes mid-call.
-    room.remoteParticipants.forEach((participant) =>
-      participant.videoTrackPublications.forEach(applyQuality)
-    )
-
-    const handleTrackPublished = (publication: RemoteTrackPublication) =>
-      applyQuality(publication)
-
-    // TrackPublished is not raised for cameras that were already sending when we
-    // joined, but it is the earliest point for the ones that start after us.
-    const handleTrackSubscribed = (
-      _track: RemoteTrack,
-      publication: RemoteTrackPublication
-    ) => applyQuality(publication)
-
    room.on(RoomEvent.TrackPublished, handleTrackPublished)
-    room.on(RoomEvent.TrackSubscribed, handleTrackSubscribed)
    return () => {
      room.off(RoomEvent.TrackPublished, handleTrackPublished)
-      room.off(RoomEvent.TrackSubscribed, handleTrackSubscribed)
    }
  }, [room, videoSubscribeQuality])

@@ -2,23 +2,23 @@ import { RiQuestionLine } from '@remixicon/react'
 import { MenuItem } from 'react-aria-components'
 import { useTranslation } from 'react-i18next'
 import { menuRecipe } from '@/primitives/menuRecipe'
-import {
-  useIsSupportEnabled,
-  openSupportChat,
-} from '@/features/support/hooks/useSupport'
+import { Crisp } from 'crisp-sdk-web'
+import { useIsSupportEnabled } from '@/features/support/hooks/useSupport'

 export const SupportMenuItem = () => {
  const { t } = useTranslation('rooms', { keyPrefix: 'options.items' })
  const isSupportEnabled = useIsSupportEnabled()

-  if (!isSupportEnabled) {
+  if (!isSupportEnabled || !Crisp) {
    return
  }

  return (
    <MenuItem
      className={menuRecipe({ icon: true, variant: 'dark' }).item}
-      onAction={openSupportChat}
+      onAction={() => {
+        Crisp?.chat.open()
+      }}
    >
      <RiQuestionLine size={20} />
      {t('support')}
@@ -1,270 +0,0 @@
-import { useCallback, useRef, useState } from 'react'
-import { useMove } from 'react-aria'
-import type { MoveMoveEvent } from '@react-types/shared'
-import {
-  FULL_PICTURE_RATIO,
-  MAX_ZOOM,
-  MIN_ZOOM,
-  PAN_STEP,
-  WHEEL_ZOOM_SPEED,
-  ZOOM_STEP,
-  type PanOffset,
-  clampPan,
-  clampZoom,
-  getCursorFromZoomState,
-  getCursorPercentsFromWheelEvent,
-  getPanDeltaPercentsFromMove,
-  getPictureRatio,
-  getWheelPanOffset,
-  getZoomTransform,
-} from '../utils/screenShareZoom'
-
-/**
- * Manages zoom and pan state for a remote screen share.
- *
- * Performance: zoom/pan live in refs and are applied imperatively to the DOM
- * (via transformElRef / surfaceElRef) so dragging and panning never re-render.
- * React state only tracks what the toolbar displays, and only updates when
- * the zoom level actually changes.
- *
- * Drag/touch panning is handled by react-aria's useMove (moveProps).
- * The wheel listener (non-passive) zooms on Ctrl/Cmd+scroll and pans on a
- * two-finger trackpad scroll once zoomed.
- * Arrow key panning and +/-/0 zoom are on a keydown listener attached to the
- * tile container (which has tabIndex=0 and focus).
- */
-export const useScreenShareZoom = () => {
-  const zoomRef = useRef(MIN_ZOOM)
-  const panRef = useRef<PanOffset>({ x: 0, y: 0 })
-  const draggingRef = useRef(false)
-
-  // The consumer binds these to the inner transform div and the outer drag surface.
-  const transformElRef = useRef<HTMLDivElement | null>(null)
-  const surfaceElRef = useRef<HTMLDivElement | null>(null)
-
-  // Mirrors zoomRef for the toolbar. Panning never publishes: the toolbar
-  // shows the zoom level, not the position.
-  const [zoomLevel, setZoomLevel] = useState(MIN_ZOOM)
-
-  const syncToolbar = useCallback(() => setZoomLevel(zoomRef.current), [])
-
-  const applyTransform = useCallback(() => {
-    const el = transformElRef.current
-    if (!el) return
-    el.style.transform = getZoomTransform(zoomRef.current, panRef.current)
-  }, [])
-
-  // The video is letterboxed inside the surface by object-fit: contain, so the
-  // pan bounds depend on how much of the surface the picture actually covers.
-  // Read live rather than cached: both the tile and the shared resolution can
-  // change at any time.
-  const readPictureRatio = useCallback(() => {
-    const surface = surfaceElRef.current
-    const video = transformElRef.current?.querySelector('video')
-    if (!surface || !video) return FULL_PICTURE_RATIO
-    return getPictureRatio(
-      surface.clientWidth,
-      surface.clientHeight,
-      video.videoWidth,
-      video.videoHeight
-    )
-  }, [])
-
-  const applyCursor = useCallback(() => {
-    const el = surfaceElRef.current
-    if (!el) return
-    el.style.cursor = getCursorFromZoomState(
-      zoomRef.current,
-      draggingRef.current
-    )
-  }, [])
-
-  const setZoom = useCallback(
-    (next: number) => {
-      zoomRef.current = next
-      panRef.current =
-        next <= MIN_ZOOM
-          ? { x: 0, y: 0 }
-          : clampPan(panRef.current, next, readPictureRatio())
-      applyTransform()
-      applyCursor()
-      syncToolbar()
-    },
-    [applyTransform, applyCursor, syncToolbar, readPictureRatio]
-  )
-
-  const zoomIn = useCallback(
-    () => setZoom(clampZoom(zoomRef.current + ZOOM_STEP)),
-    [setZoom]
-  )
-
-  const zoomOut = useCallback(
-    () => setZoom(clampZoom(zoomRef.current - ZOOM_STEP)),
-    [setZoom]
-  )
-
-  const resetZoom = useCallback(() => setZoom(MIN_ZOOM), [setZoom])
-
-  // Cancels the scale() that multiplies translate(), so the picture follows
-  // the pointer 1:1 and keyboard steps keep the same visual size.
-  const panBy = useCallback(
-    (dx: number, dy: number) => {
-      const zoom = zoomRef.current
-      panRef.current = clampPan(
-        {
-          x: panRef.current.x + dx / zoom,
-          y: panRef.current.y + dy / zoom,
-        },
-        zoom,
-        readPictureRatio()
-      )
-      applyTransform()
-    },
-    [applyTransform, readPictureRatio]
-  )
-
-  // Must be attached with { passive: false } so preventDefault() blocks
-  // the browser's native Ctrl+scroll page zoom. Trackpad pinch arrives
-  // here as a wheel event with ctrl/cmd already set.
-  const handleWheel = useCallback(
-    (e: WheelEvent) => {
-      if (e.ctrlKey || e.metaKey) {
-        e.preventDefault()
-        e.stopPropagation()
-
-        const target = e.currentTarget as HTMLElement
-        const prev = zoomRef.current
-        const delta = -e.deltaY * WHEEL_ZOOM_SPEED
-        const next = clampZoom(prev + delta)
-
-        if (next <= MIN_ZOOM) {
-          zoomRef.current = MIN_ZOOM
-          panRef.current = { x: 0, y: 0 }
-        } else {
-          const { cursorXPercent, cursorYPercent } =
-            getCursorPercentsFromWheelEvent(e, target)
-          zoomRef.current = next
-          panRef.current = getWheelPanOffset({
-            pan: panRef.current,
-            prevZoom: prev,
-            nextZoom: next,
-            cursorXPercent,
-            cursorYPercent,
-            ratio: readPictureRatio(),
-          })
-        }
-
-        applyTransform()
-        applyCursor()
-        syncToolbar()
-        return
-      }
-
-      // Two-finger trackpad scroll: pan only once zoomed, otherwise leave
-      // the event alone so the page can still scroll.
-      if (zoomRef.current <= MIN_ZOOM) return
-
-      const el = surfaceElRef.current
-      if (!el) return
-
-      e.preventDefault()
-      e.stopPropagation()
-
-      const { deltaXPercent, deltaYPercent } = getPanDeltaPercentsFromMove(
-        -e.deltaX,
-        -e.deltaY,
-        el
-      )
-      panBy(deltaXPercent, deltaYPercent)
-    },
-    [applyTransform, applyCursor, syncToolbar, readPictureRatio, panBy]
-  )
-
-  // useMove handles mouse drag + touch pan. Keyboard arrows are not handled
-  // here because moveProps is on the zoom surface, while focus is on the tile
-  // container, see handleKeyDown below.
-  const { moveProps } = useMove({
-    onMoveStart() {
-      if (zoomRef.current <= MIN_ZOOM) return
-      draggingRef.current = true
-      applyCursor()
-    },
-    onMove(e: MoveMoveEvent) {
-      if (zoomRef.current <= MIN_ZOOM) return
-
-      const el = surfaceElRef.current
-      if (!el) return
-
-      const { deltaXPercent, deltaYPercent } = getPanDeltaPercentsFromMove(
-        e.deltaX,
-        e.deltaY,
-        el
-      )
-      panBy(deltaXPercent, deltaYPercent)
-    },
-    onMoveEnd() {
-      draggingRef.current = false
-      applyTransform()
-      applyCursor()
-    },
-  })
-
-  // Attached to the tile container (not the zoom surface) where keyboard
-  // focus lives. Arrows pan, +/-/0 zoom.
-  const handleKeyDown = useCallback(
-    (e: KeyboardEvent) => {
-      const isZoomed = zoomRef.current > MIN_ZOOM
-      if (!isZoomed && e.key !== '+' && e.key !== '=') return
-
-      if (e.key.startsWith('Arrow') && e.target !== e.currentTarget) return
-
-      switch (e.key) {
-        case 'ArrowLeft':
-          e.preventDefault()
-          panBy(PAN_STEP, 0)
-          break
-        case 'ArrowRight':
-          e.preventDefault()
-          panBy(-PAN_STEP, 0)
-          break
-        case 'ArrowUp':
-          e.preventDefault()
-          panBy(0, PAN_STEP)
-          break
-        case 'ArrowDown':
-          e.preventDefault()
-          panBy(0, -PAN_STEP)
-          break
-        case '+':
-        case '=':
-          e.preventDefault()
-          zoomIn()
-          break
-        case '-':
-          e.preventDefault()
-          zoomOut()
-          break
-        case '0':
-          e.preventDefault()
-          resetZoom()
-          break
-      }
-    },
-    [panBy, zoomIn, zoomOut, resetZoom]
-  )
-
-  return {
-    zoomPercentage: Math.round(zoomLevel * 100),
-    isZoomed: zoomLevel > MIN_ZOOM,
-    canZoomIn: zoomLevel < MAX_ZOOM,
-    canZoomOut: zoomLevel > MIN_ZOOM,
-    transformElRef,
-    surfaceElRef,
-    moveProps,
-    zoomIn,
-    zoomOut,
-    resetZoom,
-    handleWheel,
-    handleKeyDown,
-  }
-}
@@ -1,128 +0,0 @@
-export const MIN_ZOOM = 1
-export const MAX_ZOOM = 4
-export const ZOOM_STEP = 0.1
-export const WHEEL_ZOOM_SPEED = 0.002
-export const PAN_STEP = 5
-
-// Half of a 100 % axis. Geometry, not a tunable: it is both the centre the
-// cursor offset is measured from and the half extent the pan is clamped
-// against, so the two stay consistent by construction.
-export const HALF_EXTENT_PERCENT = 50
-
-export interface PanOffset {
-  x: number
-  y: number
-}
-
-// Fraction of the surface each axis of the picture covers, in [0, 1].
-export interface PictureRatio {
-  x: number
-  y: number
-}
-
-export const FULL_PICTURE_RATIO: PictureRatio = { x: 1, y: 1 }
-
-export const clampZoom = (value: number) => {
-  return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, value))
-}
-
-// Restrict pan so the picture always covers the view. Pan is a % of the
-// surface, in which object-fit: contain letterboxes the picture: its half
-// extent is `ratio * 50` against a view half extent of 50, and scaling by
-// `zoom` must keep `zoom * (ratio * 50 - |pan|) >= 50`. An axis whose picture
-// is still smaller than the view is pinned to 0, keeping the bars symmetric.
-export const clampPan = (
-  pan: PanOffset,
-  zoom: number,
-  ratio: PictureRatio
-): PanOffset => {
-  const maxPanX = Math.max(0, (ratio.x - 1 / zoom) * HALF_EXTENT_PERCENT)
-  const maxPanY = Math.max(0, (ratio.y - 1 / zoom) * HALF_EXTENT_PERCENT)
-  return {
-    x: Math.max(-maxPanX, Math.min(maxPanX, pan.x)),
-    y: Math.max(-maxPanY, Math.min(maxPanY, pan.y)),
-  }
-}
-
-// Per-axis fraction of the surface covered by an object-fit: contain picture.
-export const getPictureRatio = (
-  surfaceWidth: number,
-  surfaceHeight: number,
-  videoWidth: number,
-  videoHeight: number
-): PictureRatio => {
-  if (!surfaceWidth || !surfaceHeight || !videoWidth || !videoHeight) {
-    return FULL_PICTURE_RATIO
-  }
-  const surfaceRatio = surfaceWidth / surfaceHeight
-  const videoRatio = videoWidth / videoHeight
-  return surfaceRatio > videoRatio
-    ? { x: videoRatio / surfaceRatio, y: 1 }
-    : { x: 1, y: surfaceRatio / videoRatio }
-}
-
-export const getZoomTransform = (zoom: number, pan: PanOffset) => {
-  return `scale(${zoom}) translate(${pan.x}%, ${pan.y}%)`
-}
-
-export const getCursorFromZoomState = (zoom: number, dragging: boolean) => {
-  if (zoom <= MIN_ZOOM) return 'default'
-  return dragging ? 'grabbing' : 'grab'
-}
-
-// Keep the content point under the cursor anchored while zooming. With
-// `scale(z) translate(pan%)`, a point at `offset` from the center renders at
-// `z * (offset + pan)`, so holding it still gives:
-// pan' = pan + cursor * (1 / zoom' - 1 / zoom).
-export const getWheelPanOffset = ({
-  pan,
-  prevZoom,
-  nextZoom,
-  cursorXPercent,
-  cursorYPercent,
-  ratio,
-}: {
-  pan: PanOffset
-  prevZoom: number
-  nextZoom: number
-  cursorXPercent: number
-  cursorYPercent: number
-  ratio: PictureRatio
-}): PanOffset => {
-  const panShift = 1 / nextZoom - 1 / prevZoom
-  return clampPan(
-    {
-      x: pan.x + cursorXPercent * panShift,
-      y: pan.y + cursorYPercent * panShift,
-    },
-    nextZoom,
-    ratio
-  )
-}
-
-// Convert cursor pixel position to a % offset from the surface center.
-export const getCursorPercentsFromWheelEvent = (
-  e: WheelEvent,
-  target: HTMLElement
-) => {
-  const rect = target.getBoundingClientRect()
-  return {
-    cursorXPercent:
-      ((e.clientX - rect.left) / rect.width) * 100 - HALF_EXTENT_PERCENT,
-    cursorYPercent:
-      ((e.clientY - rect.top) / rect.height) * 100 - HALF_EXTENT_PERCENT,
-  }
-}
-
-// Convert useMove pixel deltas to % of the surface dimensions.
-export const getPanDeltaPercentsFromMove = (
-  deltaX: number,
-  deltaY: number,
-  surface: HTMLElement
-) => {
-  const rect = surface.getBoundingClientRect()
-  return {
-    deltaXPercent: (deltaX / rect.width) * 100,
-    deltaYPercent: (deltaY / rect.height) * 100,
-  }
-}
@@ -34,7 +34,7 @@ const EMPTY_PROPS = {}
 export const VideoTab = ({ id }: VideoTabProps) => {
  const { t } = useTranslation('settings', { keyPrefix: 'video' })
  const room = useRoomContext()
-  const { localParticipant } = room
+  const { localParticipant, remoteParticipants } = room

  const {
    videoDeviceId,
@@ -88,6 +88,22 @@ export const VideoTab = ({ id }: VideoTabProps) => {
    })
  }

+  /**
+   * Updates video quality for all existing remote video tracks when user preference changes.
+   * LiveKit doesn't support setting video quality preferences at the room level for remote participants,
+   * so this function applies the selected quality to all existing remote video tracks.
+   * Hook useVideoResolutionSubscription updates quality preferences of new participants joining.
+   */
+  const updateExistingRemoteVideoQuality = (selectedQuality: VideoQuality) => {
+    remoteParticipants.forEach((participant) => {
+      participant.videoTrackPublications.forEach((publication) => {
+        if (publication.videoQuality !== selectedQuality) {
+          publication.setVideoQuality(selectedQuality)
+        }
+      })
+    })
+  }
+
  useEffect(() => {
    let videoTrack: LocalVideoTrack | null = null

@@ -215,7 +231,9 @@ export const VideoTab = ({ id }: VideoTabProps) => {
          selectedKey={videoSubscribeQuality?.toString()}
          onSelectionChange={(key) => {
            if (key == undefined) return
-            saveVideoSubscribeQuality(Number(String(key)))
+            const selectedQuality = Number(String(key))
+            saveVideoSubscribeQuality(selectedQuality)
+            updateExistingRemoteVideoQuality(selectedQuality)
          }}
          style={{
            width: '100%',
@@ -16,10 +16,6 @@ export type ShortcutId =
  | 'recording'
  | 'reaction'
  | 'fullscreen'
-  | 'zoom-in'
-  | 'zoom-out'
-  | 'zoom-reset'
-  | 'zoom-pan'

 export const getShortcutDescriptorById = (id: ShortcutId) =>
  shortcutCatalog.find((item) => item.id === id)
@@ -28,7 +24,7 @@ export type ShortcutDescriptor = {
  id: ShortcutId
  category: ShortcutCategory
  shortcut?: Shortcut
-  kind?: 'press' | 'longPress' | 'arrows'
+  kind?: 'press' | 'longPress'
  code?: string // used when kind === 'longPress' (KeyboardEvent.code)
  description?: string
 }
@@ -90,27 +86,4 @@ export const shortcutCatalog: ShortcutDescriptor[] = [
    category: 'interaction',
    shortcut: { key: 'P', ctrlKey: true, shiftKey: true },
  },
-  // Screen share zoom keys are unmodified, so they are bound on the focused
-  // tile instead of being registered globally. They are listed here so the
-  // shortcuts panel stays exhaustive.
-  {
-    id: 'zoom-in',
-    category: 'interaction',
-    shortcut: { key: '+' },
-  },
-  {
-    id: 'zoom-out',
-    category: 'interaction',
-    shortcut: { key: '-' },
-  },
-  {
-    id: 'zoom-reset',
-    category: 'interaction',
-    shortcut: { key: '0' },
-  },
-  {
-    id: 'zoom-pan',
-    category: 'interaction',
-    kind: 'arrows',
-  },
 ]
@@ -25,7 +25,6 @@ export const formatShortcutLabelForSR = (
    shiftLabel,
    plusLabel,
    noShortcutLabel,
-    keyLabels,
  }: {
    controlLabel: string
    commandLabel: string
@@ -34,12 +33,10 @@ export const formatShortcutLabelForSR = (
    shiftLabel: string
    plusLabel: string
    noShortcutLabel: string
-    // Spelled-out names for keys screen readers may skip or mispronounce.
-    keyLabels?: Record<string, string>
  }
 ) => {
  if (!shortcut) return noShortcutLabel
-  const key = keyLabels?.[shortcut.key] ?? shortcut.key?.toUpperCase()
+  const key = shortcut.key?.toUpperCase()
  if (!key) return noShortcutLabel
  const ctrlWord = isMacintosh() ? commandLabel : controlLabel
  const altWord = isMacintosh() ? optionLabel : altLabel
@@ -12,9 +12,6 @@ export const useShortcutFormatting = () => {

  const formatVisual = useCallback(
    (shortcut?: Shortcut, code?: string, kind?: string) => {
-      if (kind === 'arrows') {
-        return t('shortcutsPanel.visual.arrows')
-      }
      if (code && kind === 'longPress') {
        const label = getKeyLabelFromCode(code)
        return t('shortcutsPanel.visual.hold', { key: label || '?' })
@@ -26,9 +23,6 @@ export const useShortcutFormatting = () => {

  const formatForSR = useCallback(
    (shortcut?: Shortcut, code?: string, kind?: string) => {
-      if (kind === 'arrows') {
-        return t('shortcutsPanel.sr.arrows')
-      }
      if (code && kind === 'longPress') {
        const label = getKeyLabelFromCode(code)
        return t('shortcutsPanel.sr.hold', { key: label || '?' })
@@ -41,10 +35,6 @@ export const useShortcutFormatting = () => {
        shiftLabel: t('shortcutsPanel.sr.shift'),
        plusLabel: t('shortcutsPanel.sr.plus'),
        noShortcutLabel: t('shortcutsPanel.sr.noShortcut'),
-        keyLabels: {
-          '+': t('shortcutsPanel.sr.plusKey'),
-          '-': t('shortcutsPanel.sr.minusKey'),
-        },
      })
    },
    [t]
@@ -1,45 +1,20 @@
-import { useEffect, useState } from 'react'
+import { useEffect } from 'react'
+import { Crisp } from 'crisp-sdk-web'
 import { type ApiUser } from '@/features/auth/api/ApiUser'
 import { useUser } from '@/features/auth/api/useUser'
 import { useConfig } from '@/api/useConfig'

-type CrispSdk = (typeof import('crisp-sdk-web'))['Crisp']
-
-let crisp: CrispSdk | undefined
-let crispPromise: Promise<CrispSdk> | undefined
-
-const loadCrisp = (): Promise<CrispSdk> => {
-  crispPromise ??= import('crisp-sdk-web')
-    .then((module) => {
-      crisp = module.Crisp
-      return module.Crisp
-    })
-    .catch((error) => {
-      crispPromise = undefined
-      throw error
-    })
-
-  return crispPromise
-}
-
-export const openSupportChat = () => {
-  if (!crisp?.isCrispInjected()) return
-  crisp.chat.open()
-}
-
 export const initializeSupportSession = (user: ApiUser) => {
-  if (!crisp?.isCrispInjected()) return
-
+  if (!Crisp.isCrispInjected()) return
  const { id, email } = user
-  crisp.setTokenId(`meet-${id}`)
-  if (email) crisp.user.setEmail(email)
+  Crisp.setTokenId(`meet-${id}`)
+  if (email) Crisp.user.setEmail(email)
 }

 export const terminateSupportSession = () => {
-  if (!crisp?.isCrispInjected()) return
-
-  crisp.setTokenId()
-  crisp.session.reset()
+  if (!Crisp.isCrispInjected()) return
+  Crisp.setTokenId()
+  Crisp.session.reset()
 }

 export type useSupportProps = {
@@ -47,70 +22,26 @@ export type useSupportProps = {
  isDisabled?: boolean
 }

-const IDLE_TIMEOUT_MS = 10_000
-
-const scheduleWhenIdle = (callback: () => void): (() => void) => {
-  if (typeof window.requestIdleCallback === 'function') {
-    const handle = window.requestIdleCallback(callback, {
-      timeout: IDLE_TIMEOUT_MS,
-    })
-    return () => window.cancelIdleCallback(handle)
-  }
-
-  const handle = window.setTimeout(callback, 1)
-  return () => window.clearTimeout(handle)
-}
-
+// Configure Crisp chat for real-time support across all pages.
 export const useSupport = ({ id, isDisabled }: useSupportProps) => {
  const { user } = useUser()
-  const [isInjected, setIsInjected] = useState(
-    () => crisp?.isCrispInjected() ?? false
-  )

  useEffect(() => {
-    if (!id || isDisabled) return
-
-    if (crisp?.isCrispInjected()) {
-      setIsInjected(true)
-      return
-    }
-
-    let cancelled = false
-
-    const cancelIdle = scheduleWhenIdle(() => {
-      void loadCrisp()
-        .then((sdk) => {
-          if (cancelled) return
-
-          if (!sdk.isCrispInjected()) {
-            sdk.configure(id)
-            sdk.setHideOnMobile(true)
-          }
-
-          setIsInjected(true)
-        })
-        .catch((error) => {
-          if (!cancelled) {
-            console.error('Failed to initialize support chat', error)
-          }
-        })
-    })
-
-    return () => {
-      cancelled = true
-      cancelIdle()
-    }
+    if (!id || Crisp.isCrispInjected() || isDisabled) return
+    Crisp.configure(id)
+    Crisp.setHideOnMobile(true)
  }, [id, isDisabled])

  useEffect(() => {
-    if (!user || !isInjected || isDisabled) return
+    if (!user) return
    initializeSupportSession(user)
-  }, [user, isInjected, isDisabled])
+  }, [user])

  return null
 }

-// Some users block the chat widget, so check its availability safely.
+// Some users may block Crisp chat widget with browser ad blockers or anti-tracking plugins
+// So we need to safely check if Crisp is available and not blocked
 const isCrispAvailable = () => {
  try {
    return !!window?.$crisp?.is
@@ -33,21 +33,15 @@
    "accept": "Hereinlassen"
  },
  "transcript": {
-    "waitingForTracks": "Die Transkription wartet auf ein Mikrofon. Schalten Sie Ihr Mikrofon ein, damit die Transkription starten kann.",
    "started": "{{name}} hat die Meeting-Transkription gestartet.",
    "stopped": "{{name}} hat die Meeting-Transkription gestoppt.",
    "limitReached": "Die Transkription hat die maximal zulässige Dauer überschritten und wird automatisch gespeichert.",
-    "failed": "Die Transkription wurde unerwartet beendet und konnte nicht gespeichert werden.",
-    "aborted": "Die Transkription konnte nicht gestartet werden.",
    "requested": "{{name}} möchte die Meeting-Transkription starten."
  },
  "screenRecording": {
-    "waitingForTracks": "Die Aufnahme wartet auf Audio oder Video. Schalten Sie Ihr Mikrofon oder Ihre Kamera ein oder teilen Sie Ihren Bildschirm, damit die Aufnahme starten kann.",
    "started": "{{name}} hat die Meeting-Aufzeichnung gestartet.",
    "stopped": "{{name}} hat die Meeting-Aufzeichnung gestoppt.",
    "limitReached": "Die Aufzeichnung hat die maximal zulässige Dauer überschritten und wird automatisch gespeichert.",
-    "failed": "Die Aufzeichnung wurde unerwartet beendet und konnte nicht gespeichert werden.",
-    "aborted": "Die Aufzeichnung konnte nicht gestartet werden.",
    "requested": "{{name}} möchte die Meeting-Aufzeichnung starten."
  },
  "recordingSave": {
@@ -480,7 +480,7 @@
      "destination": "Ein neues Dokument wird erstellt auf",
      "destinationUnknown": "Ein neues Dokument wird erstellt",
      "language": "Meeting-Sprache:",
-      "recording": "Auch eine Videoaufzeichnung starten"
+      "recording": "Auch eine Aufzeichnung starten"
    },
    "button": {
      "start": "Meeting-Transkription starten",
@@ -756,24 +756,6 @@
    "muteParticipant": "{{name}} stummschalten",
    "fullScreen": "Vollbild"
  },
-  "screenShareZoom": {
-    "toolbarLabel": "Zoom-Steuerung für Bildschirmfreigabe",
-    "zoomIn": "Vergrößern",
-    "zoomInWithShortcut": "Vergrößern ({{shortcut}})",
-    "zoomOut": "Verkleinern",
-    "zoomOutWithShortcut": "Verkleinern ({{shortcut}})",
-    "wheelShortcut": "Steuerung plus Mausrad",
-    "wheelShortcutMac": "⌘+Mausrad",
-    "wheelShortcutHint": "Tastenkürzel: Steuerung plus Mausrad zum Vergrößern oder Verkleinern.",
-    "wheelShortcutHintMac": "Tastenkürzel: Befehl plus Mausrad zum Vergrößern oder Verkleinern.",
-    "fitToWindow": "An Fenster anpassen",
-    "fullScreen": "Vollbild",
-    "exitFullScreen": "Vollbild beenden",
-    "currentZoomLevel": "Zoom {{level}} %",
-    "panHint": "Zoom {{level}} %. Mit der Maus ziehen oder den Fokus zurück auf die Bildschirmfreigabe setzen und mit den Pfeiltasten im Bild navigieren.",
-    "fullScreenEntered": "Vollbild aktiviert",
-    "fullScreenExited": "Vollbild deaktiviert"
-  },
  "shortcutsPanel": {
    "title": "Tastenkürzel",
    "categories": {
@@ -793,11 +775,7 @@
      "raise-hand": "Hand heben oder senken",
      "toggle-chat": "Chat anzeigen/ausblenden",
      "toggle-participants": "Teilnehmende anzeigen/ausblenden",
-      "open-shortcuts-settings": "Tastenkürzel-Einstellungen öffnen",
-      "zoom-in": "In einen geteilten Bildschirm hineinzoomen",
-      "zoom-out": "Aus einem geteilten Bildschirm herauszoomen",
-      "zoom-reset": "Zoom des geteilten Bildschirms zurücksetzen",
-      "zoom-pan": "Im gezoomten geteilten Bildschirm navigieren"
+      "open-shortcuts-settings": "Tastenkürzel-Einstellungen öffnen"
    },
    "sr": {
      "control": "Steuerung",
@@ -807,14 +785,10 @@
      "shift": "Umschalt",
      "plus": "plus",
      "hold": "Halte {{key}} gedrückt",
-      "arrows": "Pfeiltasten",
-      "plusKey": "Plus-Taste",
-      "minusKey": "Minus-Taste",
      "noShortcut": "Kein Tastenkürzel"
    },
    "visual": {
-      "hold": "Halte {{key}} gedrückt",
-      "arrows": "↑ ↓ ← →"
+      "hold": "Halte {{key}} gedrückt"
    }
  },
  "fullScreenWarning": {
@@ -102,9 +102,6 @@
      },
      "messageReceived": {
        "label": "Nachricht erhalten"
-      },
-      "participantWaiting": {
-        "label": "Person im Warteraum"
      }
    }
  },
@@ -33,21 +33,15 @@
    "accept": "Accept"
  },
  "transcript": {
-    "waitingForTracks": "Transcription is waiting for a microphone. Turn on your microphone so the transcription can start.",
    "started": "{{name}} started the meeting transcription.",
    "stopped": "{{name}} stopped the meeting transcription.",
    "limitReached": "The transcription has exceeded the maximum allowed duration and will be automatically saved.",
-    "failed": "The transcription stopped unexpectedly and could not be saved.",
-    "aborted": "The transcription could not be started.",
    "requested": "{{name}} wants to start the meeting transcription."
  },
  "screenRecording": {
-    "waitingForTracks": "Recording is waiting for audio or video. Turn on your microphone or camera, or share your screen, so the recording can start.",
    "started": "{{name}} started the meeting recording.",
    "stopped": "{{name}} stopped the meeting recording.",
    "limitReached": "The recording has exceeded the maximum allowed duration and will be automatically saved.",
-    "failed": "The recording stopped unexpectedly and could not be saved.",
-    "aborted": "The recording could not be started.",
    "requested": "{{name}} wants to start the meeting recording."
  },
  "recordingSave": {
@@ -480,7 +480,7 @@
      "destination": "A new document will be created on",
      "destinationUnknown": "A new document will be created",
      "language": "Meeting language:",
-      "recording": "Also start a video recording"
+      "recording": "Also start a recording"
    },
    "button": {
      "start": "Start transcribing the meeting",
@@ -756,24 +756,6 @@
    "muteParticipant": "Mute {{name}}",
    "fullScreen": "Full screen"
  },
-  "screenShareZoom": {
-    "toolbarLabel": "Screen share zoom controls",
-    "zoomIn": "Zoom in",
-    "zoomInWithShortcut": "Zoom in ({{shortcut}})",
-    "zoomOut": "Zoom out",
-    "zoomOutWithShortcut": "Zoom out ({{shortcut}})",
-    "wheelShortcut": "Control plus scroll wheel",
-    "wheelShortcutMac": "⌘+scroll wheel",
-    "wheelShortcutHint": "Shortcut: Control plus scroll wheel to zoom in or out.",
-    "wheelShortcutHintMac": "Shortcut: Command plus scroll wheel to zoom in or out.",
-    "fitToWindow": "Fit to window",
-    "fullScreen": "Full screen",
-    "exitFullScreen": "Exit full screen",
-    "currentZoomLevel": "Zoom {{level}} %",
-    "panHint": "Zoom {{level}} %. Drag with mouse, or move focus back to the screen share and use arrow keys to navigate the picture.",
-    "fullScreenEntered": "Full screen enabled",
-    "fullScreenExited": "Full screen disabled"
-  },
  "shortcutsPanel": {
    "title": "Keyboard shortcuts",
    "categories": {
@@ -793,11 +775,7 @@
      "raise-hand": "Raise or lower hand",
      "toggle-chat": "Toggle chat",
      "toggle-participants": "Toggle participants",
-      "open-shortcuts-settings": "Open shortcuts settings",
-      "zoom-in": "Zoom in on a shared screen",
-      "zoom-out": "Zoom out on a shared screen",
-      "zoom-reset": "Reset the shared screen zoom",
-      "zoom-pan": "Move around a zoomed shared screen"
+      "open-shortcuts-settings": "Open shortcuts settings"
    },
    "sr": {
      "control": "Control",
@@ -807,14 +785,10 @@
      "shift": "Shift",
      "plus": "plus",
      "hold": "Hold {{key}}",
-      "arrows": "Arrow keys",
-      "plusKey": "Plus key",
-      "minusKey": "Minus key",
      "noShortcut": "No shortcut"
    },
    "visual": {
-      "hold": "Hold {{key}}",
-      "arrows": "↑ ↓ ← →"
+      "hold": "Hold {{key}}"
    }
  },
  "fullScreenWarning": {
@@ -102,9 +102,6 @@
      },
      "messageReceived": {
        "label": "Message received"
-      },
-      "participantWaiting": {
-        "label": "Participant waiting"
      }
    }
  },
@@ -33,21 +33,15 @@
    "accept": "Aceptar"
  },
  "transcript": {
-    "waitingForTracks": "La transcripción está esperando un micrófono. Activa el micrófono para que la transcripción pueda comenzar.",
    "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.",
-    "failed": "La transcripción se ha interrumpido de forma inesperada y no se ha podido guardar.",
-    "aborted": "No se ha podido iniciar la transcripción.",
    "requested": "{{name}} ha solicitado iniciar la transcripción."
  },
  "screenRecording": {
-    "waitingForTracks": "La grabación está esperando audio o vídeo. Activa el micrófono o la cámara, o comparte la pantalla, para que la grabación pueda comenzar.",
    "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.",
-    "failed": "La grabación se ha interrumpido de forma inesperada y no se ha podido guardar.",
-    "aborted": "No se ha podido iniciar la grabación.",
    "requested": "{{name}} ha solicitado iniciar la grabación."
  },
  "recordingSave": {
@@ -479,7 +479,7 @@
      "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 de vídeo"
+      "recording": "Iniciar también una grabación"
    },
    "button": {
      "start": "Empezar a transcribir la reunión",
@@ -755,24 +755,6 @@
    "muteParticipant": "Silenciar el micrófono de {{name}}",
    "fullScreen": "Pantalla completa"
  },
-  "screenShareZoom": {
-    "toolbarLabel": "Controles de zoom de la pantalla compartida",
-    "zoomIn": "Acercar",
-    "zoomInWithShortcut": "Acercar ({{shortcut}})",
-    "zoomOut": "Alejar",
-    "zoomOutWithShortcut": "Alejar ({{shortcut}})",
-    "wheelShortcut": "Control más rueda del ratón",
-    "wheelShortcutMac": "⌘+rueda del ratón",
-    "wheelShortcutHint": "Atajo: Control más rueda del ratón para acercar o alejar.",
-    "wheelShortcutHintMac": "Atajo: Comando más rueda del ratón para acercar o alejar.",
-    "fitToWindow": "Ajustar a la ventana",
-    "fullScreen": "Pantalla completa",
-    "exitFullScreen": "Salir de pantalla completa",
-    "currentZoomLevel": "Zoom {{level}} %",
-    "panHint": "Zoom {{level}} %. Arrastra con el ratón, o vuelve a la pantalla compartida y usa las flechas para moverte por la imagen.",
-    "fullScreenEntered": "Pantalla completa activada",
-    "fullScreenExited": "Pantalla completa desactivada"
-  },
  "shortcutsPanel": {
    "title": "Atajos de teclado",
    "categories": {
@@ -792,11 +774,7 @@
      "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",
-      "zoom-in": "Acercar una pantalla compartida",
-      "zoom-out": "Alejar una pantalla compartida",
-      "zoom-reset": "Restablecer el zoom de la pantalla compartida",
-      "zoom-pan": "Moverse por una pantalla compartida ampliada"
+      "open-shortcuts-settings": "Abrir los ajustes de los atajos"
    },
    "sr": {
      "control": "Control",
@@ -102,9 +102,6 @@
      },
      "messageReceived": {
        "label": "Un mensaje recibido"
-      },
-      "participantWaiting": {
-        "label": "Una persona en la sala de espera"
      }
    }
  },
@@ -33,21 +33,15 @@
    "accept": "Accepter"
  },
  "transcript": {
-    "waitingForTracks": "La transcription attend un microphone. Activez votre microphone pour permettre à la transcription de démarrer.",
    "started": "{{name}} a démarré la transcription de la réunion.",
    "stopped": "{{name}} a arrêté la transcription de la réunion.",
    "limitReached": "La transcription a dépassé la durée maximale autorisée, elle va être automatiquement sauvegardée.",
-    "failed": "La transcription s'est interrompue de façon inattendue et n'a pas pu être sauvegardée.",
-    "aborted": "La transcription n'a pas pu être démarrée.",
    "requested": "{{name}} a demandé à démarrer la transcription."
  },
  "screenRecording": {
-    "waitingForTracks": "L’enregistrement attend un flux audio ou vidéo. Activez votre microphone ou votre caméra, ou partagez votre écran, pour permettre à l’enregistrement de démarrer.",
    "started": "{{name}} a démarré l'enregistrement de la réunion.",
    "stopped": "{{name}} a arrêté l'enregistrement de la réunion.",
    "limitReached": "L'enregistrement a dépassé la durée maximale autorisée, il va être automatiquement sauvegardé.",
-    "failed": "L'enregistrement s'est interrompu de façon inattendue et n'a pas pu être sauvegardé.",
-    "aborted": "L'enregistrement n'a pas pu être démarré.",
    "requested": "{{name}} a demandé à démarrer l'enregistrement."
  },
  "recordingSave": {
@@ -480,7 +480,7 @@
      "destination": "Un nouveau document sera créé sur",
      "destinationUnknown": "Un nouveau document sera créé",
      "language": "Langue de la réunion :",
-      "recording": "Démarrer aussi un enregistrement vidéo"
+      "recording": "Démarrer aussi un enregistrement"
    },
    "button": {
      "start": "Commencer à transcrire la réunion",
@@ -756,24 +756,6 @@
    "muteParticipant": "Couper le micro de {{name}}",
    "fullScreen": "Plein écran"
  },
-  "screenShareZoom": {
-    "toolbarLabel": "Contrôles de zoom du partage d'écran",
-    "zoomIn": "Zoomer",
-    "zoomInWithShortcut": "Zoomer ({{shortcut}})",
-    "zoomOut": "Dézoomer",
-    "zoomOutWithShortcut": "Dézoomer ({{shortcut}})",
-    "wheelShortcut": "Contrôle plus molette",
-    "wheelShortcutMac": "⌘+molette",
-    "wheelShortcutHint": "Raccourci : Contrôle plus molette pour zoomer ou dézoomer.",
-    "wheelShortcutHintMac": "Raccourci : Commande plus molette pour zoomer ou dézoomer.",
-    "fitToWindow": "Ajuster à la fenêtre",
-    "fullScreen": "Plein écran",
-    "exitFullScreen": "Quitter le plein écran",
-    "currentZoomLevel": "Zoom {{level}} %",
-    "panHint": "Zoom {{level}} %. Glissez avec la souris, ou revenez sur le partage d'écran et utilisez les touches fléchées pour naviguer dans l'image.",
-    "fullScreenEntered": "Plein écran activé",
-    "fullScreenExited": "Plein écran désactivé"
-  },
  "shortcutsPanel": {
    "title": "Raccourcis clavier",
    "categories": {
@@ -793,11 +775,7 @@
      "raise-hand": "Lever ou baisser la main",
      "toggle-chat": "Afficher/Masquer le chat",
      "toggle-participants": "Afficher/Masquer les participants",
-      "open-shortcuts-settings": "Ouvrir les réglages des raccourcis",
-      "zoom-in": "Zoomer sur un écran partagé",
-      "zoom-out": "Dézoomer sur un écran partagé",
-      "zoom-reset": "Réinitialiser le zoom de l’écran partagé",
-      "zoom-pan": "Se déplacer dans un écran partagé zoomé"
+      "open-shortcuts-settings": "Ouvrir les réglages des raccourcis"
    },
    "sr": {
      "control": "Contrôle",
@@ -807,14 +785,10 @@
      "shift": "Majuscule",
      "plus": "plus",
      "hold": "Maintenir {{key}}",
-      "arrows": "Touches fléchées",
-      "plusKey": "Touche plus",
-      "minusKey": "Touche moins",
      "noShortcut": "Aucun raccourci"
    },
    "visual": {
-      "hold": "Maintenir {{key}}",
-      "arrows": "↑ ↓ ← →"
+      "hold": "Maintenir {{key}}"
    }
  },
  "fullScreenWarning": {
@@ -102,9 +102,6 @@
      },
      "messageReceived": {
        "label": "Un message reçu"
-      },
-      "participantWaiting": {
-        "label": "Une personne en salle d’attente"
      }
    }
  },
@@ -33,21 +33,15 @@
    "accept": "Accepteren"
  },
  "transcript": {
-    "waitingForTracks": "De transcriptie wacht op een microfoon. Zet uw microfoon aan, zodat de transcriptie kan starten.",
    "started": "{{name}} is de transcriptie van de vergadering gestart.",
    "stopped": "{{name}} heeft de transcriptie van de vergadering gestopt.",
    "limitReached": "De transcriptie heeft de maximaal toegestane duur overschreden en wordt automatisch opgeslagen.",
-    "failed": "De transcriptie is onverwacht gestopt en kon niet worden opgeslagen.",
-    "aborted": "De transcriptie kon niet worden gestart.",
    "requested": "{{name}} wil graag de transcriptie starten."
  },
  "screenRecording": {
-    "waitingForTracks": "De opname wacht op audio of video. Zet uw microfoon of camera aan of deel uw scherm, zodat de opname kan starten.",
    "started": "{{name}} is begonnen met het opnemen van de vergadering.",
    "stopped": "{{name}} is gestopt met het opnemen van de vergadering.",
    "limitReached": "De opname heeft de maximaal toegestane duur overschreden en wordt automatisch opgeslagen.",
-    "failed": "De opname is onverwacht gestopt en kon niet worden opgeslagen.",
-    "aborted": "De opname kon niet worden gestart.",
    "requested": "{{name}} wil graag de opname starten."
  },
  "recordingSave": {
@@ -480,7 +480,7 @@
      "destination": "Er wordt een nieuw document aangemaakt op",
      "destinationUnknown": "Een nieuw document wordt aangemaakt",
      "language": "Vergadertalen:",
-      "recording": "Start ook een video-opname"
+      "recording": "Start ook een opname"
    },
    "button": {
      "start": "Begin met het transcriberen van de vergadering",
@@ -756,24 +756,6 @@
    "muteParticipant": "Demp {{name}}",
    "fullScreen": "Volledig scherm"
  },
-  "screenShareZoom": {
-    "toolbarLabel": "Zoombediening voor schermdeling",
-    "zoomIn": "Inzoomen",
-    "zoomInWithShortcut": "Inzoomen ({{shortcut}})",
-    "zoomOut": "Uitzoomen",
-    "zoomOutWithShortcut": "Uitzoomen ({{shortcut}})",
-    "wheelShortcut": "Control plus scrollwiel",
-    "wheelShortcutMac": "⌘+scrollwiel",
-    "wheelShortcutHint": "Sneltoets: Control plus scrollwiel om in of uit te zoomen.",
-    "wheelShortcutHintMac": "Sneltoets: Command plus scrollwiel om in of uit te zoomen.",
-    "fitToWindow": "Aanpassen aan venster",
-    "fullScreen": "Volledig scherm",
-    "exitFullScreen": "Volledig scherm verlaten",
-    "currentZoomLevel": "Zoom {{level}} %",
-    "panHint": "Zoom {{level}} %. Sleep met de muis, of zet de focus terug op de schermdeling en gebruik de pijltjestoetsen om door het beeld te navigeren.",
-    "fullScreenEntered": "Volledig scherm ingeschakeld",
-    "fullScreenExited": "Volledig scherm uitgeschakeld"
-  },
  "shortcutsPanel": {
    "title": "Sneltoetsen",
    "categories": {
@@ -793,11 +775,7 @@
      "raise-hand": "Hand opsteken of laten zakken",
      "toggle-chat": "Chat tonen/verbergen",
      "toggle-participants": "Deelnemers tonen/verbergen",
-      "open-shortcuts-settings": "Sneltoets-instellingen openen",
-      "zoom-in": "Inzoomen op een gedeeld scherm",
-      "zoom-out": "Uitzoomen op een gedeeld scherm",
-      "zoom-reset": "Zoom van het gedeelde scherm herstellen",
-      "zoom-pan": "Navigeren in een ingezoomd gedeeld scherm"
+      "open-shortcuts-settings": "Sneltoets-instellingen openen"
    },
    "sr": {
      "control": "Control",
@@ -807,14 +785,10 @@
      "shift": "Shift",
      "plus": "plus",
      "hold": "Houd {{key}} ingedrukt",
-      "arrows": "Pijltoetsen",
-      "plusKey": "Plus-toets",
-      "minusKey": "Min-toets",
      "noShortcut": "Geen sneltoets"
    },
    "visual": {
-      "hold": "Houd {{key}} ingedrukt",
-      "arrows": "↑ ↓ ← →"
+      "hold": "Houd {{key}} ingedrukt"
    }
  },
  "fullScreenWarning": {
@@ -102,9 +102,6 @@
      },
      "messageReceived": {
        "label": "Bericht ontvangen"
-      },
-      "participantWaiting": {
-        "label": "Deelnemer in de wachtkamer"
      }
    }
  },
@@ -16,7 +16,6 @@ const DEFAULT_STATE: State = {
      [NotificationType.ParticipantJoined, true],
      [NotificationType.HandRaised, true],
      [NotificationType.MessageReceived, true],
-      [NotificationType.ParticipantWaiting, true],
    ])
  ),
  soundNotificationVolume: 0.1,
@@ -150,7 +150,6 @@ backend:
    # Frontend
    LIVEKIT_FORCE_WSS_PROTOCOL: True
    LIVEKIT_ENABLE_FIREFOX_PROXY_WORKAROUND: True
-    LIVEKIT_DEFAULT_VIDEO_CODEC: vp9
    FRONTEND_IDLE_DISCONNECT_WARNING_DELAY: 9000
    FRONTEND_SILENCE_LIVEKIT_DEBUG: False
    FRONTEND_SUPPORT: "{'id': '58ea6697-8eba-4492-bc59-ad6562585041', 'help_article_transcript': 'https://lasuite.crisp.help/fr/article/visio-transcript-1sjq43x', 'help_article_recording': 'https://lasuite.crisp.help/fr/article/visio-enregistrement-wgc8o0', 'help_article_more_tools': 'https://lasuite.crisp.help/fr/article/visio-tools-bvxj23'}"
@@ -74,7 +74,7 @@ spec:
            value: meet
          - name: MINIO_ROOT_PASSWORD
            value: password
-        image: "quay.io/minio/minio"
+        image: "minio/minio"
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 9000
@@ -103,7 +103,7 @@ spec:
    spec:
      containers:
      - name: mc
-        image: quay.io/minio/mc
+        image: minio/mc
        command:
          - /bin/sh
          - -c
@@ -1,4 +1,4 @@
 apiVersion: v2
 type: application
 name: meet
-version: 0.0.28
+version: 0.0.27
@@ -81,24 +81,18 @@
 | `backend.migrate.restartPolicy`                       | backend migrate job restart policy                                                 | `Never`                                                                                                                                                                                                                                                                             |
 | `backend.createsuperuser.command`                     | backend migrate command                                                            | `["/bin/sh","-c","while ! python manage.py check --database default > /dev/null 2>&1\ndo\n  echo \"Database not ready\"\n  sleep 2\ndone\necho \"Database is ready\"\n\npython manage.py createsuperuser --email $DJANGO_SUPERUSER_EMAIL --password $DJANGO_SUPERUSER_PASSWORD\n"]` |
 | `backend.createsuperuser.restartPolicy`               | backend migrate job restart policy                                                 | `Never`                                                                                                                                                                                                                                                                             |
-| `backend.probes.liveness.path`                        | Configure path for backend HTTP liveness probe                                     | `/__lbheartbeat__`                                                                                                                                                                                                                                                                  |
+| `backend.probes.liveness.path`                        | Configure path for backend HTTP liveness probe                                     | `/__heartbeat__`                                                                                                                                                                                                                                                                    |
 | `backend.probes.liveness.targetPort`                  | Configure port for backend HTTP liveness probe                                     | `undefined`                                                                                                                                                                                                                                                                         |
-| `backend.probes.liveness.initialDelaySeconds`         | Configure initial delay for backend liveness probe                                 | `undefined`                                                                                                                                                                                                                                                                         |
-| `backend.probes.liveness.periodSeconds`               | Configure period for backend liveness probe                                        | `30`                                                                                                                                                                                                                                                                                |
-| `backend.probes.liveness.timeoutSeconds`              | Configure timeout for backend liveness probe                                       | `5`                                                                                                                                                                                                                                                                                 |
-| `backend.probes.liveness.failureThreshold`            | Configure failure threshold for backend liveness probe                             | `undefined`                                                                                                                                                                                                                                                                         |
-| `backend.probes.startup.path`                         | Configure path for backend HTTP startup probe                                      | `/__lbheartbeat__`                                                                                                                                                                                                                                                                  |
+| `backend.probes.liveness.initialDelaySeconds`         | Configure initial delay for backend liveness probe                                 | `30`                                                                                                                                                                                                                                                                                |
+| `backend.probes.liveness.initialDelaySeconds`         | Configure timeout for backend liveness probe                                       | `30`                                                                                                                                                                                                                                                                                |
+| `backend.probes.startup.path`                         | Configure path for backend HTTP startup probe                                      | `undefined`                                                                                                                                                                                                                                                                         |
 | `backend.probes.startup.targetPort`                   | Configure port for backend HTTP startup probe                                      | `undefined`                                                                                                                                                                                                                                                                         |
 | `backend.probes.startup.initialDelaySeconds`          | Configure initial delay for backend startup probe                                  | `undefined`                                                                                                                                                                                                                                                                         |
-| `backend.probes.startup.periodSeconds`                | Configure period for backend startup probe                                         | `5`                                                                                                                                                                                                                                                                                 |
-| `backend.probes.startup.timeoutSeconds`               | Configure timeout for backend startup probe                                        | `5`                                                                                                                                                                                                                                                                                 |
-| `backend.probes.startup.failureThreshold`             | Configure failure threshold for backend startup probe                              | `12`                                                                                                                                                                                                                                                                                |
-| `backend.probes.readiness.path`                       | Configure path for backend HTTP readiness probe                                    | `/__heartbeat__`                                                                                                                                                                                                                                                                    |
+| `backend.probes.startup.initialDelaySeconds`          | Configure timeout for backend startup probe                                        | `undefined`                                                                                                                                                                                                                                                                         |
+| `backend.probes.readiness.path`                       | Configure path for backend HTTP readiness probe                                    | `/__lbheartbeat__`                                                                                                                                                                                                                                                                  |
 | `backend.probes.readiness.targetPort`                 | Configure port for backend HTTP readiness probe                                    | `undefined`                                                                                                                                                                                                                                                                         |
-| `backend.probes.readiness.initialDelaySeconds`        | Configure initial delay for backend readiness probe                                | `undefined`                                                                                                                                                                                                                                                                         |
-| `backend.probes.readiness.periodSeconds`              | Configure period for backend readiness probe                                       | `30`                                                                                                                                                                                                                                                                                |
-| `backend.probes.readiness.timeoutSeconds`             | Configure timeout for backend readiness probe                                      | `5`                                                                                                                                                                                                                                                                                 |
-| `backend.probes.readiness.failureThreshold`           | Configure failure threshold for backend readiness probe                            | `3`                                                                                                                                                                                                                                                                                 |
+| `backend.probes.readiness.initialDelaySeconds`        | Configure initial delay for backend readiness probe                                | `30`                                                                                                                                                                                                                                                                                |
+| `backend.probes.readiness.initialDelaySeconds`        | Configure timeout for backend readiness probe                                      | `30`                                                                                                                                                                                                                                                                                |
 | `backend.resources`                                   | Resource requirements for the backend container                                    | `{}`                                                                                                                                                                                                                                                                                |
 | `backend.nodeSelector`                                | Node selector for the backend Pod                                                  | `{}`                                                                                                                                                                                                                                                                                |
 | `backend.tolerations`                                 | Tolerations for the backend Pod                                                    | `[]`                                                                                                                                                                                                                                                                                |
@@ -217,24 +211,18 @@
 | `summary.service.port`                                | summary Service listening port                                                     | `80`               |
 | `summary.service.targetPort`                          | summary container listening port                                                   | `8000`             |
 | `summary.service.annotations`                         | Annotations to add to the summary Service                                          | `{}`               |
-| `summary.probes.liveness.path`                        | Configure path for summary HTTP liveness probe                                     | `/__lbheartbeat__` |
+| `summary.probes.liveness.path`                        | Configure path for summary HTTP liveness probe                                     | `/__heartbeat__`   |
 | `summary.probes.liveness.targetPort`                  | Configure port for summary HTTP liveness probe                                     | `undefined`        |
-| `summary.probes.liveness.initialDelaySeconds`         | Configure initial delay summary liveness probe                                     | `undefined`        |
-| `summary.probes.liveness.periodSeconds`               | Configure the period for the summary liveness probe                                | `30`               |
-| `summary.probes.liveness.timeoutSeconds`              | Configure timeout for summary liveness probe                                       | `5`                |
-| `summary.probes.liveness.failureThreshold`            | Configure failure threshold for summary liveness probe                             | `undefined`        |
-| `summary.probes.startup.path`                         | Configure path for summary HTTP startup probe                                      | `/__lbheartbeat__` |
+| `summary.probes.liveness.initialDelaySeconds`         | Configure initial delay for summary liveness probe                                 | `30`               |
+| `summary.probes.liveness.initialDelaySeconds`         | Configure timeout for summary liveness probe                                       | `30`               |
+| `summary.probes.startup.path`                         | Configure path for summary HTTP startup probe                                      | `undefined`        |
 | `summary.probes.startup.targetPort`                   | Configure port for summary HTTP startup probe                                      | `undefined`        |
 | `summary.probes.startup.initialDelaySeconds`          | Configure initial delay for summary startup probe                                  | `undefined`        |
-| `summary.probes.startup.periodSeconds`                | Configure period for the summary startup probe                                     | `5`                |
-| `summary.probes.startup.timeoutSeconds`               | Configure timeout for summary startup probe                                        | `5`                |
-| `summary.probes.startup.failureThreshold`             | Configure failure threshold for summary startup probe                              | `12`               |
-| `summary.probes.readiness.path`                       | Configure path for summary HTTP readiness probe                                    | `/__heartbeat__`   |
+| `summary.probes.startup.initialDelaySeconds`          | Configure timeout for summary startup probe                                        | `undefined`        |
+| `summary.probes.readiness.path`                       | Configure path for summary HTTP readiness probe                                    | `/__lbheartbeat__` |
 | `summary.probes.readiness.targetPort`                 | Configure port for summary HTTP readiness probe                                    | `undefined`        |
-| `summary.probes.readiness.initialDelaySeconds`        | Configure initial delay for summary readiness probe                                | `undefined`        |
-| `summary.probes.readiness.periodSeconds`              | Configure period for the summary readiness probe                                   | `30`               |
-| `summary.probes.readiness.timeoutSeconds`             | Configure timeout for summary readiness probe                                      | `5`                |
-| `summary.probes.readiness.failureThreshold`           | Configure failure threshold for summary readiness probe                            | `3`                |
+| `summary.probes.readiness.initialDelaySeconds`        | Configure initial delay for summary readiness probe                                | `30`               |
+| `summary.probes.readiness.initialDelaySeconds`        | Configure timeout for summary readiness probe                                      | `30`               |
 | `summary.resources`                                   | Resource requirements for the summary container                                    | `{}`               |
 | `summary.nodeSelector`                                | Node selector for the summary Pod                                                  | `{}`               |
 | `summary.tolerations`                                 | Tolerations for the summary Pod                                                    | `[]`               |
@@ -128,9 +128,6 @@ httpGet:
 {{- end }}
 initialDelaySeconds: {{ .initialDelaySeconds | eq nil | ternary 0 .initialDelaySeconds }}
 timeoutSeconds: {{ .timeoutSeconds | eq nil | ternary 1 .timeoutSeconds }}
-periodSeconds: {{ .periodSeconds | eq nil | ternary 10 .periodSeconds }}
-failureThreshold: {{ .failureThreshold | eq nil | ternary 3 .failureThreshold }}
-successThreshold: {{ .successThreshold | eq nil | ternary 1 .successThreshold }}
 {{- end }}

 {{/*
@@ -320,36 +320,26 @@ backend:
  ## @param backend.probes.liveness.initialDelaySeconds [nullable] Configure initial delay for backend liveness probe
  ## @param backend.probes.liveness.periodSeconds [nullable] Configure period for backend liveness probe
  ## @param backend.probes.liveness.timeoutSeconds [nullable] Configure timeout for backend liveness probe
-  ## @param backend.probes.liveness.failureThreshold [nullable] Configure failure threshold for backend liveness probe
  ## @param backend.probes.startup.path [nullable] Configure path for backend HTTP startup probe
  ## @param backend.probes.startup.targetPort [nullable] Configure port for backend HTTP startup probe
  ## @param backend.probes.startup.initialDelaySeconds [nullable] Configure initial delay for backend startup probe
  ## @param backend.probes.startup.periodSeconds [nullable] Configure period for backend startup probe
  ## @param backend.probes.startup.timeoutSeconds [nullable] Configure timeout for backend startup probe
-  ## @param backend.probes.startup.failureThreshold [nullable] Configure failure threshold for backend startup probe
  ## @param backend.probes.readiness.path [nullable] Configure path for backend HTTP readiness probe
  ## @param backend.probes.readiness.targetPort [nullable] Configure port for backend HTTP readiness probe
  ## @param backend.probes.readiness.initialDelaySeconds [nullable] Configure initial delay for backend readiness probe
  ## @param backend.probes.readiness.periodSeconds [nullable] Configure period for backend readiness probe
  ## @param backend.probes.readiness.timeoutSeconds [nullable] Configure timeout for backend readiness probe
-  ## @param backend.probes.readiness.failureThreshold [nullable] Configure failure threshold for backend readiness probe
  probes:
-    startup:
-      path: /__lbheartbeat__
-      periodSeconds: 5
-      timeoutSeconds: 5
-      failureThreshold: 12
-
    liveness:
-      path: /__lbheartbeat__
+      path: /__heartbeat__
+      initialDelaySeconds: 5
      periodSeconds: 30
-      timeoutSeconds: 5

    readiness:
-      path: /__heartbeat__
+      path: /__lbheartbeat__
+      initialDelaySeconds: 5
      periodSeconds: 30
-      timeoutSeconds: 5
-      failureThreshold: 3

  ## @param backend.resources Resource requirements for the backend container
  resources: {}
@@ -633,36 +623,25 @@ summary:
  ## @param summary.probes.liveness.initialDelaySeconds [nullable] Configure initial delay summary liveness probe
  ## @param summary.probes.liveness.periodSeconds [nullable] Configure the period for the summary liveness probe
  ## @param summary.probes.liveness.timeoutSeconds [nullable] Configure timeout for summary liveness probe
-  ## @param summary.probes.liveness.failureThreshold [nullable] Configure failure threshold for summary liveness probe
  ## @param summary.probes.startup.path [nullable] Configure path for summary HTTP startup probe
  ## @param summary.probes.startup.targetPort [nullable] Configure port for summary HTTP startup probe
  ## @param summary.probes.startup.initialDelaySeconds [nullable] Configure initial delay for summary startup probe
  ## @param summary.probes.startup.periodSeconds [nullable] Configure period for the summary startup probe
  ## @param summary.probes.startup.timeoutSeconds [nullable] Configure timeout for summary startup probe
-  ## @param summary.probes.startup.failureThreshold [nullable] Configure failure threshold for summary startup probe
  ## @param summary.probes.readiness.path [nullable] Configure path for summary HTTP readiness probe
  ## @param summary.probes.readiness.targetPort [nullable] Configure port for summary HTTP readiness probe
  ## @param summary.probes.readiness.initialDelaySeconds [nullable] Configure initial delay for summary readiness probe
  ## @param summary.probes.readiness.periodSeconds [nullable] Configure period for the summary readiness probe
  ## @param summary.probes.readiness.timeoutSeconds [nullable] Configure timeout for summary readiness probe
-  ## @param summary.probes.readiness.failureThreshold [nullable] Configure failure threshold for summary readiness probe
  probes:
-    startup:
-      path: /__lbheartbeat__
-      periodSeconds: 5
-      timeoutSeconds: 5
-      failureThreshold: 12
-
    liveness:
-      path: /__lbheartbeat__
-      periodSeconds: 30
-      timeoutSeconds: 5
-
-    readiness:
      path: /__heartbeat__
+      initialDelaySeconds: 5
+      periodSeconds: 30
+    readiness:
+      path: /__lbheartbeat__
+      initialDelaySeconds: 5
      periodSeconds: 30
-      timeoutSeconds: 5
-      failureThreshold: 3


  ## @param summary.resources Resource requirements for the summary container
@@ -1,12 +1,12 @@
 {
  "name": "mail_mjml",
-  "version": "1.32.1",
+  "version": "1.31.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "mail_mjml",
-      "version": "1.32.1",
+      "version": "1.31.0",
      "license": "MIT",
      "dependencies": {
        "@html-to/text-cli": "0.6.1",
@@ -1,6 +1,6 @@
 {
  "name": "mail_mjml",
-  "version": "1.32.1",
+  "version": "1.31.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.32.1",
+  "version": "1.31.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sdk",
-      "version": "1.32.1",
+      "version": "1.31.0",
      "license": "ISC",
      "workspaces": [
        "./library",
@@ -1,6 +1,6 @@
 {
  "name": "sdk",
-  "version": "1.32.1",
+  "version": "1.31.0",
  "author": "",
  "license": "ISC",
  "description": "",
@@ -1,7 +1,7 @@

 [project]
 name = "summary"
-version = "1.32.1"
+version = "1.31.0"
 requires-python = ">=3.13"
 dependencies = [
    "fastapi[standard]>=0.105.0",
@@ -10,7 +10,6 @@ dependencies = [
    "pydantic-settings>=2.1.0",
    "celery==5.6.3",
    "redis==5.2.1",
-    "dockerflow==2026.3.4",
    "minio==7.2.20",
    "openai==2.48.0",
    "posthog==7.29.0",
@@ -0,0 +1,17 @@
+"""API routes related to application health checking."""
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/__heartbeat__")
+async def heartbeat():
+    """Health check endpoint for monitoring."""
+    return
+
+
+@router.get("/__lbheartbeat__")
+async def lbheartbeat():
+    """Health check endpoint for load balancer."""
+    return
--- a/Show More
+++ b/Show More