Merge branch 'dev' into birdseye-layout

Resolve conflict in frigate/output/birdseye.py in favor of the single
pass layout algorithm from this branch. Dev's conflicting hunk was the
Optional to union type modernization of the two pass algorithm that this
branch removes.

Convert the new algorithm's Optional hints to unions, since dev dropped
Optional from the typing import in the same change.

.gitignore

@@ -12,7 +12,6 @@ config/*
 models
 *.mp4
 *.db
-*.db-*
 *.csv
 frigate/version.py
 web/build

docker/main/Dockerfile

@@ -81,10 +81,10 @@ RUN --mount=type=bind,source=docker/main/install_tempio.sh,target=/deps/install_
 FROM base_host AS ov-converter
 ARG DEBIAN_FRONTEND
 
-# Install OpenVINO for model conversion
+# Install OpenVino Runtime and Dev library
 COPY docker/main/requirements-ov.txt /requirements-ov.txt
 RUN apt-get -qq update \
-    && apt-get -qq install -y wget python3 python3-distutils \
+    && apt-get -qq install -y wget python3 python3-dev python3-distutils gcc pkg-config libhdf5-dev \
     && wget -q https://bootstrap.pypa.io/get-pip.py -O get-pip.py \
     && sed -i 's/args.append("setuptools")/args.append("setuptools==77.0.3")/' get-pip.py \
     && python3 get-pip.py "pip" \

docker/main/build_ov_model.py

@@ -1,42 +1,11 @@
-"""Convert the default SSDLite MobileNet v2 model to OpenVINO IR.
-
-Replaces the legacy openvino-dev Model Optimizer conversion. The TensorFlow
-frontend converts the Object Detection API frozen graph natively; the four TF
-outputs are then repacked into the single [1, 1, 100, 7] DetectionOutput-style
-tensor that Frigate's OpenVINO detector expects, and the input is flipped to
-BGR to match the legacy reverse_input_channels behavior.
-"""
-
-import numpy as np
 import openvino as ov
-from openvino import opset8 as ops
-from openvino.preprocess import PrePostProcessor
+from openvino.tools import mo
 
-model = ov.convert_model(
+ov_model = mo.convert_model(
     "/models/ssdlite_mobilenet_v2_coco_2018_05_09/frozen_inference_graph.pb",
-    input=[("image_tensor:0", [1, 300, 300, 3])],
+    compress_to_fp16=True,
+    transformations_config="/usr/local/lib/python3.11/dist-packages/openvino/tools/mo/front/tf/ssd_v2_support.json",
+    tensorflow_object_detection_api_pipeline_config="/models/ssdlite_mobilenet_v2_coco_2018_05_09/pipeline.config",
+    reverse_input_channels=True,
 )
-
-# rows of (image_id, class_id, score, xmin, ymin, xmax, ymax)
-boxes = model.output("detection_boxes:0").get_node().input_value(0)
-classes = model.output("detection_classes:0").get_node().input_value(0)
-scores = model.output("detection_scores:0").get_node().input_value(0)
-
-# (ymin,xmin,ymax,xmax) -> (xmin,ymin,xmax,ymax)
-boxes = ops.gather(boxes, [1, 0, 3, 2], 2)
-classes = ops.unsqueeze(classes, 2)
-scores = ops.unsqueeze(scores, 2)
-image_id = ops.multiply(scores, np.float32(0.0))
-
-detections = ops.concat([image_id, classes, scores, boxes], 2)
-detections = ops.unsqueeze(detections, 1)
-detections.output(0).get_tensor().set_names({"detection_out"})
-
-model = ov.Model([detections], model.get_parameters(), "ssdlite_mobilenet_v2")
-
-ppp = PrePostProcessor(model)
-ppp.input().tensor().set_layout(ov.Layout("NHWC"))
-ppp.input().preprocess().reverse_channels()
-model = ppp.build()
-
-ov.save_model(model, "/models/ssdlite_mobilenet_v2.xml", compress_to_fp16=True)
+ov.save_model(ov_model, "/models/ssdlite_mobilenet_v2.xml")

docker/main/requirements-ov.txt

@@ -1,2 +1,3 @@
 numpy
-openvino >= 2026.2.0
+tensorflow
+openvino-dev>=2024.0.0

docs/docs/frigate/installation.md

@@ -78,7 +78,7 @@ Users of the Snapcraft build of Docker cannot use storage locations outside your
 
 Frigate utilizes shared memory to store frames during processing. The default `shm-size` provided by Docker is **64MB**.
 
-The default shm size of **128MB** is fine for setups with **2 cameras** detecting at **720p**. If Frigate is exiting with "Bus error" messages, it is likely because you have too many high resolution cameras and you need to specify a higher shm size, using [`--shm-size`](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources) (or [`service.shm_size`](https://docs.docker.com/compose/compose-file/compose-file-v2/#shm_size) in Docker Compose). If raising the shm size does not help, check your [process and file limits](#process-and-file-limits) as well.
+The default shm size of **128MB** is fine for setups with **2 cameras** detecting at **720p**. If Frigate is exiting with "Bus error" messages, it is likely because you have too many high resolution cameras and you need to specify a higher shm size, using [`--shm-size`](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources) (or [`service.shm_size`](https://docs.docker.com/compose/compose-file/compose-file-v2/#shm_size) in Docker Compose).
 
 The Frigate container also stores logs in shm, which can take up to **40MB**, so make sure to take this into account in your math as well.
 
@@ -86,30 +86,6 @@ The Frigate container also stores logs in shm, which can take up to **40MB**, so
 
 The shm size cannot be set per container for Home Assistant Apps. However, this is probably not required since by default Home Assistant Supervisor allocates `/dev/shm` with half the size of your total memory. If your machine has 8GB of memory, chances are that Frigate will have access to up to 4GB without any additional configuration.
 
-### Process and file limits
-
-Frigate runs many processes and opens a number of shared memory files. Installs with a large number of cameras can exceed the default limits your container runtime applies.
-
-Hitting the PID limit logs `RuntimeError: can't start new thread`, often followed by a "Bus error" that makes it look like an shm sizing problem. Compare the current count against the max from inside the container:
-
-```bash
-cat /sys/fs/cgroup/pids.current
-cat /sys/fs/cgroup/pids.max
-```
-
-If these are close, raise the limit with [`--pids-limit`](https://docs.docker.com/engine/containers/resource_constraints/) (or `service.pids_limit` in Docker Compose).
-
-Running out of file descriptors logs `OSError: [Errno 24] Too many open files`. Raise the limit in Docker Compose:
-
-```yaml
-services:
-  frigate:
-    ulimits:
-      nofile:
-        soft: 65535
-        hard: 65535
-```
-
 ## Extra Steps for Specific Hardware
 
 The following sections contain additional setup steps that are only required if you are using specific hardware. If you are not using any of these hardware types, you can skip to the [Docker](#docker) installation section.
@@ -508,6 +484,7 @@ Generate a Frigate Docker Compose configuration based on your hardware and requi
 
 <DockerComposeGenerator/>
 
+
   </TabItem>
   <TabItem value="original" label="Example Docker Compose File">
 ```yaml

frigate/api/app.py

@@ -31,7 +31,6 @@ from frigate.api.auth import (
     get_allowed_cameras_for_filter,
     require_role,
 )
-from frigate.api.config_util import swap_runtime_config
 from frigate.api.defs.query.app_query_parameters import AppTimelineHourlyQueryParameters
 from frigate.api.defs.request.app_body import (
     AppConfigSetBody,
@@ -916,7 +915,19 @@ def config_set(request: Request, body: AppConfigSetBody):
 
             if body.requires_restart == 0 or body.update_topic:
                 old_config: FrigateConfig = request.app.frigate_config
-                swap_runtime_config(request.app, config)
+                request.app.frigate_config = config
+                request.app.genai_manager.update_config(config)
+
+                if request.app.profile_manager is not None:
+                    request.app.profile_manager.update_config(config)
+
+                if request.app.stats_emitter is not None:
+                    request.app.stats_emitter.config = config
+
+                if request.app.dispatcher is not None:
+                    request.app.dispatcher.config = config
+                    for comm in request.app.dispatcher.comms:
+                        comm.config = config
 
                 if body.update_topic:
                     if body.update_topic.startswith("config/cameras/"):
@@ -960,11 +971,7 @@ def config_set(request: Request, body: AppConfigSetBody):
                 content=(
                     {
                         "success": True,
-                        "message": (
-                            "Config successfully updated"
-                            if body.requires_restart == 0
-                            else "Config successfully updated, restart to apply"
-                        ),
+                        "message": "Config successfully updated, restart to apply",
                     }
                 ),
                 status_code=200,

frigate/api/camera.py

@@ -25,7 +25,6 @@ from frigate.api.auth import (
     require_go2rtc_stream_access,
     require_role,
 )
-from frigate.api.config_util import swap_runtime_config
 from frigate.api.defs.request.app_body import CameraSetBody
 from frigate.api.defs.tags import Tags
 from frigate.config import FrigateConfig
@@ -1255,14 +1254,9 @@ async def delete_camera(
                     status_code=500,
                 )
 
-            # rebind every collaborator to the new config and re-layer runtime
-            # toggles for the surviving cameras, same as /api/config/set
-            swap_runtime_config(request.app, config)
-
-            # drop the deleted camera's persisted overrides so a camera later
-            # added under the same name doesn't inherit them
-            if request.app.dispatcher is not None:
-                request.app.dispatcher.clear_runtime_state_for_camera(camera_name)
+            # Update runtime config
+            request.app.frigate_config = config
+            request.app.genai_manager.update_config(config)
 
             # Publish removal to stop ffmpeg processes and clean up runtime state
             request.app.config_publisher.publish_update(

frigate/api/config_util.py

@@ -1,35 +0,0 @@
-"""Shared helpers for applying a freshly parsed config to the running app."""
-
-from fastapi import FastAPI
-
-from frigate.config import FrigateConfig
-
-
-def swap_runtime_config(app: FastAPI, config: FrigateConfig) -> None:
-    """Point every long-lived collaborator at a newly parsed config object.
-
-    Both /api/config/set and camera deletion re-parse yaml into a fresh
-    FrigateConfig and must rebind the same set of references, or the API and
-    the dispatcher drift onto different objects (the API reports one camera
-    state while the dispatcher acts on another). Runtime toggle overrides are
-    re-layered last: the swap rebuilt every camera from yaml, so without this a
-    camera the user turned off would silently come back on.
-    """
-    app.frigate_config = config
-    app.genai_manager.update_config(config)
-
-    if app.profile_manager is not None:
-        app.profile_manager.update_config(config)
-
-    if app.stats_emitter is not None:
-        app.stats_emitter.config = config
-
-    if app.dispatcher is not None:
-        app.dispatcher.config = config
-
-        for comm in app.dispatcher.comms:
-            comm.config = config
-
-        # workers still hold the live toggle values, so correct only the
-        # config object here rather than re-broadcasting every override
-        app.dispatcher.reapply_runtime_state_to_config()

frigate/camera/maintainer.py

@@ -117,9 +117,7 @@ class CameraMaintainer(threading.Thread):
 
         if runtime:
             self.camera_metrics[name] = CameraMetrics(self.metrics_manager)
-            self.ptz_metrics[name] = PTZMetrics(
-                autotracker_enabled=config.onvif.autotracking.enabled
-            )
+            self.ptz_metrics[name] = PTZMetrics(autotracker_enabled=False)
             self.region_grids[name] = get_camera_regions_grid(
                 name,
                 config.detect,

frigate/camera/state.py

@@ -111,9 +111,9 @@ class CameraState:
                 # draw thicker box around ptz autotracked object
                 if (
                     self.camera_config.onvif.autotracking.enabled
-                    and self.ptz_autotracker_thread.ptz_autotracker.autotracker_init.get(
+                    and self.ptz_autotracker_thread.ptz_autotracker.autotracker_init[
                         self.name
-                    )
+                    ]
                     and self.ptz_autotracker_thread.ptz_autotracker.tracked_object[
                         self.name
                     ]

frigate/comms/dispatcher.py

@@ -404,64 +404,38 @@ class Dispatcher:
         for comm in self.comms:
             comm.stop()
 
-    def apply_runtime_state(self) -> dict[str, dict[str, bool]]:
+    def restore_runtime_state(self) -> None:
         """Replay persisted runtime overrides through the camera settings handlers.
 
-        Routing through the handlers (rather than mutating config directly) is
-        deliberate: they publish the ``config_updater`` broadcast and the
-        retained MQTT state as a side effect, so worker processes and the UI
-        converge on the replayed value. Unknown cameras and topics are skipped;
-        handler exceptions are logged and replay continues for the rest.
-
-        Returns:
-            The entries handed to a handler without raising, keyed by camera
-            then topic. A handler can still refuse the value internally (an ON
-            payload for a camera that is not enabled_in_config, for example),
-            so this is not proof the override took effect.
+        Called once after Frigate startup completes so processing threads can
+        receive the resulting ``config_updater`` broadcasts. Unknown cameras
+        and topics are skipped; handler exceptions are logged and replay
+        continues for remaining entries.
         """
         state = self._runtime_state.load()
-        applied: dict[str, dict[str, bool]] = {}
-
         for camera_name, features in state.items():
             if camera_name not in self.config.cameras:
                 continue
-
             for topic, value in features.items():
                 handler = self._camera_settings_handlers.get(topic)
-
                 if handler is None:
                     continue
-
                 payload = "ON" if value else "OFF"
-
                 try:
                     handler(camera_name, payload)
                 except Exception:
                     logger.exception(
-                        "Failed to apply runtime state %s.%s=%s",
+                        "Failed to restore runtime state %s.%s=%s",
                         camera_name,
                         topic,
                         payload,
                     )
                     continue
-
-                applied.setdefault(camera_name, {})[topic] = value
-
-        return applied
-
-    def restore_runtime_state(self) -> None:
-        """Replay persisted runtime overrides once Frigate startup completes.
-
-        Called after every ``config_updater`` subscriber is up so the resulting
-        broadcasts are not dropped by ZMQ PUB/SUB.
-        """
-        for camera_name, features in self.apply_runtime_state().items():
-            for topic, value in features.items():
                 logger.info(
                     "Restored runtime state: %s.%s=%s",
                     camera_name,
                     topic,
-                    "ON" if value else "OFF",
+                    payload,
                 )
 
     def clear_runtime_state_for_yaml_keys(self, dotted_keys: Iterable[str]) -> None:
@@ -484,56 +458,6 @@ class Dispatcher:
         """
         self._runtime_state.clear_all()
 
-    def clear_runtime_state_for_camera(self, camera: str) -> None:
-        """Drop all persisted runtime overrides for a deleted camera.
-
-        Called by camera deletion so a camera later added under the same name
-        does not inherit the removed camera's stale toggles.
-        """
-        self._runtime_state.clear_camera(camera)
-
-    def reapply_runtime_state_to_config(self) -> None:
-        """Re-apply persisted runtime overrides to the swapped-in config object.
-
-        After config/set (or a camera delete) parses fresh yaml and swaps the
-        config, the worker processes still hold the live toggle values and the
-        overrides are already on disk, so only the in-process config object is
-        out of date. Unlike apply_runtime_state (used at startup, where workers
-        must be told), this makes no ZMQ, MQTT, or disk writes, it just corrects
-        the config the API and dispatcher read.
-
-        The field mutations and gates mirror the _on_*_command handlers; keep
-        the two in sync if a tracked toggle is added or its gate changes.
-        """
-        state = self._runtime_state.load()
-
-        for camera_name, features in state.items():
-            camera = self.config.cameras.get(camera_name)
-
-            if camera is None:
-                continue
-
-            for topic, value in features.items():
-                if topic == "enabled":
-                    if value and not camera.enabled_in_config:
-                        continue
-                    camera.enabled = value
-                elif topic == "detect":
-                    camera.detect.enabled = value
-                    # detection requires motion, mirror the handler coupling
-                    if value and not camera.motion.enabled:
-                        camera.motion.enabled = True
-                elif topic == "snapshots":
-                    camera.snapshots.enabled = value
-                elif topic == "recordings":
-                    if value and not camera.record.enabled_in_config:
-                        continue
-                    camera.record.enabled = value
-                elif topic == "audio":
-                    if value and not camera.audio.enabled_in_config:
-                        continue
-                    camera.audio.enabled = value
-
     def _on_detect_command(self, camera_name: str, payload: str) -> None:
         """Callback for detect topic."""
         detect_settings = self.config.cameras[camera_name].detect
@@ -664,10 +588,6 @@ class Dispatcher:
                 self.ptz_metrics[camera_name].start_time.value = 0
                 ptz_autotracker_settings.enabled = False
 
-        self.config_updater.publish_update(
-            CameraConfigUpdateTopic(CameraConfigUpdateEnum.autotracking, camera_name),
-            ptz_autotracker_settings,
-        )
         self.publish(f"{camera_name}/ptz_autotracker/state", payload, retain=True)
 
     def _on_motion_contour_area_command(self, camera_name: str, payload: int) -> None:

frigate/comms/runtime_state.py

@@ -96,25 +96,6 @@ class RuntimeStatePersistence:
         except OSError:
             logger.exception("Failed to clear runtime state")
 
-    def clear_camera(self, camera: str) -> None:
-        """Drop every stored override for a single camera.
-
-        Called when a camera is deleted so a camera later added under the same
-        name does not inherit the removed camera's stale toggles.
-        """
-        try:
-            with FileLock(self._lock_path, timeout=self._lock_timeout):
-                data = self._read_locked()
-                cameras = data.get("cameras")
-                if not isinstance(cameras, dict) or camera not in cameras:
-                    return
-                del cameras[camera]
-                self._write_locked(data)
-        except Timeout:
-            logger.error("Timed out clearing runtime state for camera")
-        except OSError:
-            logger.exception("Failed to clear runtime state for camera")
-
     def clear_for_yaml_keys(self, dotted_keys: Iterable[str]) -> None:
         """Remove stored entries whose YAML key was just rewritten.
 

frigate/config/camera/updater.py

@@ -14,7 +14,6 @@ class CameraConfigUpdateEnum(str, Enum):
     add = "add"  # for adding a camera
     audio = "audio"
     audio_transcription = "audio_transcription"
-    autotracking = "autotracking"  # ptz autotracking only, without an onvif reinit
     birdseye = "birdseye"
     detect = "detect"
     enabled = "enabled"
@@ -146,8 +145,6 @@ class CameraConfigUpdateSubscriber:
             config.snapshots = updated_config
         elif update_type == CameraConfigUpdateEnum.onvif:
             config.onvif = updated_config
-        elif update_type == CameraConfigUpdateEnum.autotracking:
-            config.onvif.autotracking = updated_config
         elif update_type == CameraConfigUpdateEnum.timestamp_style:
             config.timestamp_style = updated_config
         elif update_type == CameraConfigUpdateEnum.zones:

frigate/config/profile_manager.py

@@ -141,11 +141,6 @@ class ProfileManager:
         Preserves active profile state: re-snapshots base configs from the new
         (freshly parsed) config, then re-applies profile overrides if a profile
         was active.
-
-        Deliberately does not clear the dispatcher's runtime overrides. This is
-        the config-save path, not a profile switch: the save only invalidates
-        the toggles it rewrote in yaml, which /api/config/set already clears by
-        key. The broad wipe belongs to activate_profile alone.
         """
         current_active = self.config.active_profile
         self.config = new_config
@@ -169,6 +164,10 @@ class ProfileManager:
                 self.config.active_profile = None
                 self._persist_active_profile(None)
 
+            # drop all runtime overrides so they don't replay stale values on restart
+            if self.dispatcher is not None:
+                self.dispatcher.clear_runtime_state()
+
     def activate_profile(
         self,
         profile_name: str | None,

frigate/output/birdseye.py

@@ -335,7 +335,6 @@ class BirdsEyeFrameManager:
 
         self.camera_layout: list[Any] = []
         self.active_cameras: set[str] = set()
-        self.layout_camera_order: list[str] = []
         self.last_output_time = 0.0
 
     def add_camera(self, cam: str) -> None:
@@ -373,13 +372,6 @@ class BirdsEyeFrameManager:
         if cam in self.cameras:
             del self.cameras[cam]
 
-    def sort_cameras(self, cameras: set[str]) -> list[str]:
-        """Sort cameras by birdseye order, falling back to name when tied."""
-        return sorted(
-            cameras,
-            key=lambda camera: (self.config.cameras[camera].birdseye.order, camera),
-        )
-
     def clear_frame(self) -> None:
         logger.debug("Clearing the birdseye frame")
         self.frame[:] = self.blank_frame
@@ -490,7 +482,6 @@ class BirdsEyeFrameManager:
             # if the layout needs to be cleared
             self.camera_layout = []
             self.active_cameras = set()
-            self.layout_camera_order = []
             self.clear_frame()
             frame_changed = True
             layout_changed = True
@@ -509,21 +500,21 @@ class BirdsEyeFrameManager:
             else:
                 reset_layout = True
 
-            sorted_active_cameras = self.sort_cameras(active_cameras)
-
-            if not reset_layout and sorted_active_cameras != self.layout_camera_order:
-                logger.debug("Birdseye camera order changed")
-                reset_layout = True
-
             if reset_layout:
                 logger.debug("Resetting Birdseye layout...")
                 self.clear_frame()
                 self.active_cameras = active_cameras
-                self.layout_camera_order = sorted_active_cameras
                 layout_changed = True  # Layout is changing due to reset
                 # this also converts added_cameras from a set to a list since we need
                 # to pop elements in order
-                active_cameras_to_add = sorted_active_cameras
+                active_cameras_to_add = sorted(
+                    active_cameras,
+                    # sort cameras by order and by name if the order is the same
+                    key=lambda active_camera: (
+                        self.config.cameras[active_camera].birdseye.order,
+                        active_camera,
+                    ),
+                )
                 if len(active_cameras) == 1:
                     # show single camera as fullscreen
                     camera = active_cameras_to_add[0]
@@ -604,112 +595,92 @@ class BirdsEyeFrameManager:
     ) -> list[list[Any]] | None:
         """Calculate the optimal layout for 2+ cameras."""
 
-        def map_layout(
-            camera_layout: list[list[Any]], row_height: int
-        ) -> tuple[int, int, list[list[Any]] | None]:
-            """Map the calculated layout."""
-            candidate_layout = []
-            starting_x = 0
-            x = 0
-            max_width = 0
-            y = 0
+        def find_available_x(
+            current_x: int,
+            width: int,
+            reserved_ranges: list[tuple[int, int]],
+            max_width: int,
+        ) -> int | None:
+            """Find the first horizontal slot that does not collide with reservations."""
+            x = current_x
 
-            for row in camera_layout:
-                final_row = []
-                max_width = max(max_width, x)
-                x = starting_x
-                for cameras in row:
-                    camera_dims = self.cameras[cameras[0]]["dimensions"].copy()
-                    camera_aspect = cameras[1]
+            for reserved_start, reserved_end in sorted(reserved_ranges):
+                if x >= reserved_end:
+                    continue
 
-                    if camera_dims[1] > camera_dims[0]:
-                        scaled_height = int(row_height * 2)
-                        scaled_width = int(scaled_height * camera_aspect)
-                        starting_x = scaled_width
-                    else:
-                        scaled_height = row_height
-                        scaled_width = int(scaled_height * camera_aspect)
+                if x + width <= reserved_start:
+                    return x
 
-                    # layout is too large
-                    if (
-                        x + scaled_width > self.canvas.width
-                        or y + scaled_height > self.canvas.height
-                    ):
-                        return x + scaled_width, y + scaled_height, None
+                x = max(x, reserved_end)
 
-                    final_row.append((cameras[0], (x, y, scaled_width, scaled_height)))
-                    x += scaled_width
+            if x + width <= max_width:
+                return x
 
-                y += row_height
-                candidate_layout.append(final_row)
-
-            if max_width == 0:
-                max_width = x
-
-            return max_width, y, candidate_layout
-
-        canvas_aspect_x, canvas_aspect_y = self.canvas.get_aspect(coefficient)
-        camera_layout: list[list[Any]] = []
-        camera_layout.append([])
-        starting_x = 0
-        x = starting_x
-        y = 0
-        y_i = 0
-        max_y = 0
-        for camera in cameras_to_add:
-            camera_dims = self.cameras[camera]["dimensions"].copy()
-            camera_aspect_x, camera_aspect_y = self.canvas.get_camera_aspect(
-                camera, camera_dims[0], camera_dims[1]
-            )
-
-            if camera_dims[1] > camera_dims[0]:
-                portrait = True
-            else:
-                portrait = False
-
-            if (x + camera_aspect_x) <= canvas_aspect_x:
-                # insert if camera can fit on current row
-                camera_layout[y_i].append(
-                    (
-                        camera,
-                        camera_aspect_x / camera_aspect_y,
-                    )
-                )
-
-                if portrait:
-                    starting_x = camera_aspect_x
-                else:
-                    max_y = max(
-                        max_y,
-                        camera_aspect_y,
-                    )
-
-                x += camera_aspect_x
-            else:
-                # move on to the next row and insert
-                y += max_y
-                y_i += 1
-                camera_layout.append([])
-                x = starting_x
-
-                if x + camera_aspect_x > canvas_aspect_x:
-                    return None
-
-                camera_layout[y_i].append(
-                    (
-                        camera,
-                        camera_aspect_x / camera_aspect_y,
-                    )
-                )
-                x += camera_aspect_x
-
-        if y + max_y > canvas_aspect_y:
             return None
 
-        row_height = int(self.canvas.height / coefficient)
-        total_width, total_height, standard_candidate_layout = map_layout(
-            camera_layout, row_height
-        )
+        def map_layout(row_height: int) -> tuple[int, int, list[list[Any]] | None]:
+            """Lay out cameras row by row while reserving portrait spans for the next row."""
+            candidate_layout: list[list[Any]] = []
+            reserved_ranges: dict[int, list[tuple[int, int]]] = {}
+            current_row: list[Any] = []
+            row_index = 0
+            row_y = 0
+            row_x = 0
+            max_width = 0
+            max_height = 0
+
+            for camera in cameras_to_add:
+                camera_dims = self.cameras[camera]["dimensions"].copy()
+                camera_aspect_x, camera_aspect_y = self.canvas.get_camera_aspect(
+                    camera, camera_dims[0], camera_dims[1]
+                )
+                portrait = camera_dims[1] > camera_dims[0]
+                scaled_height = row_height * 2 if portrait else row_height
+                scaled_width = int(scaled_height * (camera_aspect_x / camera_aspect_y))
+
+                while True:
+                    x = find_available_x(
+                        row_x,
+                        scaled_width,
+                        reserved_ranges.get(row_index, []),
+                        self.canvas.width,
+                    )
+
+                    if x is not None and row_y + scaled_height <= self.canvas.height:
+                        current_row.append(
+                            (camera, (x, row_y, scaled_width, scaled_height))
+                        )
+                        row_x = x + scaled_width
+                        max_width = max(max_width, row_x)
+                        max_height = max(max_height, row_y + scaled_height)
+
+                        if portrait:
+                            reserved_ranges.setdefault(row_index + 1, []).append(
+                                (x, row_x)
+                            )
+
+                        break
+
+                    if current_row:
+                        candidate_layout.append(current_row)
+                        current_row = []
+
+                    row_index += 1
+                    row_y = row_index * row_height
+                    row_x = 0
+
+                    if row_y + scaled_height > self.canvas.height:
+                        overflow_width = max(max_width, scaled_width)
+                        overflow_height = row_y + scaled_height
+                        return overflow_width, overflow_height, None
+
+            if current_row:
+                candidate_layout.append(current_row)
+
+            return max_width, max_height, candidate_layout
+
+        row_height = max(1, int(self.canvas.height / coefficient))
+        total_width, total_height, standard_candidate_layout = map_layout(row_height)
 
         if not standard_candidate_layout:
             # if standard layout didn't work
@@ -718,9 +689,9 @@ class BirdsEyeFrameManager:
                 total_width / self.canvas.width,
                 total_height / self.canvas.height,
             )
-            row_height = int(row_height / scale_down_percent)
+            row_height = max(1, int(row_height / scale_down_percent))
             total_width, total_height, standard_candidate_layout = map_layout(
-                camera_layout, row_height
+                row_height
             )
 
             if not standard_candidate_layout:
@@ -734,8 +705,8 @@ class BirdsEyeFrameManager:
             1 / (total_width / self.canvas.width),
             1 / (total_height / self.canvas.height),
         )
-        row_height = int(row_height * scale_up_percent)
-        _, _, scaled_layout = map_layout(camera_layout, row_height)
+        row_height = max(1, int(row_height * scale_up_percent))
+        _, _, scaled_layout = map_layout(row_height)
 
         if scaled_layout:
             return scaled_layout
@@ -789,7 +760,6 @@ class BirdsEyeFrameManager:
             frame_changed, layout_changed = False, False
             self.active_cameras = set()
             self.camera_layout = []
-            self.layout_camera_order = []
             print(traceback.format_exc())
 
         # if the frame was updated or the fps is too low, send frame

frigate/ptz/autotrack.py

@@ -20,10 +20,6 @@ from norfair.camera_motion import (
 from frigate.camera import PTZMetrics
 from frigate.comms.dispatcher import Dispatcher
 from frigate.config import CameraConfig, FrigateConfig, ZoomingModeEnum
-from frigate.config.camera.updater import (
-    CameraConfigUpdateEnum,
-    CameraConfigUpdateSubscriber,
-)
 from frigate.const import (
     AUTOTRACKING_MAX_AREA_RATIO,
     AUTOTRACKING_MAX_MOVE_METRICS,
@@ -198,9 +194,7 @@ class PtzAutoTrackerThread(threading.Thread):
 
     def run(self):
         while not self.stop_event.wait(1):
-            self.ptz_autotracker.check_for_updates()
-
-            for camera, camera_config in list(self.config.cameras.items()):
+            for camera, camera_config in self.config.cameras.items():
                 if not camera_config.enabled:
                     continue
 
@@ -217,7 +211,6 @@ class PtzAutoTrackerThread(threading.Thread):
                         self.ptz_autotracker.tracked_object[camera] = None
                         self.ptz_autotracker.tracked_object_history[camera].clear()
 
-        self.ptz_autotracker.config_subscriber.stop()
         logger.info("Exiting autotracker...")
 
 
@@ -251,16 +244,6 @@ class PtzAutoTracker:
         self.zoom_time: dict[str, float] = {}
         self.zoom_factor: dict[str, object] = {}
 
-        self.config_subscriber = CameraConfigUpdateSubscriber(
-            self.config,
-            self.config.cameras,
-            [
-                CameraConfigUpdateEnum.add,
-                CameraConfigUpdateEnum.autotracking,
-                CameraConfigUpdateEnum.onvif,
-            ],
-        )
-
         # if cam is set to autotrack, onvif should be set up
         for camera, camera_config in self.config.cameras.items():
             if not camera_config.enabled:
@@ -277,29 +260,6 @@ class PtzAutoTracker:
                 # Wait for the coroutine to complete
                 future.result()
 
-    def check_for_updates(self) -> None:
-        """Apply camera config updates and mirror autotracking state to ptz metrics.
-
-        The camera processes read autotracker_enabled rather than the config, so it
-        has to follow every path that can change autotracking, not just the mqtt
-        toggle that writes it directly.
-        """
-        updates = self.config_subscriber.check_for_updates()
-
-        for cameras in updates.values():
-            for camera in cameras:
-                camera_config = self.config.cameras.get(camera)
-                metrics = self.ptz_metrics.get(camera)
-
-                # a camera added at runtime gets its metrics from the maintainer on
-                # another thread, which seeds them from this same config value
-                if camera_config is None or metrics is None:
-                    continue
-
-                metrics.autotracker_enabled.value = (
-                    camera_config.onvif.autotracking.enabled
-                )
-
     async def _autotracker_setup(self, camera_config: CameraConfig, camera: str):
         logger.debug(f"{camera}: Autotracker init")
 
@@ -1405,7 +1365,7 @@ class PtzAutoTracker:
         camera_config = self.config.cameras[camera]
 
         if camera_config.onvif.autotracking.enabled:
-            if not self.autotracker_init.get(camera):
+            if not self.autotracker_init[camera]:
                 future = asyncio.run_coroutine_threadsafe(
                     self._autotracker_setup(camera_config, camera), self.onvif.loop
                 )
@@ -1523,11 +1483,9 @@ class PtzAutoTracker:
                 }
 
     async def camera_maintenance(self, camera):
-        # bail and don't check anything if we're not set up yet, calibrating, or
-        # tracking an object. a camera enabled at runtime has no autotracker_init
-        # entry until autotrack_object sets it up
+        # bail and don't check anything if we're calibrating or tracking an object
         if (
-            not self.autotracker_init.get(camera)
+            not self.autotracker_init[camera]
             or self.calibrating[camera]
             or self.tracked_object[camera] is not None
         ):

frigate/ptz/onvif.py

@@ -344,17 +344,16 @@ class OnvifController:
             autotracking_config.enabled_in_config and autotracking_config.enabled
         )
 
-        # these are local and cost nothing to build, and autotracking can be enabled
-        # after a camera is initialized, so always create them rather than baking the
-        # current config value into init state
-        status_request = ptz.create_type("GetStatus")
-        status_request.ProfileToken = profile.token
-        self.cams[camera_name]["status_request"] = status_request
+        # autotracking-only: status request and service capabilities
+        if autotracking_enabled:
+            status_request = ptz.create_type("GetStatus")
+            status_request.ProfileToken = profile.token
+            self.cams[camera_name]["status_request"] = status_request
 
-        service_capabilities_request = ptz.create_type("GetServiceCapabilities")
-        self.cams[camera_name]["service_capabilities_request"] = (
-            service_capabilities_request
-        )
+            service_capabilities_request = ptz.create_type("GetServiceCapabilities")
+            self.cams[camera_name]["service_capabilities_request"] = (
+                service_capabilities_request
+            )
 
         # setup relative move request when FOV relative movement is supported
         if (

frigate/test/http_api/test_http_camera.py

@@ -1,132 +0,0 @@
-"""Tests for the camera delete endpoint's runtime config handling."""
-
-import os
-import tempfile
-import unittest
-from unittest.mock import MagicMock, Mock, patch
-
-import ruamel.yaml
-
-from frigate.config import FrigateConfig
-from frigate.config.camera.updater import CameraConfigUpdatePublisher
-from frigate.models import Event, Recordings, ReviewSegment
-from frigate.test.http_api.base_http_test import AuthTestClient, BaseTestHttp
-
-
-class TestDeleteCameraRuntimeConfig(BaseTestHttp):
-    """Deleting a camera must keep the API and dispatcher on the same config."""
-
-    def setUp(self):
-        super().setUp(models=[Event, Recordings, ReviewSegment])
-        self.minimal_config = {
-            "mqtt": {"host": "mqtt"},
-            "cameras": {
-                "front_door": {
-                    "ffmpeg": {
-                        "inputs": [
-                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
-                        ]
-                    },
-                    "detect": {"height": 1080, "width": 1920, "fps": 5},
-                },
-                "back_yard": {
-                    "ffmpeg": {
-                        "inputs": [
-                            {"path": "rtsp://10.0.0.2:554/video", "roles": ["detect"]}
-                        ]
-                    },
-                    "detect": {"height": 720, "width": 1280, "fps": 10},
-                },
-            },
-        }
-
-    def _write_config_file(self):
-        yaml = ruamel.yaml.YAML()
-        f = tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False)
-        yaml.dump(self.minimal_config, f)
-        f.close()
-        return f.name
-
-    def _create_app_with_dispatcher(self, dispatcher):
-        from fastapi import Request
-
-        from frigate.api.auth import get_allowed_cameras_for_filter, get_current_user
-        from frigate.api.fastapi_app import create_fastapi_app
-
-        mock_publisher = Mock(spec=CameraConfigUpdatePublisher)
-        mock_publisher.publisher = MagicMock()
-
-        app = create_fastapi_app(
-            FrigateConfig(**self.minimal_config),
-            self.db,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            mock_publisher,
-            None,
-            dispatcher=dispatcher,
-            enforce_default_admin=False,
-        )
-
-        async def mock_get_current_user(request: Request):
-            return {
-                "username": request.headers.get("remote-user"),
-                "role": request.headers.get("remote-role"),
-            }
-
-        async def mock_get_allowed_cameras_for_filter(request: Request):
-            return list(self.minimal_config.get("cameras", {}).keys())
-
-        app.dependency_overrides[get_current_user] = mock_get_current_user
-        app.dependency_overrides[get_allowed_cameras_for_filter] = (
-            mock_get_allowed_cameras_for_filter
-        )
-
-        return app, mock_publisher
-
-    @patch("frigate.api.camera.requests.delete")
-    @patch("frigate.api.camera.cleanup_camera_files")
-    @patch("frigate.api.camera.cleanup_camera_db")
-    @patch("frigate.api.camera.find_config_file")
-    def test_delete_syncs_dispatcher_and_prunes_runtime_state(
-        self, mock_find_config, mock_cleanup_db, mock_cleanup_files, mock_go2rtc_delete
-    ):
-        """Deleting a camera swaps every config reference and prunes its state."""
-        config_path = self._write_config_file()
-        mock_find_config.return_value = config_path
-        mock_cleanup_db.return_value = ({}, [])
-
-        dispatcher = MagicMock()
-        dispatcher.comms = []
-
-        try:
-            app, _ = self._create_app_with_dispatcher(dispatcher)
-
-            with AuthTestClient(app) as client:
-                resp = client.delete("/cameras/front_door")
-
-                self.assertEqual(resp.status_code, 200)
-                self.assertTrue(resp.json()["success"])
-
-                # the dispatcher must be moved onto the same new object the API
-                # now serves, and that object must no longer contain the camera
-                self.assertIs(dispatcher.config, app.frigate_config)
-                self.assertNotIn("front_door", dispatcher.config.cameras)
-                self.assertIn("back_yard", dispatcher.config.cameras)
-
-                # surviving cameras' overrides are re-layered onto the new object
-                dispatcher.reapply_runtime_state_to_config.assert_called_once_with()
-
-                # the deleted camera's persisted overrides are pruned
-                dispatcher.clear_runtime_state_for_camera.assert_called_once_with(
-                    "front_door"
-                )
-        finally:
-            os.unlink(config_path)
-
-
-if __name__ == "__main__":
-    unittest.main()

frigate/test/http_api/test_http_config_set.py

@@ -91,123 +91,6 @@ class TestConfigSetWildcardPropagation(BaseTestHttp):
 
         return app, mock_publisher
 
-    def _create_app_with_dispatcher(self, dispatcher):
-        """Create app with a mocked config publisher and a real-ish dispatcher."""
-        from fastapi import Request
-
-        from frigate.api.auth import get_allowed_cameras_for_filter, get_current_user
-        from frigate.api.fastapi_app import create_fastapi_app
-
-        mock_publisher = Mock(spec=CameraConfigUpdatePublisher)
-        mock_publisher.publisher = MagicMock()
-
-        app = create_fastapi_app(
-            FrigateConfig(**self.minimal_config),
-            self.db,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            mock_publisher,
-            None,
-            dispatcher=dispatcher,
-            enforce_default_admin=False,
-        )
-
-        async def mock_get_current_user(request: Request):
-            username = request.headers.get("remote-user")
-            role = request.headers.get("remote-role")
-            return {"username": username, "role": role}
-
-        async def mock_get_allowed_cameras_for_filter(request: Request):
-            return list(self.minimal_config.get("cameras", {}).keys())
-
-        app.dependency_overrides[get_current_user] = mock_get_current_user
-        app.dependency_overrides[get_allowed_cameras_for_filter] = (
-            mock_get_allowed_cameras_for_filter
-        )
-
-        return app, mock_publisher
-
-    @patch("frigate.api.app.find_config_file")
-    def test_runtime_disabled_camera_survives_unrelated_save(self, mock_find_config):
-        """A camera turned off at runtime stays off when another camera is saved."""
-        config_path = self._write_config_file()
-        mock_find_config.return_value = config_path
-
-        dispatcher = MagicMock()
-        dispatcher.comms = []
-
-        # front_door was turned off via the UI: the override is on disk, and
-        # yaml still says enabled: true. Stand in for the real replay, which
-        # reads dispatcher.config - the object the endpoint just swapped in.
-        def fake_reapply():
-            dispatcher.config.cameras["front_door"].enabled = False
-
-        dispatcher.reapply_runtime_state_to_config.side_effect = fake_reapply
-
-        try:
-            app, _ = self._create_app_with_dispatcher(dispatcher)
-
-            with AuthTestClient(app) as client:
-                resp = client.put(
-                    "/config/set",
-                    json={
-                        "config_data": {
-                            "cameras": {"back_yard": {"detect": {"fps": 7}}}
-                        },
-                        "requires_restart": 0,
-                    },
-                )
-
-                self.assertEqual(resp.status_code, 200)
-                self.assertTrue(resp.json()["success"])
-
-                # the swap must be repaired: the new config object the API and
-                # dispatcher now share has to still show front_door as off
-                dispatcher.reapply_runtime_state_to_config.assert_called_once_with()
-                self.assertFalse(app.frigate_config.cameras["front_door"].enabled)
-                self.assertIs(dispatcher.config, app.frigate_config)
-
-                # yaml-wins ordering: the surgical clear for rewritten keys
-                # must run before the replay, or a save that rewrote a toggle
-                # would have its old override resurrected
-                call_names = [name for name, _, _ in dispatcher.mock_calls]
-                self.assertLess(
-                    call_names.index("clear_runtime_state_for_yaml_keys"),
-                    call_names.index("reapply_runtime_state_to_config"),
-                )
-        finally:
-            os.unlink(config_path)
-
-    @patch("frigate.api.app.find_config_file")
-    def test_no_reapply_when_config_is_not_swapped(self, mock_find_config):
-        """A restart-required save with no update topic never swaps, so no replay."""
-        config_path = self._write_config_file()
-        mock_find_config.return_value = config_path
-
-        dispatcher = MagicMock()
-        dispatcher.comms = []
-
-        try:
-            app, _ = self._create_app_with_dispatcher(dispatcher)
-
-            with AuthTestClient(app) as client:
-                resp = client.put(
-                    "/config/set",
-                    json={
-                        "config_data": {"mqtt": {"host": "other"}},
-                        "requires_restart": 1,
-                    },
-                )
-
-                self.assertEqual(resp.status_code, 200)
-                dispatcher.reapply_runtime_state_to_config.assert_not_called()
-        finally:
-            os.unlink(config_path)
-
     def _write_config_file(self):
         """Write the minimal config to a temp YAML file and return the path."""
         yaml = ruamel.yaml.YAML()

frigate/test/test_birdseye.py

@@ -1,13 +1,64 @@
-"""Test camera user and password cleanup."""
+"""Tests for Birdseye canvas sizing and layout behavior."""
 
-import multiprocessing as mp
 import unittest
+from multiprocessing import Event
 
 from frigate.config import FrigateConfig
 from frigate.output.birdseye import BirdsEyeFrameManager, get_canvas_shape
 
 
 class TestBirdseye(unittest.TestCase):
+    def _build_manager(
+        self, camera_dimensions: dict[str, tuple[int, int]]
+    ) -> BirdsEyeFrameManager:
+        config = {
+            "mqtt": {"host": "mqtt"},
+            "birdseye": {"width": 1280, "height": 720},
+            "cameras": {},
+        }
+
+        for order, (camera, dimensions) in enumerate(
+            camera_dimensions.items(), start=1
+        ):
+            config["cameras"][camera] = {
+                "ffmpeg": {
+                    "inputs": [
+                        {
+                            "path": f"rtsp://10.0.0.1:554/{camera}",
+                            "roles": ["detect"],
+                        }
+                    ]
+                },
+                "detect": {
+                    "width": dimensions[0],
+                    "height": dimensions[1],
+                    "fps": 5,
+                },
+                "birdseye": {"order": order},
+            }
+
+        return BirdsEyeFrameManager(FrigateConfig(**config), Event())
+
+    def _assert_no_overlaps(
+        self, layout: list[list[tuple[str, tuple[int, int, int, int]]]]
+    ):
+        rectangles = [position for row in layout for _, position in row]
+
+        for index, rect in enumerate(rectangles):
+            x1, y1, width1, height1 = rect
+            for other in rectangles[index + 1 :]:
+                x2, y2, width2, height2 = other
+                overlap = (
+                    x1 < x2 + width2
+                    and x2 < x1 + width1
+                    and y1 < y2 + height2
+                    and y2 < y1 + height1
+                )
+                self.assertFalse(
+                    overlap,
+                    msg=f"Overlapping rectangles found: {rect} and {other}",
+                )
+
     def test_16x9(self):
         """Test 16x9 aspect ratio works as expected for birdseye."""
         width = 1280
@@ -48,69 +99,103 @@ class TestBirdseye(unittest.TestCase):
         assert canvas_width == width  # width will be the same
         assert canvas_height != height
 
+    def test_portrait_camera_does_not_overlap_next_row(self):
+        """Portrait cameras should reserve their real horizontal position on the next row."""
+        manager = self._build_manager(
+            {
+                "cam_a": (1280, 720),
+                "cam_p": (360, 640),
+                "cam_b": (1280, 720),
+                "cam_c": (640, 480),
+            }
+        )
 
-class TestBirdseyeCameraOrder(unittest.TestCase):
-    """Test that birdseye reacts to camera order changes without a restart."""
+        layout = manager.calculate_layout(["cam_a", "cam_p", "cam_b", "cam_c"], 3)
 
-    def setUp(self):
-        config = {
-            "mqtt": {"enabled": False},
-            "birdseye": {"enabled": True, "mode": "continuous"},
-            "cameras": {
-                camera: {
-                    "ffmpeg": {
-                        "inputs": [
-                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
-                        ]
-                    },
-                    "detect": {"height": 1080, "width": 1920, "fps": 5},
-                }
-                for camera in ("back", "front", "side")
-            },
-        }
-        self.config = FrigateConfig(**config)
-        self.manager = BirdsEyeFrameManager(self.config, mp.Event())
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
 
-        # mark every camera as continuously active with no frame to draw, which
-        # exercises the layout without needing real yuv frames
-        for camera_data in self.manager.cameras.values():
-            camera_data["current_frame"] = None
-            camera_data["current_frame_time"] = 1.0
-            camera_data["last_active_frame"] = 1.0
+        cam_c = [
+            position for row in layout for camera, position in row if camera == "cam_c"
+        ][0]
+        self.assertEqual(cam_c[0], 0)
 
-    def layout_order(self) -> list[str]:
-        """Return the cameras in the order the current layout renders them."""
-        return [position[0] for row in self.manager.camera_layout for position in row]
+    def test_portrait_reservation_only_applies_to_next_row(self):
+        """Portrait reservations should not push later rows after the span ends."""
+        manager = self._build_manager(
+            {
+                "cam_a": (1280, 720),
+                "cam_p": (360, 640),
+                "cam_b": (1280, 720),
+                "cam_c": (1280, 720),
+                "cam_d": (1280, 720),
+                "cam_e": (1280, 720),
+            }
+        )
 
-    def test_layout_uses_configured_order(self):
-        """Test the layout is sorted by order, then by name when tied."""
-        self.config.cameras["side"].birdseye.order = 0
-        self.config.cameras["back"].birdseye.order = 10
-        self.config.cameras["front"].birdseye.order = 20
+        layout = manager.calculate_layout(
+            ["cam_a", "cam_p", "cam_b", "cam_c", "cam_d", "cam_e"],
+            3,
+        )
 
-        self.manager.update_frame()
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
 
-        assert self.layout_order() == ["side", "back", "front"]
+        cam_e = [
+            position for row in layout for camera, position in row if camera == "cam_e"
+        ][0]
+        self.assertEqual(cam_e[0], 0)
 
-    def test_order_change_rebuilds_layout(self):
-        """Test a reorder relayouts even though the active cameras are unchanged."""
-        self.manager.update_frame()
-        assert self.layout_order() == ["back", "front", "side"]
+    def test_multiple_portraits_reserve_distinct_ranges(self):
+        """Multiple portrait cameras in one row should reserve separate spans below them."""
+        manager = self._build_manager(
+            {
+                "cam_a": (640, 480),
+                "cam_p1": (360, 640),
+                "cam_p2": (360, 640),
+                "cam_b": (640, 480),
+                "cam_c": (1280, 720),
+                "cam_d": (640, 480),
+            }
+        )
 
-        # a stable active set means only an order change can reset the layout,
-        # which is what a settings reorder publishes to this process
-        self.config.cameras["side"].birdseye.order = -10
+        layout = manager.calculate_layout(
+            ["cam_a", "cam_p1", "cam_p2", "cam_b", "cam_c", "cam_d"],
+            4,
+        )
 
-        _, layout_changed = self.manager.update_frame()
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
 
-        assert layout_changed
-        assert self.layout_order() == ["side", "back", "front"]
+    def test_two_landscapes_then_portrait_then_two_landscapes(self):
+        """A portrait after two landscapes should reserve only its own tail span."""
+        manager = self._build_manager(
+            {
+                "cam_a": (1280, 720),
+                "cam_b": (1280, 720),
+                "cam_p": (360, 640),
+                "cam_c": (1280, 720),
+                "cam_d": (1280, 720),
+            }
+        )
 
-    def test_unchanged_order_keeps_layout(self):
-        """Test a repeat update with no order change doesn't reset the layout."""
-        self.manager.update_frame()
+        layout = manager.calculate_layout(
+            ["cam_a", "cam_b", "cam_p", "cam_c", "cam_d"],
+            3,
+        )
 
-        _, layout_changed = self.manager.update_frame()
+        self.assertIsNotNone(layout)
+        assert layout is not None
+        self._assert_no_overlaps(layout)
 
-        assert not layout_changed
-        assert self.layout_order() == ["back", "front", "side"]
+        cam_c = [
+            position for row in layout for camera, position in row if camera == "cam_c"
+        ][0]
+        cam_d = [
+            position for row in layout for camera, position in row if camera == "cam_d"
+        ][0]
+        self.assertEqual(cam_c[0], 0)
+        self.assertEqual(cam_d[0], cam_c[0] + cam_c[2])

frigate/test/test_camera_pw.py

@@ -8,7 +8,9 @@ from frigate.util.builtin import clean_camera_user_pass, escape_special_characte
 class TestUserPassCleanup(unittest.TestCase):
     def setUp(self) -> None:
         self.rtsp_with_pass = "rtsp://user:password@192.168.0.2:554/live"
-        self.rtsp_with_special_pass = "rtsp://user:password`~!@#$%^&*()-_;',.<>:\"\\{\\}\\[\\]@@192.168.0.2:554/live"
+        self.rtsp_with_special_pass = (
+            "rtsp://user:password`~!@#$%^&*()-_;',.<>:\"\{\}\[\]@@192.168.0.2:554/live"
+        )
         self.rtsp_no_pass = "rtsp://192.168.0.3:554/live"
 
     def test_cleanup(self):

frigate/test/test_config_util.py

@@ -1,55 +0,0 @@
-"""Tests for the shared runtime config swap helper."""
-
-import unittest
-from unittest.mock import MagicMock
-
-from frigate.api.config_util import swap_runtime_config
-
-
-class TestSwapRuntimeConfig(unittest.TestCase):
-    """swap_runtime_config rebinds every collaborator to the new config."""
-
-    def _make_app(self) -> MagicMock:
-        app = MagicMock()
-        app.dispatcher.comms = [MagicMock(), MagicMock()]
-        return app
-
-    def test_rebinds_all_references(self) -> None:
-        app = self._make_app()
-        config = MagicMock(name="new_config")
-
-        swap_runtime_config(app, config)
-
-        self.assertIs(app.frigate_config, config)
-        app.genai_manager.update_config.assert_called_once_with(config)
-        app.profile_manager.update_config.assert_called_once_with(config)
-        self.assertIs(app.stats_emitter.config, config)
-        self.assertIs(app.dispatcher.config, config)
-        for comm in app.dispatcher.comms:
-            self.assertIs(comm.config, config)
-
-    def test_reapplies_runtime_state_after_swap(self) -> None:
-        app = self._make_app()
-        config = MagicMock(name="new_config")
-
-        swap_runtime_config(app, config)
-
-        # the swap rebuilds cameras from yaml, so overrides must be re-layered
-        app.dispatcher.reapply_runtime_state_to_config.assert_called_once_with()
-
-    def test_tolerates_missing_optional_collaborators(self) -> None:
-        app = MagicMock()
-        app.profile_manager = None
-        app.stats_emitter = None
-        app.dispatcher = None
-        config = MagicMock(name="new_config")
-
-        # must not raise when the optional collaborators are absent
-        swap_runtime_config(app, config)
-
-        self.assertIs(app.frigate_config, config)
-        app.genai_manager.update_config.assert_called_once_with(config)
-
-
-if __name__ == "__main__":
-    unittest.main()

frigate/test/test_dispatcher_runtime_state.py

@@ -126,40 +126,6 @@ class TestRestoreRuntimeState(unittest.TestCase):
         self.dispatcher.restore_runtime_state()
         self.handler_mocks["detect"].assert_called_once_with("front_door", "ON")
 
-    def test_apply_runtime_state_replays_through_handlers(self) -> None:
-        """The extracted method replays every stored entry."""
-        with patch.object(
-            self.dispatcher._runtime_state,
-            "load",
-            return_value={"front_door": {"enabled": False, "detect": True}},
-        ):
-            self.dispatcher.apply_runtime_state()
-
-        self.handler_mocks["enabled"].assert_called_once_with("front_door", "OFF")
-        self.handler_mocks["detect"].assert_called_once_with("front_door", "ON")
-
-    def test_apply_runtime_state_returns_applied_entries(self) -> None:
-        """Callers get back what was replayed, for logging and assertions."""
-        with patch.object(
-            self.dispatcher._runtime_state,
-            "load",
-            return_value={"front_door": {"enabled": False}, "nope": {"enabled": True}},
-        ):
-            applied = self.dispatcher.apply_runtime_state()
-
-        self.assertEqual(applied, {"front_door": {"enabled": False}})
-
-    def test_restore_runtime_state_still_replays(self) -> None:
-        """The startup entry point keeps working after the extraction."""
-        with patch.object(
-            self.dispatcher._runtime_state,
-            "load",
-            return_value={"back_yard": {"snapshots": False}},
-        ):
-            self.dispatcher.restore_runtime_state()
-
-        self.handler_mocks["snapshots"].assert_called_once_with("back_yard", "OFF")
-
 
 class TestHandlersPersistViaSet(unittest.TestCase):
     """Verify each in-scope handler writes to the runtime state on success."""
@@ -246,122 +212,6 @@ class TestClearPassthrough(unittest.TestCase):
         dispatcher.clear_runtime_state()
         dispatcher._runtime_state.clear_all.assert_called_once_with()
 
-    def test_clear_runtime_state_for_camera_passthrough(self) -> None:
-        dispatcher = _build_dispatcher({})
-        dispatcher._runtime_state = MagicMock(spec=RuntimeStatePersistence)
-        dispatcher.clear_runtime_state_for_camera("front_door")
-        dispatcher._runtime_state.clear_camera.assert_called_once_with("front_door")
-
-
-class TestReapplyRuntimeStateToConfig(unittest.TestCase):
-    """The silent re-apply corrects the config object with no side effects."""
-
-    def _dispatcher_with(
-        self, cameras: dict[str, MagicMock], state: dict
-    ) -> Dispatcher:
-        dispatcher = _build_dispatcher(cameras)
-        dispatcher._runtime_state = MagicMock(spec=RuntimeStatePersistence)
-        dispatcher._runtime_state.load.return_value = state
-        dispatcher.publish = MagicMock()
-        return dispatcher
-
-    def test_mutates_every_tracked_field(self) -> None:
-        cameras = {"front_door": _make_camera_mock()}
-        dispatcher = self._dispatcher_with(
-            cameras,
-            {
-                "front_door": {
-                    "enabled": False,
-                    "detect": False,
-                    "snapshots": False,
-                    "recordings": False,
-                    "audio": False,
-                }
-            },
-        )
-
-        dispatcher.reapply_runtime_state_to_config()
-
-        cam = cameras["front_door"]
-        self.assertFalse(cam.enabled)
-        self.assertFalse(cam.detect.enabled)
-        self.assertFalse(cam.snapshots.enabled)
-        self.assertFalse(cam.record.enabled)
-        self.assertFalse(cam.audio.enabled)
-
-    def test_makes_no_zmq_mqtt_or_disk_writes(self) -> None:
-        dispatcher = self._dispatcher_with(
-            {"front_door": _make_camera_mock()},
-            {"front_door": {"enabled": False}},
-        )
-
-        dispatcher.reapply_runtime_state_to_config()
-
-        dispatcher.config_updater.publish_update.assert_not_called()
-        dispatcher._runtime_state.set.assert_not_called()
-        dispatcher.publish.assert_not_called()
-
-    def test_respects_enabled_in_config_gate(self) -> None:
-        # an ON override for a camera disabled in yaml must not enable it
-        cameras = {
-            "front_door": _make_camera_mock(enabled=False, enabled_in_config=False)
-        }
-        dispatcher = self._dispatcher_with(cameras, {"front_door": {"enabled": True}})
-
-        dispatcher.reapply_runtime_state_to_config()
-
-        self.assertFalse(cameras["front_door"].enabled)
-
-    def test_respects_recordings_and_audio_gates(self) -> None:
-        # ON overrides for recordings/audio not enabled in yaml must be ignored
-        cameras = {
-            "front_door": _make_camera_mock(
-                record_enabled=False,
-                record_enabled_in_config=False,
-                audio_enabled=False,
-                audio_enabled_in_config=False,
-            )
-        }
-        dispatcher = self._dispatcher_with(
-            cameras, {"front_door": {"recordings": True, "audio": True}}
-        )
-
-        dispatcher.reapply_runtime_state_to_config()
-
-        self.assertFalse(cameras["front_door"].record.enabled)
-        self.assertFalse(cameras["front_door"].audio.enabled)
-
-    def test_applies_on_override_when_gate_passes(self) -> None:
-        # a camera off in yaml but enabled_in_config keeps its runtime-on state
-        cameras = {
-            "front_door": _make_camera_mock(enabled=False, enabled_in_config=True)
-        }
-        dispatcher = self._dispatcher_with(cameras, {"front_door": {"enabled": True}})
-
-        dispatcher.reapply_runtime_state_to_config()
-
-        self.assertTrue(cameras["front_door"].enabled)
-
-    def test_detect_on_couples_motion(self) -> None:
-        cam = _make_camera_mock(detect_enabled=False)
-        cam.motion.enabled = False
-        dispatcher = self._dispatcher_with(
-            {"front_door": cam}, {"front_door": {"detect": True}}
-        )
-
-        dispatcher.reapply_runtime_state_to_config()
-
-        self.assertTrue(cam.detect.enabled)
-        self.assertTrue(cam.motion.enabled)
-
-    def test_skips_camera_not_in_config(self) -> None:
-        dispatcher = self._dispatcher_with(
-            {"front_door": _make_camera_mock()}, {"ghost": {"enabled": False}}
-        )
-
-        # a stale entry for a deleted camera must be ignored, not raise
-        dispatcher.reapply_runtime_state_to_config()
-
 
 if __name__ == "__main__":
     unittest.main()

frigate/test/test_gpu_stats.py

@@ -21,12 +21,8 @@ class TestGpuStats(unittest.TestCase):
     @patch("frigate.util.services.time.sleep")
     @patch("frigate.util.services.time.monotonic")
     @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    def test_intel_gpu_stats_fdinfo(
-        self, drm_devices, read_fdinfo, monotonic, sleep, get_names
-    ):
+    def test_intel_gpu_stats_fdinfo(self, read_fdinfo, monotonic, sleep, get_names):
         # 1 second of wall clock between snapshots
-        drm_devices.return_value = {"0000:00:02.0": "i915"}
         monotonic.side_effect = [0.0, 1.0]
         get_names.return_value = {"0000:00:02.0": "Intel Graphics"}
 
@@ -100,15 +96,13 @@ class TestGpuStats(unittest.TestCase):
     @patch("frigate.util.services.time.sleep")
     @patch("frigate.util.services.time.monotonic")
     @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
     def test_intel_gpu_stats_xe_capacity(
-        self, drm_devices, read_fdinfo, monotonic, sleep, get_names
+        self, read_fdinfo, monotonic, sleep, get_names
     ):
         # Xe engines report cumulative cycles paired with total cycles, plus a
         # per-class capacity. drm-cycles-* is summed across every instance of a
         # class, so on Battlemage (capacity 2 for vcs/vecs) busy/total must be
         # divided by capacity to land in 0-100%.
-        drm_devices.return_value = {"0000:03:00.0": "xe"}
         monotonic.side_effect = [0.0, 1.0]
         get_names.return_value = {"0000:03:00.0": "Intel Arc"}
 
@@ -156,145 +150,7 @@ class TestGpuStats(unittest.TestCase):
             },
         }
 
-    @patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
-    @patch("frigate.util.services.time.sleep")
     @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    def test_intel_gpu_stats_no_clients_reports_idle(
-        self, drm_devices, read_fdinfo, sleep, get_names
-    ):
-        # The device exists but nothing holds it open, e.g. while camera
-        # processes are restarting. This is an idle state, not an error:
-        # returning None here would latch the hwaccel error cooldown and
-        # blank GPU stats for an hour over a momentary gap.
-        drm_devices.return_value = {"0000:00:02.0": "i915"}
+    def test_intel_gpu_stats_no_clients(self, read_fdinfo):
         read_fdinfo.return_value = {}
-        get_names.return_value = {"0000:00:02.0": "Intel Graphics"}
-
-        assert get_intel_gpu_stats(None) == {
-            "0000:00:02.0": {
-                "name": "Intel Graphics",
-                "vendor": "intel",
-                "gpu": "0.0%",
-                "mem": "-%",
-                "compute": "0.0%",
-                "dec": "0.0%",
-            },
-        }
-        # Idle short-circuits before spending the sample window
-        sleep.assert_not_called()
-        read_fdinfo.assert_called_once()
-
-    @patch("frigate.util.services.time.sleep")
-    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    def test_intel_gpu_stats_clients_without_engine_counters(
-        self, drm_devices, read_fdinfo, sleep
-    ):
-        # i915 publishes drm-driver/drm-pdev/drm-client-id but no drm-engine-*
-        # lines while GuC submission is active on kernels older than 6.5, so
-        # clients are found with nothing to sample. Reporting idle here would
-        # be a lie, and sampling a second time cannot help.
-        drm_devices.return_value = {"0000:00:02.0": "i915"}
-        read_fdinfo.return_value = {
-            ("0000:00:02.0", "48", "1109"): {
-                "driver": "i915",
-                "pid": "1109",
-                "engines": {},
-            },
-            ("0000:00:02.0", "51", "1258"): {
-                "driver": "i915",
-                "pid": "1258",
-                "engines": {},
-            },
-        }
-
         assert get_intel_gpu_stats(None) is None
-        sleep.assert_not_called()
-        read_fdinfo.assert_called_once()
-
-    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    def test_intel_gpu_stats_no_intel_device(self, drm_devices, read_fdinfo):
-        # Only a non-Intel GPU is visible in sysfs; /proc is never scanned
-        drm_devices.return_value = {"0000:01:00.0": "nvidia"}
-
-        assert get_intel_gpu_stats(None) is None
-        read_fdinfo.assert_not_called()
-
-    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    @patch("frigate.util.services._resolve_intel_gpu_pdev")
-    def test_intel_gpu_stats_unresolvable_device_hint(
-        self, resolve_pdev, drm_devices, read_fdinfo
-    ):
-        # A configured intel_gpu_device that cannot be resolved is a config
-        # error, not a reason to silently fall back to reporting all GPUs
-        resolve_pdev.return_value = None
-
-        assert get_intel_gpu_stats("/dev/dri/renderD999") is None
-        drm_devices.assert_not_called()
-        read_fdinfo.assert_not_called()
-
-    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    @patch("frigate.util.services._resolve_intel_gpu_pdev")
-    def test_intel_gpu_stats_hint_resolves_to_non_intel_gpu(
-        self, resolve_pdev, drm_devices, read_fdinfo
-    ):
-        # card numbering can reorder across reboots on multi-GPU hosts, so a
-        # configured hint may point at another vendor's card; call it out
-        # instead of reporting nothing
-        resolve_pdev.return_value = "0000:01:00.0"
-        drm_devices.return_value = {
-            "0000:00:02.0": "i915",
-            "0000:01:00.0": "nvidia",
-        }
-
-        assert get_intel_gpu_stats("/dev/dri/card0") is None
-        read_fdinfo.assert_not_called()
-
-    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    def test_intel_gpu_stats_unreadable_proc(self, drm_devices, read_fdinfo):
-        # A scan failure (None) is a different condition than a scan that
-        # finds no clients ({}) and must not report idle
-        drm_devices.return_value = {"0000:00:02.0": "i915"}
-        read_fdinfo.return_value = None
-
-        assert get_intel_gpu_stats(None) is None
-
-    @patch("frigate.stats.intel_gpu_info.intel_gpu_name_resolver.get_names")
-    @patch("frigate.util.services.time.sleep")
-    @patch("frigate.util.services.time.monotonic")
-    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    @patch("frigate.util.services._enumerate_drm_devices")
-    def test_intel_gpu_stats_clients_lost_between_samples(
-        self, drm_devices, read_fdinfo, monotonic, sleep, get_names
-    ):
-        # Clients disappearing during the sample window is transient process
-        # churn, so report idle rather than latching an error
-        drm_devices.return_value = {"0000:00:02.0": "i915"}
-        monotonic.side_effect = [0.0, 1.0]
-        get_names.return_value = {"0000:00:02.0": "Intel Graphics"}
-        read_fdinfo.side_effect = [
-            {
-                ("0000:00:02.0", "1", "100"): {
-                    "driver": "i915",
-                    "pid": "100",
-                    "engines": {"video": (5_000_000_000, 0, 1)},
-                },
-            },
-            {},
-        ]
-
-        assert get_intel_gpu_stats(None) == {
-            "0000:00:02.0": {
-                "name": "Intel Graphics",
-                "vendor": "intel",
-                "gpu": "0.0%",
-                "mem": "-%",
-                "compute": "0.0%",
-                "dec": "0.0%",
-            },
-        }

frigate/test/test_profiles.py

@@ -786,15 +786,8 @@ class TestProfileManager(unittest.TestCase):
         dispatcher.clear_runtime_state.assert_not_called()
 
     @patch.object(ProfileManager, "_persist_active_profile")
-    def test_update_config_preserves_runtime_state_with_active_profile(
-        self, mock_persist
-    ):
-        """A config/set save must not wipe overrides it never rewrote.
-
-        The save path clears matching entries itself via
-        clear_runtime_state_for_yaml_keys; a broad wipe here would drop
-        overrides for unrelated cameras.
-        """
+    def test_update_config_clears_when_active_profile_reapplies(self, mock_persist):
+        """After /api/config/set, an active-profile re-application drops state."""
         dispatcher = MagicMock()
         manager = ProfileManager(self.config, self.mock_updater, dispatcher)
         manager.activate_profile("armed")
@@ -802,20 +795,7 @@ class TestProfileManager(unittest.TestCase):
 
         new_config = FrigateConfig(**self.config_data)
         manager.update_config(new_config)
-        dispatcher.clear_runtime_state.assert_not_called()
-
-    @patch.object(ProfileManager, "_persist_active_profile")
-    def test_update_config_still_reapplies_active_profile(self, mock_persist):
-        """Dropping the wipe must not disturb profile re-application."""
-        dispatcher = MagicMock()
-        manager = ProfileManager(self.config, self.mock_updater, dispatcher)
-        manager.activate_profile("armed")
-
-        new_config = FrigateConfig(**self.config_data)
-        manager.update_config(new_config)
-
-        self.assertEqual(manager.config, new_config)
-        self.assertEqual(new_config.active_profile, "armed")
+        dispatcher.clear_runtime_state.assert_called_once_with()
 
     @patch.object(ProfileManager, "_persist_active_profile")
     def test_update_config_does_not_clear_when_no_active_profile(self, mock_persist):

frigate/test/test_ptz_autotrack.py

@@ -1,130 +0,0 @@
-"""Tests for autotracker state that must survive runtime config changes.
-
-Regression coverage for a family of bugs where per-camera autotracker state was
-built once at startup and never revisited. A camera that is added or enabled
-after startup, or has autotracking enabled from the UI, would either raise a
-KeyError on the autotracker thread or silently keep the wrong state:
-
-- autotracker_init only got an entry for cameras enabled when PtzAutoTracker was
-  constructed, so runtime-enabled cameras raised KeyError on lookup.
-- ptz_metrics autotracker_enabled is what the camera processes read, but nothing
-  updated it when autotracking was enabled through a config save, so it stayed
-  False and the tracker never built a motion estimator.
-"""
-
-import unittest
-from unittest.mock import MagicMock
-
-from frigate.camera import PTZMetrics
-from frigate.config import FrigateConfig
-from frigate.ptz.autotrack import PtzAutoTracker
-
-CAMERA = "ptz_cam"
-
-
-def _config(autotracking_enabled: bool) -> FrigateConfig:
-    return FrigateConfig(
-        **{
-            "mqtt": {"enabled": False},
-            "cameras": {
-                CAMERA: {
-                    "ffmpeg": {
-                        "inputs": [
-                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
-                        ]
-                    },
-                    "detect": {"width": 1920, "height": 1080},
-                    "zones": {"zone": {"coordinates": "0,0,1,0,1,1,0,1"}},
-                    "onvif": {
-                        "host": "10.0.0.1",
-                        "autotracking": {
-                            "enabled": autotracking_enabled,
-                            "required_zones": ["zone"],
-                        },
-                    },
-                }
-            },
-        }
-    )
-
-
-def _make_tracker(autotracking_enabled: bool = True) -> PtzAutoTracker:
-    """Build a PtzAutoTracker without invoking __init__, which would try to set up
-    onvif over the network. Only the config/metrics state is relevant here."""
-    tracker = PtzAutoTracker.__new__(PtzAutoTracker)
-    tracker.config = _config(autotracking_enabled)
-    tracker.ptz_metrics = {CAMERA: PTZMetrics(autotracker_enabled=False)}
-    tracker.onvif = MagicMock()
-    tracker.config_subscriber = MagicMock()
-    tracker.autotracker_init = {}
-    tracker.calibrating = {}
-    tracker.tracked_object = {}
-    return tracker
-
-
-class TestAutotrackerInitGuards(unittest.IsolatedAsyncioTestCase):
-    async def test_camera_maintenance_returns_early_when_not_initialized(self) -> None:
-        # a camera enabled at runtime has no autotracker_init entry, which used to
-        # raise KeyError and kill the autotracker thread for every camera
-        tracker = _make_tracker()
-        self.assertNotIn(CAMERA, tracker.autotracker_init)
-
-        await tracker.camera_maintenance(CAMERA)
-
-        tracker.onvif.get_camera_status.assert_not_called()
-
-    async def test_camera_maintenance_returns_early_when_init_incomplete(self) -> None:
-        # autotracker_init is seeded False for enabled cameras before setup runs
-        tracker = _make_tracker()
-        tracker.autotracker_init[CAMERA] = False
-
-        await tracker.camera_maintenance(CAMERA)
-
-        tracker.onvif.get_camera_status.assert_not_called()
-
-
-class TestAutotrackerMetricSync(unittest.TestCase):
-    def test_metric_follows_config_when_enabled_by_update(self) -> None:
-        # autotracking enabled via a config save: the metric was seeded False when
-        # the camera was added and nothing else updates it
-        tracker = _make_tracker(autotracking_enabled=True)
-        metrics = tracker.ptz_metrics[CAMERA]
-        self.assertFalse(metrics.autotracker_enabled.value)
-
-        tracker.config_subscriber.check_for_updates.return_value = {"onvif": [CAMERA]}
-        tracker.check_for_updates()
-
-        self.assertTrue(metrics.autotracker_enabled.value)
-
-    def test_metric_follows_config_when_disabled_by_update(self) -> None:
-        tracker = _make_tracker(autotracking_enabled=False)
-        metrics = tracker.ptz_metrics[CAMERA]
-        metrics.autotracker_enabled.value = True
-
-        tracker.config_subscriber.check_for_updates.return_value = {
-            "autotracking": [CAMERA]
-        }
-        tracker.check_for_updates()
-
-        self.assertFalse(metrics.autotracker_enabled.value)
-
-    def test_metric_sync_skips_camera_without_metrics(self) -> None:
-        # `add` reaches the maintainer and the autotracker on separate threads with
-        # no ordering guarantee, so the metrics may not exist yet
-        tracker = _make_tracker()
-        tracker.ptz_metrics = {}
-        tracker.config_subscriber.check_for_updates.return_value = {"add": [CAMERA]}
-
-        tracker.check_for_updates()
-
-    def test_metric_sync_skips_unknown_camera(self) -> None:
-        tracker = _make_tracker()
-        tracker.config_subscriber.check_for_updates.return_value = {
-            "add": ["not_in_config"]
-        }
-
-        tracker.check_for_updates()
-
-
-if __name__ == "__main__":
-    unittest.main()

frigate/test/test_ptz_onvif.py

@@ -1,147 +0,0 @@
-"""Tests for ONVIF init state that must not depend on the autotracking config.
-
-Regression coverage for a camera that is initialized while autotracking is off and
-has it enabled later, which is the normal wizard flow: set the camera up first,
-configure autotracking afterwards. The autotracking-only request objects used to
-be created only when autotracking was enabled at init time, so the camera was left
-with init=True but no status_request. get_camera_status skips its re-init branch
-when init is True, so it went straight to the missing key and raised KeyError on
-the tracking thread.
-
-The request objects are built from the locally parsed WSDL and cost no network, so
-they are always created and init=True now implies they exist.
-"""
-
-import unittest
-from unittest.mock import AsyncMock, MagicMock
-
-from frigate.config import FrigateConfig
-from frigate.ptz.onvif import OnvifController
-
-CAMERA = "ptz_cam"
-
-
-def _config(autotracking_enabled: bool) -> FrigateConfig:
-    return FrigateConfig(
-        **{
-            "mqtt": {"enabled": False},
-            "cameras": {
-                CAMERA: {
-                    "ffmpeg": {
-                        "inputs": [
-                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
-                        ]
-                    },
-                    "detect": {"width": 1920, "height": 1080},
-                    "zones": {"zone": {"coordinates": "0,0,1,0,1,1,0,1"}},
-                    "onvif": {
-                        "host": "10.0.0.1",
-                        "autotracking": {
-                            "enabled": autotracking_enabled,
-                            "required_zones": ["zone"],
-                        },
-                    },
-                }
-            },
-        }
-    )
-
-
-def _make_profile() -> MagicMock:
-    profile = MagicMock()
-    profile.token = "profile_1"
-    profile.Name = "MainStream"
-    profile.VideoEncoderConfiguration = MagicMock()
-    ptz_config = MagicMock()
-    ptz_config.token = "ptz_config_1"
-    ptz_config.DefaultContinuousPanTiltVelocitySpace = "space"
-    ptz_config.DefaultContinuousZoomVelocitySpace = "space"
-    profile.PTZConfiguration = ptz_config
-    return profile
-
-
-def _make_onvif_camera() -> MagicMock:
-    """A camera that supports PTZ but nothing optional, so init takes the simplest
-    path through the feature detection below."""
-    onvif = MagicMock()
-    onvif.update_xaddrs = AsyncMock()
-
-    video_source = MagicMock()
-    video_source.token = "video_source_1"
-
-    media = MagicMock()
-    media.GetProfiles = AsyncMock(return_value=[_make_profile()])
-    media.GetVideoSources = AsyncMock(return_value=[video_source])
-    onvif.create_media_service = AsyncMock(return_value=media)
-    onvif.get_definition = MagicMock(return_value={"ptz": "definition"})
-
-    ptz = MagicMock()
-    # create_type is a local WSDL lookup, so tag the result to assert on it later
-    ptz.create_type = MagicMock(side_effect=lambda name: MagicMock(request_type=name))
-    ptz.GetConfigurationOptions = AsyncMock(side_effect=Exception("not supported"))
-    onvif.create_ptz_service = AsyncMock(return_value=ptz)
-    onvif.create_imaging_service = AsyncMock(side_effect=Exception("not supported"))
-    return onvif
-
-
-def _make_controller(autotracking_enabled: bool) -> OnvifController:
-    """Build a controller without invoking __init__, which would start an event loop
-    thread and reach out to the camera."""
-    config = _config(autotracking_enabled)
-    controller = OnvifController.__new__(OnvifController)
-    controller.config = config
-    controller.cams = {CAMERA: {"onvif": _make_onvif_camera(), "init": False}}
-    controller.failed_cams = {}
-    controller.camera_configs = {CAMERA: config.cameras[CAMERA]}
-    controller.ptz_metrics = {CAMERA: MagicMock()}
-    return controller
-
-
-class TestOnvifInitRequests(unittest.IsolatedAsyncioTestCase):
-    async def test_status_request_created_when_autotracking_disabled(self) -> None:
-        # the wizard flow: onvif configured first, autotracking enabled later
-        controller = _make_controller(autotracking_enabled=False)
-
-        self.assertTrue(await controller._init_onvif(CAMERA))
-
-        cam = controller.cams[CAMERA]
-        self.assertTrue(cam["init"])
-        self.assertIn("status_request", cam)
-        self.assertIn("service_capabilities_request", cam)
-
-    async def test_status_request_created_when_autotracking_enabled(self) -> None:
-        controller = _make_controller(autotracking_enabled=True)
-
-        self.assertTrue(await controller._init_onvif(CAMERA))
-
-        cam = controller.cams[CAMERA]
-        self.assertIn("status_request", cam)
-        self.assertIn("service_capabilities_request", cam)
-
-    async def test_init_implies_status_request_exists(self) -> None:
-        # the invariant get_camera_status relies on: it skips re-init when init is
-        # True and then reads status_request without guarding
-        for autotracking_enabled in (True, False):
-            with self.subTest(autotracking_enabled=autotracking_enabled):
-                controller = _make_controller(autotracking_enabled)
-
-                await controller._init_onvif(CAMERA)
-
-                cam = controller.cams[CAMERA]
-                if cam["init"]:
-                    self.assertEqual(cam["status_request"].request_type, "GetStatus")
-
-    async def test_requests_built_without_contacting_camera(self) -> None:
-        # create_type is a local WSDL lookup; cameras that do not implement
-        # GetServiceCapabilities must not be asked about it during init
-        controller = _make_controller(autotracking_enabled=False)
-
-        await controller._init_onvif(CAMERA)
-
-        ptz = controller.cams[CAMERA]["ptz"]
-        ptz.GetServiceCapabilities.assert_not_called()
-        ptz.GetStatus.assert_not_called()
-
-
-if __name__ == "__main__":
-    unittest.main()

frigate/test/test_runtime_state.py

@@ -131,25 +131,6 @@ class TestRuntimeStatePersistence(unittest.TestCase):
         self.store.clear_all()
         self.assertEqual(self.store.load(), {})
 
-    def test_clear_camera_removes_only_that_camera(self) -> None:
-        self.store.set("front_door", "enabled", False)
-        self.store.set("front_door", "detect", False)
-        self.store.set("back_yard", "audio", False)
-
-        self.store.clear_camera("front_door")
-
-        self.assertEqual(self.store.load(), {"back_yard": {"audio": False}})
-
-    def test_clear_camera_is_noop_for_unknown_camera(self) -> None:
-        self.store.set("front_door", "enabled", False)
-        self.store.clear_camera("side_gate")
-        self.assertEqual(self.store.load(), {"front_door": {"enabled": False}})
-
-    def test_clear_camera_is_safe_when_file_missing(self) -> None:
-        # No prior set() calls, so the file does not exist
-        self.store.clear_camera("front_door")
-        self.assertEqual(self.store.load(), {})
-
 
 if __name__ == "__main__":
     unittest.main()

frigate/util/services.py

@@ -285,10 +285,6 @@ _XE_ENGINE_KEYS = {
     "vecs": "video-enhance",
     "ccs": "compute",
 }
-_INTEL_DRM_DRIVERS = ("i915", "xe")
-_PCI_ADDRESS_RE = re.compile(
-    r"^[0-9a-fA-F]{4}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-9a-fA-F]$"
-)
 
 
 def _resolve_intel_gpu_pdev(device: str | None) -> str | None:
@@ -298,70 +294,29 @@ def _resolve_intel_gpu_pdev(device: str | None) -> str | None:
     if not device:
         return None
 
-    if _PCI_ADDRESS_RE.match(device):
+    if re.match(r"^[0-9a-fA-F]{4}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-9a-fA-F]$", device):
         return device
 
     name = os.path.basename(device.rstrip("/"))
     try:
-        pdev = os.path.basename(os.path.realpath(f"/sys/class/drm/{name}/device"))
+        return os.path.basename(os.path.realpath(f"/sys/class/drm/{name}/device"))
     except OSError:
         return None
 
-    # realpath does not raise on a nonexistent node; it returns the input
-    # path unchanged, so validate the result actually looks like a PCI
-    # address before trusting it.
-    return pdev if _PCI_ADDRESS_RE.match(pdev) else None
 
-
-def _enumerate_drm_devices() -> dict[str, str]:
-    """Map each PCI-attached DRM device to its bound kernel driver.
-
-    Reads /sys/class/drm, which reflects every GPU on the host even when only
-    some render nodes are mapped into the container, so device presence can be
-    verified without /dev access. Returns {pdev: driver}, e.g.
-    {"0000:00:02.0": "i915"}.
-    """
-    devices: dict[str, str] = {}
-
-    try:
-        entries = os.listdir("/sys/class/drm")
-    except OSError:
-        return devices
-
-    for entry in entries:
-        device_dir = f"/sys/class/drm/{entry}/device"
-        pdev = os.path.basename(os.path.realpath(device_dir))
-
-        if not _PCI_ADDRESS_RE.match(pdev):
-            continue
-
-        try:
-            driver = os.path.basename(os.readlink(f"{device_dir}/driver"))
-        except OSError:
-            continue
-
-        devices[pdev] = driver
-
-    return devices
-
-
-def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict | None:
+def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict:
     """Snapshot DRM fdinfo for every Intel client visible in /proc.
 
     Returns a dict keyed by (pdev, drm-client-id, pid) so the same context
     seen via multiple file descriptors on a single process collapses to one
-    entry. Clients whose fdinfo carries no engine counters are still included
-    with an empty "engines" dict so the caller can distinguish "clients exist
-    but the kernel publishes no busyness" from "no clients at all". Returns
-    None when /proc itself cannot be scanned, which is a different failure
-    than a scan that finds nothing.
+    entry.
     """
     snapshot: dict = {}
 
     try:
         proc_entries = os.listdir("/proc")
     except OSError:
-        return None
+        return snapshot
 
     for entry in proc_entries:
         if not entry.isdigit():
@@ -445,124 +400,41 @@ def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict | None:
                     except (ValueError, IndexError):
                         continue
 
+            if not engines:
+                continue
+
             snapshot[key] = {"driver": driver, "pid": entry, "engines": engines}
 
     return snapshot
 
 
-def _idle_intel_gpu_stats(
-    target_pdev: str | None, intel_pdevs: dict[str, str]
-) -> dict[str, dict[str, Any]]:
-    """Build a 0% reading for the configured (or every) Intel GPU.
-
-    Used when the device is confirmed present but no DRM client is currently
-    attached, e.g. while camera processes are restarting. That is an idle
-    state, not a collection failure, so it must produce a valid reading:
-    returning None would latch the hwaccel error cooldown and blank GPU stats
-    for an hour over a momentary gap.
-    """
-    from frigate.stats.intel_gpu_info import intel_gpu_name_resolver
-
-    names = intel_gpu_name_resolver.get_names()
-    pdevs = [target_pdev] if target_pdev else sorted(intel_pdevs)
-
-    return {
-        pdev: {
-            "name": names.get(pdev) or "Intel iGPU",
-            "vendor": "intel",
-            "gpu": "0.0%",
-            "mem": "-%",
-            "compute": "0.0%",
-            "dec": "0.0%",
-        }
-        for pdev in pdevs
-    }
-
-
 def get_intel_gpu_stats(
     intel_gpu_device: str | None,
 ) -> dict[str, dict[str, Any]] | None:
     """Get stats by reading DRM fdinfo files, bucketed per-pdev.
 
     Each DRM client FD exposes monotonic per-engine busy counters via
-    /proc/<pid>/fdinfo/<fd>. For i915 this requires kernel 6.5 or newer:
-    earlier kernels omit the per-engine counters whenever GuC submission is
-    active, which is the default on 12th gen and newer. Xe has exposed them
-    since its first release. We sample twice and divide busy-time deltas by
-    wall-clock to derive utilization. Render/3D and Compute are pooled into
-    "compute"; Video and VideoEnhance into "dec". Overall "gpu" is the sum of
-    those pools (clamped to 100%).
+    /proc/<pid>/fdinfo/<fd> (i915 since kernel 5.19, Xe since first release).
+    We sample twice and divide busy-time deltas by wall-clock to derive
+    utilization. Render/3D and Compute are pooled into "compute"; Video and
+    VideoEnhance into "dec". Overall "gpu" is the sum of those pools (clamped
+    to 100%).
 
     The return value is keyed by the GPU's drm-pdev string so multiple Intel
     GPUs in the same system are reported separately. Each entry carries a
     "name" populated from OpenVINO (falling back to the pdev) so callers can
     surface a real device name in the UI.
-
-    A device that exists but has no attached DRM clients reports an idle 0%
-    reading. None is returned only for durable failures (no Intel GPU, a bad
-    intel_gpu_device config, unreadable /proc, or a kernel that publishes no
-    counters), each of which logs a distinct warning, and the caller latches
-    it against retries for an hour.
     """
     from frigate.stats.intel_gpu_info import intel_gpu_name_resolver
 
     target_pdev = _resolve_intel_gpu_pdev(intel_gpu_device)
-    if intel_gpu_device and not target_pdev:
-        logger.warning(
-            "Unable to collect Intel GPU stats: configured intel_gpu_device %s "
-            "does not exist or could not be resolved to a PCI device",
-            intel_gpu_device,
-        )
-        return None
-
-    drm_devices = _enumerate_drm_devices()
-    intel_pdevs = {
-        pdev: driver
-        for pdev, driver in drm_devices.items()
-        if driver in _INTEL_DRM_DRIVERS
-    }
-
-    if not intel_pdevs:
-        logger.warning(
-            "Unable to collect Intel GPU stats: no Intel GPU (i915/xe) found in "
-            "/sys/class/drm. Check that the driver is loaded on the host"
-        )
-        return None
-
-    if target_pdev and target_pdev not in intel_pdevs:
-        logger.warning(
-            "Unable to collect Intel GPU stats: configured intel_gpu_device %s "
-            "resolved to %s (driver: %s), which is not an Intel GPU",
-            intel_gpu_device,
-            target_pdev,
-            drm_devices.get(target_pdev, "unknown"),
-        )
-        return None
 
     snapshot_a = _read_intel_drm_fdinfo(target_pdev)
-    if snapshot_a is None:
-        logger.warning("Unable to collect Intel GPU stats: /proc could not be read")
-        return None
-
     if not snapshot_a:
-        # No process currently holds the GPU open, e.g. while camera processes
-        # are restarting. The device is confirmed present, so report idle
-        # rather than an error; the next stats cycle re-samples normally.
-        logger.debug("No active DRM clients for Intel GPU, reporting idle")
-        return _idle_intel_gpu_stats(target_pdev, intel_pdevs)
-
-    if not any(client["engines"] for client in snapshot_a.values()):
-        # Clients exist but the kernel published no busyness for them, so
-        # there is nothing to sample and a second snapshot would not help.
-        # i915 suppresses per-client engine counters while GuC submission is
-        # active on kernels older than 6.5 (kernel commit 1324680a80eb lifted
-        # this), which covers stock Debian 12 and Ubuntu 22.04 on 12th gen
-        # and newer.
         logger.warning(
-            "Unable to collect Intel GPU stats: found %d DRM client(s) for %s but "
-            "no per-engine counters. Kernel 6.5 or newer is required.",
-            len(snapshot_a),
-            "/".join(sorted({client["driver"] for client in snapshot_a.values()})),
+            "Unable to collect Intel GPU stats: no DRM fdinfo entries found"
+            "%s. Check that /proc is readable and the i915/xe driver is loaded",
+            f" for pdev {target_pdev}" if target_pdev else "",
         )
         return None
 
@@ -571,17 +443,11 @@ def get_intel_gpu_stats(
     elapsed_ns = (time.monotonic() - start) * 1e9
 
     snapshot_b = _read_intel_drm_fdinfo(target_pdev)
-    if snapshot_b is None:
-        logger.warning("Unable to collect Intel GPU stats: /proc could not be read")
-        return None
-
     if not snapshot_b or elapsed_ns <= 0:
-        # Every client disappeared during the sample window; transient by
-        # definition, so report idle instead of latching an error.
-        logger.debug(
-            "No DRM clients persisted across Intel GPU samples, reporting idle"
+        logger.warning(
+            "Unable to collect Intel GPU stats: second DRM fdinfo sample was empty"
         )
-        return _idle_intel_gpu_stats(target_pdev, intel_pdevs)
+        return None
 
     def _new_engine_pct() -> dict[str, float]:
         return {"render": 0.0, "video": 0.0, "video-enhance": 0.0, "compute": 0.0}
@@ -594,11 +460,6 @@ def get_intel_gpu_stats(
         if not data_a or data_a["driver"] != data_b["driver"]:
             continue
 
-        # Skip before the setdefault below so a counter-less client cannot
-        # register its pdev on its own.
-        if not data_b["engines"]:
-            continue
-
         pdev = key[0]
         engine_pct = per_pdev_engine_pct.setdefault(pdev, _new_engine_pct())
         pid_pct = per_pdev_pid_pct.setdefault(pdev, {})
@@ -630,12 +491,11 @@ def get_intel_gpu_stats(
         pid_pct[data_b["pid"]] = pid_pct.get(data_b["pid"], 0.0) + client_total
 
     if not per_pdev_engine_pct:
-        # Clients were seen in both snapshots but none persisted as the same
-        # (pdev, client-id, pid); process churn, so report idle.
-        logger.debug(
-            "No DRM clients persisted across Intel GPU samples, reporting idle"
+        logger.warning(
+            "Unable to collect Intel GPU stats: no per-engine counters available "
+            "(i915 requires kernel >= 5.19)"
         )
-        return _idle_intel_gpu_stats(target_pdev, intel_pdevs)
+        return None
 
     names = intel_gpu_name_resolver.get_names()
     results: dict[str, dict[str, Any]] = {}

web/public/locales/ca/components/dialog.json

@@ -61,8 +61,7 @@
       "error": {
         "endTimeMustAfterStartTime": "L'hora de finalització ha de ser posterior a l'hora d'inici",
         "noVaildTimeSelected": "No s'ha seleccionat un rang de temps vàlid",
-        "failed": "No s'ha pogut inciar l'exportació: {{error}}",
-        "noValidTimeSelected": "No s'ha seleccionat cap interval de temps vàlid"
+        "failed": "No s'ha pogut inciar l'exportació: {{error}}"
       },
       "view": "Vista",
       "queued": "Exporta a la cua. Mostra el progrés a la pàgina d'exportacions.",

web/public/locales/ca/config/cameras.json

@@ -493,9 +493,6 @@
             "max_concurrent": {
                 "label": "Màxim d'exportacions concurrents",
                 "description": "Nombre màxim de treballs d'exportació a processar al mateix temps."
-            },
-            "chapters": {
-                "label": "Metadades de capítol per incrustar en els enregistraments exportats"
             }
         },
         "preview": {

web/public/locales/ca/config/global.json

@@ -380,9 +380,6 @@
             "max_concurrent": {
                 "label": "Màxim d'exportacions concurrents",
                 "description": "Nombre màxim de treballs d'exportació a processar al mateix temps."
-            },
-            "chapters": {
-                "label": "Metadades de capítol per incrustar en els enregistraments exportats"
             }
         },
         "preview": {

web/public/locales/ca/views/classificationModel.json

@@ -192,20 +192,7 @@
     "title": "Edita el model de classificació",
     "descriptionState": "Edita les classes per a aquest model de classificació d'estats. Els canvis requeriran tornar a entrenar el model.",
     "descriptionObject": "Edita el tipus d'objecte i el tipus de classificació per a aquest model de classificació d'objectes.",
-    "stateClassesInfo": "S'ha actualitzat el model. Restringeix el model perquè els canvis de classe tinguin efecte.",
-    "enabled": "Habilitat",
-    "enabledDesc": "Executa aquest model. Quan està desactivat, deixa d'executar-se i ja no classifica.",
-    "saveAttempts": "Desa els intents",
-    "saveAttemptsDesc": "Nombre d'imatges de classificació que s'intenten mantenir per a les classificacions recents UI.",
-    "motion": "Executa en moviment",
-    "motionDesc": "Executa la classificació quan es detecta el moviment dins de l'escapçat configurat.",
-    "interval": "Interval",
-    "intervalDesc": "Segons entre les classificacions periòdiques. Deixeu-ho buit per a executar-se només en moviment.",
-    "intervalPlaceholder": "Sense interval",
-    "errors": {
-      "saveAttemptsInvalid": "Els intents de desar han de ser un nombre sencer de 0 o més",
-      "intervalInvalid": "L'interval ha de ser un nombre sencer més gran que 0"
-    }
+    "stateClassesInfo": "Nota: Canviar les classes d'estat requereix tornar a entrenar el model amb les classes actualitzades."
   },
   "tooltip": {
     "trainingInProgress": "El model s'està entrenant actualment",
@@ -215,6 +202,5 @@
   },
   "none": "Cap",
   "reclassifyImageAs": "Reclassifica la imatge com a:",
-  "reclassifyImage": "Reclassifica la imatge",
-  "disabled": "Desactivat"
+  "reclassifyImage": "Reclassifica la imatge"
 }

web/public/locales/ca/views/explore.json

@@ -303,7 +303,7 @@
       },
       "offset": {
         "label": "Òfset d'Anotació",
-        "desc": "Aquestes dades provenen del canal de detecció de la càmera, però estan sobreposades a les imatges del canal de registre. És poc probable que els dos corrents estiguin perfectament sincronitzats. Com a resultat, la caixa contenidora i les imatges no s'alinearan perfectament. Podeu utilitzar aquest paràmetre per a compensar les anotacions cap endavant o cap enrere en el temps per a alinear-les millor amb el metratge gravat.",
+        "desc": "Aquestes dades provenen del flux de detecció de la càmera, però se superposen a les imatges del flux de gravació. És poc probable que els dos fluxos estiguin perfectament sincronitzats. Com a resultat, el quadre delimitador i les imatges no s'alinearan perfectament. Tanmateix, es pot utilitzar el camp <code>annotation_offset</code> per ajustar-ho.",
         "millisecondsToOffset": "Millisegons per l'òfset de detecció d'anotacions per. <em>Per defecte: 0</em>",
         "tips": "Reduïu el valor si la reproducció del vídeo es troba per davant dels quadres i els punts de ruta, i augmenteu-lo si es troba per darrere. Aquest valor pot ser negatiu.",
         "toast": {

web/public/locales/ca/views/settings.json

@@ -698,7 +698,7 @@
         "title": "Crear un nou usuari",
         "confirmPassword": "Siusplau, confirma la contrasenya",
         "usernameOnlyInclude": "El nom d'usuari només pot contenir lletres, números, . o _",
-        "desc": "Afegeix un compte d'usuari nou i especifica un rol per a l'accés a les àrees de la interfície d'usuari de Frigate."
+        "desc": "Afegeix un nou compte d'usuari i especifica un rol per accedir a àrees de la interfície de Frigate."
       }
     },
     "title": "Usuaris",
@@ -1323,7 +1323,7 @@
       "details": {
         "edit": "Edita els detalls de la càmera",
         "title": "Edita els detalls de la càmera",
-        "description": "Actualitza el nom de visualització, l'URL extern i la visibilitat utilitzada per a aquesta càmera a tota la interfície d'usuari de Frigate.",
+        "description": "Actualitza el nom de visualització, l'URL extern i la visibilitat utilitzada per a aquesta càmera a tota la interfície d'usuari de la Fragata.",
         "friendlyNameLabel": "Nom a mostrar",
         "friendlyNameHelp": "Nom amistós que es mostra per a aquesta càmera a tota la interfície d'usuari de Frigate. Deixeu-ho en blanc per utilitzar l'ID de la càmera.",
         "webuiUrlLabel": "URL de la interfície web de la càmera",
@@ -1484,7 +1484,7 @@
         "successMulti_other": "Configuració copiada a {{count}} càmeres",
         "successMultiWithRestart_one": "Configuració copiada a la càmera {{count}}. Reinicia Frigate per aplicar tots els canvis.",
         "successMultiWithRestart_many": "Configuració copiada a {{count}} càmeres. Reinicia Frigate per aplicar tots els canvis.",
-        "successMultiWithRestart_other": "Configuració copiada a {{count}} càmeres. Reinicia Frigate per aplicar tots els canvis.",
+        "successMultiWithRestart_other": "Configuració copiada a {{count}} càmeres. Reinicia la fragata per aplicar tots els canvis.",
         "partialFailure": "{{successCount}} seccions aplicades; «{{failedSection}}» ha fallat: {{errorMessage}}",
         "partialFailureMulti": "S'ha copiat a {{successCount}} càmera(es); ha fallat {{failed}}: {{errorMessage}}",
         "newCameraPartialFailure": "S'ha creat la càmera {{cameraName}} però no s'han pogut copiar alguns paràmetres: {{errorMessage}}",
@@ -1641,14 +1641,7 @@
       "keyLabel": "Clau",
       "valueLabel": "Valor",
       "keyPlaceholder": "Nou valor",
-      "remove": "Elimina",
-      "providerNameLabel": "Nom del proveïdor",
-      "providerNamePlaceholder": "p. ex., openai",
-      "variableNameLabel": "Nom de la variable",
-      "variableNamePlaceholder": ". ex., La_Meva_Variable",
-      "loggerNameLabel": "Nom del registrador",
-      "loggerNamePlaceholder": "p. ex., friagte.registre",
-      "keyPatternError": "Utilitza només lletres, números, guions i guions baixos (sense espais)"
+      "remove": "Elimina"
     },
     "timezone": {
       "defaultOption": "Utilitza la zona horària del navegador"

web/public/locales/en/views/system.json

@@ -107,7 +107,12 @@
       },
       "npuUsage": "NPU Usage",
       "npuMemory": "NPU Memory",
-      "npuTemperature": "NPU Temperature"
+      "npuTemperature": "NPU Temperature",
+      "intelGpuWarning": {
+        "title": "Intel GPU Stats Warning",
+        "message": "GPU stats unavailable",
+        "description": "This is a known bug in Intel's GPU stats reporting tools (intel_gpu_top) where it will break and repeatedly return a GPU usage of 0% even in cases where hardware acceleration and object detection are correctly running on the (i)GPU. This is not a Frigate bug. You can restart the host to temporarily fix the issue and confirm that the GPU is working correctly. This does not affect performance."
+      }
     },
     "otherProcesses": {
       "title": "Other Processes",

web/public/locales/et/audio.json

@@ -273,69 +273,5 @@
   "sailboat": "Purjekas",
   "soundtrack_music": "Filmimuusika",
   "jingle": "Kõlisemine/tilisemine",
-  "theme_music": "Tunnusmuusika",
-  "steel_guitar": "Steel Kitarr",
-  "tapping": "Koputamine",
-  "strum": "Klimberdus",
-  "drum_machine": "Trummimasin",
-  "drum": "Trumm",
-  "maraca": "Marakas",
-  "bowed_string_instrument": "Poogenkeelpill",
-  "singing_bowl": "Helikauss",
-  "wind_noise": "Tuulemüra",
-  "rustling_leaves": "Sahisevad lehed",
-  "waves": "Lained",
-  "steam": "Aur",
-  "ship": "Laev",
-  "motor_vehicle": "Mootorsõiduk",
-  "rowboat": "Sõudepaat",
-  "motorboat": "Mootorpaat",
-  "waterfall": "Kosk",
-  "ocean": "Ookean",
-  "rain_on_surface": "Vihm pinnal",
-  "stream": "Oja",
-  "fire": "Tuli",
-  "crackle": "Praksumine",
-  "car_alarm": "Auto alarm",
-  "truck": "Veoauto",
-  "police_car": "Politseiauto",
-  "ambulance": "Kiirabi",
-  "fire_engine": "Tuletõrjeauto",
-  "aircraft": "Lennuk",
-  "aircraft_engine": "Lennukimootor",
-  "jet_engine": "Reaktiivmootor",
-  "propeller": "Propeller",
-  "helicopter": "Helikopter",
-  "fixed-wing_aircraft": "Fikseeritud tiivaga õhusõiduk",
-  "train_horn": "Rongisignaal",
-  "railroad_car": "Kaubavagun",
-  "lawn_mower": "Muruniiduk",
-  "chainsaw": "mootorsaag",
-  "engine": "Mootor",
-  "knock": "Koputus",
-  "alarm": "Häire",
-  "siren": "Sireen",
-  "fire_alarm": "Tulekahjuhäire",
-  "telephone": "Telefon",
-  "telephone_bell_ringing": "Helisev telefon",
-  "ringtone": "Telefonihelin",
-  "smoke_detector": "Suitsuandur",
-  "foghorn": "Udupasun",
-  "whistle": "Vile",
-  "printer": "Printer",
-  "drill": "Puur",
-  "explosion": "Plahvatus",
-  "hammer": "Haamer",
-  "air_conditioning": "Õhukonditsioneer",
-  "gunshot": "Püssilask",
-  "glass": "Klaas",
-  "boom": "Pauk",
-  "fireworks": "Ilutulestik",
-  "static": "Staatiline",
-  "white_noise": "Valge müra",
-  "radio": "Raadio",
-  "television": "Televiisor",
-  "scream": "Karjumine",
-  "pour": "Valamine",
-  "drip": "Tilkumine"
+  "theme_music": "Tunnusmuusika"
 }

web/public/locales/et/components/dialog.json

@@ -37,9 +37,6 @@
           "ask_an": "Kas see objekt on <code>{{label}}</code>?",
           "ask_full": "Kas see objekt on <code>{{untranslatedLabel}}</code> ({{translatedLabel}})?",
           "label": "Kinnita see silt Frigate+ teenuse jaoks"
-        },
-        "toast": {
-          "error": "Frigate+ teenusesse saatmine ebaõnnestus. Palun kontrolli oma võrguühendust ja proovi uuesti."
         }
       },
       "submitToPlus": {
@@ -73,79 +70,18 @@
       "success": "Eksportimise käivitamine õnnestus. Faili leiad eksportimise lehelt.",
       "view": "Vaata",
       "error": {
-        "failed": "Eksportimise järjekorda lisamine ei õnnestunud: {{error}}",
+        "failed": "Eksportimise käivitamine ei õnnestunud: {{error}}",
         "endTimeMustAfterStartTime": "Ajavahemiku lõpp peab olema peale algust",
-        "noVaildTimeSelected": "Ühtegi kehtivat ajavahemikku pole valitud",
-        "noValidTimeSelected": "Ühtegi korrektset ajavahemikku pole valitud"
-      },
-      "queued": "Eksport on järjekorda lisatud. Vaata progressi eksportide lehelt.",
-      "batchSuccess_one": "Alustasin 1 ekspordiga. Avan juhtumi kohe.",
-      "batchSuccess_other": "Alustasin {{count}} ekspordiga. Avan juhtumi kohe.",
-      "batchPartial": "Alustasin {{successful}}/{{total}} ekspordiga. Ebaõnnestunud kaamerad: {{failedCameras}}",
-      "batchFailed": "{{total}} eksporti ebaõnnestus algatada. Ebaõnnestunud kaamerad: {{failedCameras}}",
-      "batchQueuedSuccess_one": "1 eksport järjekorda lisatud. Avan juhtumi kohe.",
-      "batchQueuedSuccess_other": "{{count}} eksporti järjekorda lisatud. Avan juhtumi kohe.",
-      "batchQueuedPartial": "{{successful}}/{{total}} ekspordist on järjekorda lisatud. Ebaõnnestunud kaamerad: {{failedCameras}}",
-      "batchQueueFailed": "{{total}} eksporti ebaõnnestus järjekorda lisada. Ebaõnnestunud kaamerad: {{failedCameras}}"
+        "noVaildTimeSelected": "Ühtegi kehtivat ajavahemikku pole valitud"
+      }
     },
     "fromTimeline": {
       "saveExport": "Salvesta eksporditud sisu",
-      "previewExport": "Eksporditud sisu eelvaade",
-      "queueingExport": "Ekspordi järjekorda lisamine...",
-      "useThisRange": "Kasuta seda vahemikku"
+      "previewExport": "Eksporditud sisu eelvaade"
     },
     "case": {
       "label": "Juhtum",
-      "placeholder": "Vali juhtum",
-      "newCaseOption": "Ava uus juhtum",
-      "newCaseNamePlaceholder": "Uue juhtumi nimi",
-      "newCaseDescriptionPlaceholder": "Juhtumi kirjeldus",
-      "nonAdminHelp": "Uus juhtum avatakse järnevatele eksportidele."
-    },
-    "queueing": "Ekspordi järjekorda lisamine...",
-    "tabs": {
-      "export": "Üksik kaamera",
-      "multiCamera": "Mitu kaamerat"
-    },
-    "multiCamera": {
-      "timeRange": "Ajavahemik",
-      "selectFromTimeline": "Vali ajajoonelt",
-      "cameraSelection": "Kaamerad",
-      "cameraSelectionHelp": "Selles ajavahemikus tuvastatud objektidega kaamerad on eelvalitud",
-      "searchOrSelectGroup": "Otsi või vali kaamera grupp...",
-      "selectAll": "Vali kõik kaamerad",
-      "clearSelection": "Tühista valik",
-      "selectWithActivity": "Jälgitud objektidega kaamerad",
-      "selectGroup": "Vali grupp",
-      "noMatchingCameras": "Ükski kaamera ei sobitunud otsinguga",
-      "selectedCount": "{{selected}} / {{total}} valitud",
-      "checkingActivity": "Kaamera aktiivsuse kontrollimine...",
-      "noCameras": "Ühtegi kaamerat pole saadaval",
-      "detectionCount_one": "1 jälgitav objekt",
-      "detectionCount_other": "{{count}} jälgitavat objekti",
-      "nameLabel": "Ekspordi nimi",
-      "namePlaceholder": "Valikuline baasnimi nendele eksportidele",
-      "queueingButton": "Ekspordi järjekorda lisamine...",
-      "exportButton_one": "Ekspordi 1 kaamera",
-      "exportButton_other": "Ekspordi {{count}} kaamerat"
-    },
-    "multi": {
-      "title_one": "Ekspordi 1 ülevaade",
-      "title_other": "Espordi {{count}} ülevaadet",
-      "description": "Ekspordi valitud ülevaated. Kõik ekspordid on grupeeritud ühte juhtumisse.",
-      "descriptionNoCase": "Ekspordi kõik valitud juhtumid.",
-      "caseNamePlaceholder": "Ülevaate eksport - {{date}}",
-      "exportButton_one": "Ekspordi 1 ülevaade",
-      "exportButton_other": "Ekspordi {{count}} ülevaadet",
-      "exportingButton": "Ekspordin...",
-      "toast": {
-        "started_one": "Alustasin 1 eksporti. Avan juhtumi kohe.",
-        "started_other": "Alustasin {{count}} ekspordiga. Avan juhtumi kohe.",
-        "startedNoCase_one": "Alustasin 1 ekspordiga.",
-        "startedNoCase_other": "Alustasin {{count}} ekspordiga.",
-        "partial": "Alustasin {{successful}}/{{total}} ekspordiga. Ebaõnnestusid: {{failedItems}}",
-        "failed": "{{total}} ekspordi algatamine ebaõnnestus. Ebaõnnestunud: {{failedItems}}"
-      }
+      "placeholder": "Vali juhtum"
     }
   },
   "streaming": {
@@ -178,14 +114,6 @@
         "success": "Selle ülevaadatava objektiga seotud videosisu on kustutatud.",
         "error": "Kustutamine ei õnnestunud: {{error}}"
       }
-    },
-    "shareTimestamp": {
-      "label": "Jaotise ajatempel",
-      "title": "Jaotise ajatempel",
-      "description": "Jaga praeguse esituskoha ajatempliga URL-i või vali kohandatud ajatempel. Arvesta, et see ei ole avalik jagamislink ja on kättesaadav ainult kasutajatele, kellel on ligipääs Frigate'ile ja sellele kaamerale.",
-      "custom": "Kohandatud ajatempel",
-      "button": "Jaga ajatempliga linki",
-      "shareTitle": "Frigate ülevaate ajatempel: {{camera}}"
     }
   },
   "imagePicker": {

web/public/locales/et/config/cameras.json

@@ -12,20 +12,11 @@
         "description": "Kasutusel"
     },
     "audio": {
-        "label": "Heli tuvastus",
-        "min_volume": {
-            "label": "Minimaalne helitase"
-        },
-        "filters": {
-            "label": "Audio filtrid"
-        }
+        "label": "Helisündmused"
     },
     "birdseye": {
         "mode": {
             "label": "Jälgimisrežiim"
-        },
-        "order": {
-            "label": "Positsioon"
         }
     },
     "label": "Kaameraseadistus",
@@ -34,8 +25,7 @@
             "threshold": {
                 "description": "Minimaalne sarnasuse punktiskoor (0-1), mis on vajalik selle päästiku käivitamiseks."
             }
-        },
-        "label": "Semantiline otsing"
+        }
     },
     "lpr": {
         "label": "Sõidukite numbrimärkide tuvastus",
@@ -44,171 +34,6 @@
     "review": {
         "genai": {
             "description": "Kontrollib generatiivse tehisaru kasutamist kirjelduste ja kokkuvõtete koostamiseks ülevaatamisele kuuluvate objektide jaoks."
-        },
-        "alerts": {
-            "enabled": {
-                "label": "Luba häired"
-            }
         }
-    },
-    "audio_transcription": {
-        "label": "Audio transkriptsioon",
-        "live_enabled": {
-            "label": "Reaalajas transkriptsioon"
-        },
-        "enabled": {
-            "label": "Luba heli üleskirjutamine tekstina"
-        }
-    },
-    "detect": {
-        "label": "Objekti tuvastus",
-        "enabled": {
-            "label": "Luba objektituvastus"
-        },
-        "height": {
-            "label": "Tuvastamise kõrgus"
-        },
-        "width": {
-            "label": "Tuvastamise laius"
-        },
-        "fps": {
-            "label": "Tuvastamise kaadrisagedus"
-        },
-        "stationary": {
-            "label": "Püsivate objektide sätted"
-        }
-    },
-    "face_recognition": {
-        "label": "Näotuvastus"
-    },
-    "ffmpeg": {
-        "path": {
-            "label": "FFmpeg asukoht"
-        },
-        "gpu": {
-            "label": "GPU indeks"
-        },
-        "inputs": {
-            "global_args": {
-                "label": "FFmpeg globaalsed argumendid"
-            }
-        }
-    },
-    "live": {
-        "label": "Reaalajas mahamängimine",
-        "height": {
-            "label": "Otseülekande kõrgus"
-        },
-        "quality": {
-            "label": "Otseülekande kvaliteet"
-        },
-        "streams": {
-            "label": "Otseülekande voo nimed"
-        }
-    },
-    "motion": {
-        "label": "Liikumistuvastus",
-        "frame_height": {
-            "label": "Kaadri kõrgus"
-        },
-        "enabled": {
-            "label": "Luba liikumistuvastus"
-        }
-    },
-    "objects": {
-        "label": "Objektid",
-        "filters": {
-            "min_area": {
-                "label": "Minimaalne objekti ala"
-            },
-            "max_area": {
-                "label": "Maksimaalne objekti ala"
-            }
-        },
-        "genai": {
-            "label": "GenAI objekti konfiguratsioon",
-            "required_zones": {
-                "label": "Nõutud tsoonid"
-            },
-            "debug_save_thumbnails": {
-                "label": "Salvesta pisipildid"
-            },
-            "enabled": {
-                "label": "Luba GenAI"
-            },
-            "use_snapshot": {
-                "label": "Kasuta hetktõmmiseid"
-            }
-        }
-    },
-    "mqtt": {
-        "label": "MQTT"
-    },
-    "notifications": {
-        "enabled": {
-            "label": "Luba teavitused"
-        },
-        "email": {
-            "label": "Teavituste email"
-        },
-        "label": "Teavitused"
-    },
-    "ui": {
-        "label": "Kaamera kasutajaliides"
-    },
-    "record": {
-        "label": "Salvestus",
-        "enabled": {
-            "label": "Luba salvestamine"
-        }
-    },
-    "snapshots": {
-        "enabled": {
-            "label": "Luba hetktõmmised"
-        }
-    },
-    "timestamp_style": {
-        "color": {
-            "red": {
-                "label": "Punane",
-                "description": "Punase komponent (0–255) ajatempli värvi jaoks."
-            },
-            "green": {
-                "label": "Roheline",
-                "description": "Rohelise komponent (0–255) ajatempli värvi jaoks."
-            },
-            "blue": {
-                "label": "Sinine",
-                "description": "Sinise komponent (0–255) ajatempli värvi jaoks."
-            },
-            "label": "Ajatempli värv",
-            "description": "Ajatempli teksti RGB värviväärtused (kõik väärtused 0–255)."
-        },
-        "thickness": {
-            "label": "Ajatempli paksus",
-            "description": "Ajatempli teksti joone paksus."
-        },
-        "effect": {
-            "label": "Ajatempli efekt",
-            "description": "Ajatempli teksti visuaalne efekt (puudub, ühtlane, vari)."
-        }
-    },
-    "onvif": {
-        "user": {
-            "label": "ONVIF kasutajanimi"
-        },
-        "password": {
-            "label": "ONVIF parool"
-        },
-        "port": {
-            "label": "ONVIF port"
-        },
-        "label": "ONVIF",
-        "host": {
-            "label": "ONVIF host"
-        }
-    },
-    "profiles": {
-        "label": "Profiilid"
     }
 }

web/public/locales/et/config/global.json

@@ -1,31 +1,10 @@
 {
     "audio": {
-        "label": "Heli tuvastus",
-        "min_volume": {
-            "label": "Minimaalne helitase"
-        },
-        "filters": {
-            "label": "Audio filtrid"
-        }
+        "label": "Helisündmused"
     },
     "birdseye": {
         "mode": {
             "label": "Jälgimisrežiim"
-        },
-        "order": {
-            "label": "Positsioon"
-        },
-        "height": {
-            "label": "Kõrgus"
-        },
-        "width": {
-            "label": "Laius"
-        },
-        "layout": {
-            "label": "Paigutus",
-            "scaling_factor": {
-                "label": "Skaleerimistegur"
-            }
         }
     },
     "version": {
@@ -43,15 +22,6 @@
             "threshold": {
                 "label": "Punktiskoori lävend",
                 "description": "Punktiskoori lävend, mida kasutatakse klassifitseerimise oleku muutmiseks."
-            },
-            "enabled": {
-                "label": "Luba mudel"
-            },
-            "name": {
-                "label": "Mudeli nimi"
-            },
-            "save_attempts": {
-                "label": "Salvestamiskatsed"
             }
         }
     },
@@ -60,25 +30,11 @@
             "threshold": {
                 "description": "Minimaalne sarnasuse punktiskoor (0-1), mis on vajalik selle päästiku käivitamiseks."
             }
-        },
-        "label": "Semantiline otsing",
-        "model_size": {
-            "label": "Mudeli suurus"
-        },
-        "device": {
-            "label": "Seade"
         }
     },
     "face_recognition": {
         "unknown_score": {
             "label": "Tundmatu punktiskoori lävend"
-        },
-        "label": "Näotuvastus",
-        "model_size": {
-            "label": "Mudeli suurus"
-        },
-        "device": {
-            "label": "Seade"
         }
     },
     "lpr": {
@@ -86,393 +42,15 @@
         "description": "Sõidukite numbrimärkide tuvastuse seadistus sisaldab tuvastuse lävendeid, vormindust ja teadaolevaid numbrimärke.",
         "enabled": {
             "description": "Lülita sõidukite numbrimärkide tuvastus kõikide kaamerate jaoks sisse; seda saad kaamerakohaselt ka sürjutada."
-        },
-        "model_size": {
-            "label": "Mudeli suurus"
-        },
-        "device": {
-            "label": "Seade"
         }
     },
     "genai": {
         "label": "Generatiivse tehisaru seadistus",
-        "description": "Seadistsued generatiivse tehisaru teenusepakkujate kasutamisel kirjelduste ja kokkuvõtete loomiseks ülevaatamisele kuuluvate objektide jaoks.",
-        "model": {
-            "label": "Mudel"
-        },
-        "roles": {
-            "label": "Rollid"
-        },
-        "api_key": {
-            "label": "API võti"
-        },
-        "base_url": {
-            "label": "Baas-URL"
-        }
+        "description": "Seadistsued generatiivse tehisaru teenusepakkujate kasutamisel kirjelduste ja kokkuvõtete loomiseks ülevaatamisele kuuluvate objektide jaoks."
     },
     "review": {
         "genai": {
             "description": "Kontrollib generatiivse tehisaru kasutamist kirjelduste ja kokkuvõtete koostamiseks ülevaatamisele kuuluvate objektide jaoks."
-        },
-        "alerts": {
-            "enabled": {
-                "label": "Luba häired",
-                "description": "Luba või keela kõigi kaamerate häirete genereerimine; seda saab kaamerati eraldi muuta."
-            }
         }
-    },
-    "audio_transcription": {
-        "label": "Audio transkriptsioon",
-        "live_enabled": {
-            "label": "Reaalajas transkriptsioon"
-        },
-        "enabled": {
-            "label": "Luba heli üleskirjutamine tekstina",
-            "description": "Luba või keela automaatne heli üleskirjutamine tektina kõigi kaamerate jaoks; seda saad kaamerati eraldi muuta."
-        },
-        "language": {
-            "label": "Üleskirjutuse keel",
-            "description": "Üleskirjutuse/tõlkimise jaoks kasutatav keelekood (näiteks „en” inglise keele puhul). Toetatud keelekoodid leiad lehelt https://whisper-api.com/docs/languages/."
-        },
-        "device": {
-            "label": "Üleskirjutusseade"
-        },
-        "model_size": {
-            "label": "Mudeli suurus"
-        }
-    },
-    "detect": {
-        "label": "Objekti tuvastus",
-        "enabled": {
-            "label": "Luba objektituvastus"
-        },
-        "height": {
-            "label": "Tuvastamise kõrgus"
-        },
-        "width": {
-            "label": "Tuvastamise laius"
-        },
-        "fps": {
-            "label": "Tuvastamise kaadrisagedus"
-        },
-        "stationary": {
-            "label": "Püsivate objektide sätted"
-        }
-    },
-    "ffmpeg": {
-        "path": {
-            "label": "FFmpeg asukoht"
-        },
-        "gpu": {
-            "label": "GPU indeks"
-        },
-        "inputs": {
-            "global_args": {
-                "label": "FFmpeg globaalsed argumendid"
-            }
-        },
-        "label": "FFmpeg"
-    },
-    "live": {
-        "label": "Reaalajas mahamängimine",
-        "height": {
-            "label": "Otseülekande kõrgus"
-        },
-        "quality": {
-            "label": "Otseülekande kvaliteet"
-        },
-        "streams": {
-            "label": "Otseülekande voo nimed"
-        }
-    },
-    "motion": {
-        "label": "Liikumistuvastus",
-        "frame_height": {
-            "label": "Kaadri kõrgus"
-        },
-        "enabled": {
-            "label": "Luba liikumistuvastus"
-        }
-    },
-    "objects": {
-        "label": "Objektid",
-        "filters": {
-            "min_area": {
-                "label": "Minimaalne objekti ala"
-            },
-            "max_area": {
-                "label": "Maksimaalne objekti ala"
-            }
-        },
-        "genai": {
-            "label": "GenAI objekti konfiguratsioon",
-            "required_zones": {
-                "label": "Nõutud tsoonid"
-            },
-            "debug_save_thumbnails": {
-                "label": "Salvesta pisipildid"
-            },
-            "enabled": {
-                "label": "Luba GenAI"
-            },
-            "use_snapshot": {
-                "label": "Kasuta hetktõmmiseid"
-            }
-        }
-    },
-    "auth": {
-        "reset_admin_password": {
-            "label": "Lähtesta administraatori parool"
-        },
-        "cookie_name": {
-            "label": "JWT küpsise nimi"
-        },
-        "enabled": {
-            "label": "Luba autentimine"
-        },
-        "label": "Autentimine",
-        "session_length": {
-            "label": "Sessiooni pikkus"
-        }
-    },
-    "database": {
-        "label": "Andmebaas"
-    },
-    "mqtt": {
-        "label": "MQTT",
-        "enabled": {
-            "label": "Luba MQTT"
-        },
-        "user": {
-            "label": "MQTT kasutajanimi"
-        },
-        "tls_ca_certs": {
-            "label": "TLS CA sertifikaat"
-        },
-        "tls_client_cert": {
-            "label": "Kliendi sertifikaat"
-        },
-        "host": {
-            "label": "MQTT host",
-            "description": "MQTT maakleri hostinimi või IP-aadress."
-        },
-        "port": {
-            "label": "MQTT port"
-        },
-        "client_id": {
-            "label": "Kliendi ID"
-        },
-        "stats_interval": {
-            "label": "Statistika intervall"
-        },
-        "tls_client_key": {
-            "label": "Kliendi võti"
-        },
-        "qos": {
-            "label": "MQTT QoS"
-        }
-    },
-    "go2rtc": {
-        "label": "go2rtc"
-    },
-    "notifications": {
-        "enabled": {
-            "label": "Luba teavitused"
-        },
-        "email": {
-            "label": "Teavituste email"
-        },
-        "label": "Teavitused"
-    },
-    "networking": {
-        "ipv6": {
-            "label": "IPv6 sätted",
-            "enabled": {
-                "label": "Luba IPv6"
-            }
-        },
-        "label": "Võrguühendus",
-        "listen": {
-            "internal": {
-                "label": "Sisemine port"
-            },
-            "external": {
-                "label": "Välimine port"
-            }
-        }
-    },
-    "proxy": {
-        "label": "Vaheserver",
-        "logout_url": {
-            "label": "Väljalogimise url"
-        },
-        "default_role": {
-            "label": "Vaikimisi roll"
-        }
-    },
-    "telemetry": {
-        "stats": {
-            "label": "Süsteemi statistika",
-            "amd_gpu_stats": {
-                "label": "AMD GPU statistika"
-            },
-            "intel_gpu_stats": {
-                "label": "Intel GPU statistika"
-            },
-            "intel_gpu_device": {
-                "label": "Intel GPU seade"
-            },
-            "network_bandwidth": {
-                "label": "Võrgu ribalaius"
-            }
-        },
-        "label": "Telemeetria",
-        "network_interfaces": {
-            "label": "Võrguliides"
-        },
-        "version_check": {
-            "label": "Versiooni kontroll",
-            "description": "Luba väljaminev ühendus, et kontrollida uuema Frigate versooni olemasolu."
-        }
-    },
-    "tls": {
-        "label": "TLS",
-        "enabled": {
-            "label": "Luba TLS"
-        }
-    },
-    "ui": {
-        "timezone": {
-            "label": "ajavöönd"
-        },
-        "label": "Kasutajaliides",
-        "description": "Kasutajaliidese eelistused nagu ajavöönd, aja ja kuupäeva formaat ning ühikud.",
-        "unit_system": {
-            "label": "Ühikute süsteem"
-        }
-    },
-    "detectors": {
-        "label": "Detektori riistvara",
-        "cpu": {
-            "label": "CPU"
-        },
-        "deepstack": {
-            "label": "DeepStack"
-        },
-        "edgetpu": {
-            "label": "EdgeTPU"
-        },
-        "onnx": {
-            "label": "ONNX",
-            "device": {
-                "label": "Seadme tüüp"
-            }
-        },
-        "rknn": {
-            "label": "RKNN"
-        },
-        "openvino": {
-            "label": "OpenVINO"
-        },
-        "tensorrt": {
-            "label": "TensorRT"
-        },
-        "teflon_tfl": {
-            "label": "Teflon"
-        },
-        "synaptics": {
-            "label": "Synaptics"
-        },
-        "memryx": {
-            "device": {
-                "label": "Seadme asukoht"
-            },
-            "label": "MemryX"
-        },
-        "hailo8l": {
-            "label": "Hailo-8/Hailo-8L"
-        },
-        "zmq": {
-            "label": "ZMQ IPC"
-        },
-        "axengine": {
-            "label": "AXEngine NPU"
-        },
-        "degirum": {
-            "label": "DeGirum"
-        }
-    },
-    "logger": {
-        "label": "Logimine"
-    },
-    "model": {
-        "label": "Tuvastusmudel"
-    },
-    "record": {
-        "label": "Salvestus",
-        "enabled": {
-            "label": "Luba salvestamine",
-            "description": "Luba või keela salvestamine kõigi kaamerate jaoks; seda saab kaamerati eraldi muuta."
-        }
-    },
-    "snapshots": {
-        "enabled": {
-            "label": "Luba hetktõmmised",
-            "description": "Luba või keela kõigi kaamerate hetktõmmiste salvestamine; seda saab kaamerati eraldi muuta."
-        }
-    },
-    "timestamp_style": {
-        "color": {
-            "red": {
-                "label": "Punane",
-                "description": "Punase komponent (0–255) ajatempli värvi jaoks."
-            },
-            "green": {
-                "label": "Roheline",
-                "description": "Rohelise komponent (0–255) ajatempli värvi jaoks."
-            },
-            "blue": {
-                "label": "Sinine",
-                "description": "Sinise komponent (0–255) ajatempli värvi jaoks."
-            },
-            "label": "Ajatempli värv",
-            "description": "Ajatempli teksti RGB värviväärtused (kõik väärtused 0–255)."
-        },
-        "thickness": {
-            "label": "Ajatempli paksus",
-            "description": "Ajatempli teksti joone paksus."
-        },
-        "effect": {
-            "label": "Ajatempli efekt",
-            "description": "Ajatempli teksti visuaalne efekt (puudub, ühtlane, vari)."
-        }
-    },
-    "onvif": {
-        "user": {
-            "label": "ONVIF kasutajanimi"
-        },
-        "password": {
-            "label": "ONVIF parool"
-        },
-        "port": {
-            "label": "ONVIF port"
-        },
-        "label": "ONVIF",
-        "host": {
-            "label": "ONVIF host"
-        }
-    },
-    "camera_mqtt": {
-        "quality": {
-            "label": "JPEG kvaliteet",
-            "description": "MQTT-sse saadetud piltide JPEG-kvaliteet (0–100)."
-        },
-        "enabled": {
-            "label": "Saada pilt"
-        },
-        "label": "MQTT"
-    },
-    "profiles": {
-        "label": "Profiilid"
     }
 }

web/public/locales/et/views/chat.json

@@ -6,67 +6,5 @@
     "error": "Midagi läks valesti. Palun proovi uuesti.",
     "processing": "Töötlen…",
     "toolsUsed": "Kasutatud: {{tools}}",
-    "similarity_score": "Sarnasus",
-    "showTools": "Näita tööriistu ({{count}})",
-    "hideTools": "Peida tööriistad",
-    "call": "Kutse",
-    "result": "Tulemus",
-    "arguments": "Argumendid:",
-    "response": "Vastus:",
-    "send": "Saada",
-    "new_chat": "Uus vestlus",
-    "settings": {
-        "title": "Vestluse sätted",
-        "show_stats": {
-            "title": "Näita statistikat",
-            "always": "Alati",
-            "desc": "Kuva vastuste genereerimise kiirus ja konteksti suurus.",
-            "while_generating": "Genereerimise ajal"
-        },
-        "auto_scroll": {
-            "title": "Automaatne kerimine",
-            "desc": "Jälgi uusi sõnumeid kohe, kui need saabuvad."
-        }
-    },
-    "stats": {
-        "context": "{{tokens}} tokenit",
-        "tokens_per_second": "{{rate}} t/s"
-    },
-    "starting_requests_prompts": {
-        "recap": "Mis juhtus kui ma olin ära?",
-        "watch_camera": "Jälgi ust ja anna mulle teada kui keegi tuleb",
-        "show_camera_status": "Milline on minu kaamerate praegune seis?",
-        "show_recent_events": "Näita mulle viimase tunni viimaseid sündmusi"
-    },
-    "starting_requests": {
-        "show_camera_status": "Näita kaamera olekut",
-        "show_recent_events": "Kuva hiljutised sündmused",
-        "recap": "Mis juhtus kui ma olin ära?",
-        "watch_camera": "Jälgi kaamerat aktiivsuse osas"
-    },
-    "suggested_requests": "Proovi küsida:",
-    "semantic_search_required": "Sarnaste objektide leidmiseks peab olema lubatud semantiline otsing.",
-    "no_similar_objects_found": "Sarnaseid objekte ei leitud.",
-    "quick_reply_when_else": "Millal seda veel nähti?",
-    "quick_reply_find_similar_text": "Leia sarnaseid vaatepilte.",
-    "quick_reply_tell_me_more_text": "Räägi mulle sellest lähemalt.",
-    "quick_reply_when_else_text": "Millal seda veel nähtud on?",
-    "attach_event_aria": "Lisa sündmus {{eventId}}",
-    "attachment_picker_paste_label": "Või kleebi sündmuse ID",
-    "attachment_picker_attach": "Lisa",
-    "attachment_picker_placeholder": "Lisa sündmus",
-    "quick_reply_find_similar": "Leia sarnaseid vaatlusi",
-    "quick_reply_tell_me_more": "Räägi mulle sellest lähemalt",
-    "attachment_chip_remove": "Eemalda manus",
-    "attachment_chip_label": "{{label}} kaameras {{camera}}",
-    "open_in_explore": "Ava uurimisvaates",
-    "anchor": "Viide",
-    "reasoning": {
-        "active": "Otsin põhjendust…",
-        "show": "Näita põhjendust",
-        "hide": "Peida põhjendus"
-    },
-    "thinking": {
-        "toggle": "Näita mõtlemise olekut või peida see"
-    }
+    "similarity_score": "Sarnasus"
 }

web/public/locales/et/views/classificationModel.json

@@ -43,8 +43,5 @@
   },
   "tooltip": {
     "trainingInProgress": "Mudel on parasjagu õppimas"
-  },
-  "train": {
-    "titleShort": "Hiljutised"
   }
 }

web/public/locales/et/views/explore.json

@@ -5,8 +5,7 @@
   "noTrackedObjects": "Ühtegi jälgitavat objekti ei leidunud",
   "itemMenu": {
     "findSimilar": {
-      "aria": "Otsi sarnaseid jälgitavaid objekte",
-      "label": "Leia sarnane"
+      "aria": "Otsi sarnaseid jälgitavaid objekte"
     },
     "downloadSnapshot": {
       "label": "Laadi hetkvõte alla",
@@ -15,14 +14,6 @@
     "downloadCleanSnapshot": {
       "label": "Laadi puhas hetkvõte alla",
       "aria": "Laadi puhas hetkvõte alla"
-    },
-    "viewTrackingDetails": {
-      "label": "Vaata jälgimise üksikasju",
-      "aria": "Näita jälgimise üksikasju"
-    },
-    "downloadVideo": {
-      "label": "Laadi video alla",
-      "aria": "Laadi video alla"
     }
   },
   "trackingDetails": {
@@ -30,22 +21,11 @@
       "showAllZones": {
         "title": "Näita kõiki tsoone",
         "desc": "Kui objekt on sisenenud tsooni, siis alati näida tsooni märgistust."
-      },
-      "title": "Annotatsioonide seaded",
-      "offset": {
-        "desc": "Need andmed pärinevad teie kaamera tuvastusvoost, kuid on salvestusvoo piltide peal. On ebatõenäoline, et need kaks voogu on ideaalselt sünkroonis. Seetõttu ei joondu piirav kast ja kaader ideaalselt. Selle säte abil saad annotatsioone ajas edasi või tagasi nihutada, et need salvestatud kaadriga paremini joonduks.",
-        "millisecondsToOffset": "Millisekundid annotatsioonide tuvastuse nihutamiseks. <em>Vaikimisi: 0</em>",
-        "tips": "Vähendage väärtust, kui video taasesitus on kastidest ja teekonnapunktidest ees, ning suurendage väärtust, kui video taasesitus on neist maas. See väärtus võib olla negatiivne.",
-        "toast": {
-          "success": "Kaamera '{{camera}}' annotatsiooni nihe on konfiguratsioonifaili salvestatud."
-        },
-        "label": "Annotatsiooni nihe"
       }
     },
     "lifecycleItemDesc": {
       "attribute": {
-        "other": "{{label}} on tuvastatud kui {{attribute}}",
-        "faceOrLicense_plate": "{{attribute}} tuvastatud objektil {{label}}"
+        "other": "{{label}} on tuvastatud kui {{attribute}}"
       },
       "stationary": "{{label}} jäi paigale",
       "active": "{{label}} muutus aktiivseks",
@@ -57,8 +37,7 @@
         "area": "Ala",
         "score": "Punktiskoor",
         "computedScore": "Arvutatud punktiskoor",
-        "topScore": "Suuremad punktiskoorid",
-        "toggleAdvancedScores": "Täpsemate tulemuste sisse-/väljalülitamine"
+        "topScore": "Suuremad punktiskoorid"
       },
       "external": "{{label}} on tuvastatud",
       "heard": "{{label}} on kuuldud",
@@ -71,11 +50,7 @@
       "previous": "Eelmine slaid",
       "next": "Järgmine slaid"
     },
-    "count": "{{first}} / {{second}}",
-    "adjustAnnotationSettings": "Korrigeeri annotatsioonide seadeid",
-    "scrollViewTips": "Klõpsake selle objekti elutsükli oluliste hetkede vaatamiseks.",
-    "autoTrackingTips": "Piirdekastide asukohad on automaatselt jälgivate kaamerate puhul ebatäpsed.",
-    "trackedPoint": "Jälgitav punkt"
+    "count": "{{first}} / {{second}}"
   },
   "documentTitle": "Avasta - Frigate",
   "generativeAI": "Generatiivne tehisaru",
@@ -89,22 +64,7 @@
       },
       "startingUp": "Käivitun…",
       "estimatedTime": "Hinnanguliselt jäänud aega:",
-      "finishingShortly": "Lõpetan õige pea",
-      "context": "Avastamist saab kasutada pärast seda, kui jälgitavate objektide manustamine on uuesti indekseerimise lõpetanud."
-    },
-    "title": "Avastamine pole saadaval",
-    "downloadingModels": {
-      "context": "Frigate laadib alla semantilise otsingu funktsiooni toetamiseks vajalikke manustamismudeleid. See võib võtta mitu minutit, olenevalt teie võrguühenduse kiirusest.",
-      "setup": {
-        "visionModel": "Nägemismudel",
-        "visionModelFeatureExtractor": "Nägemismudeli tunnuste eraldaja",
-        "textModel": "Tekstimudel",
-        "textTokenizer": "Teksti tokenisaator"
-      },
-      "tips": {
-        "context": "Pärast mudelite allalaadimist tuleks oma jälgitavate objektide manused uuesti indekseerida."
-      },
-      "error": "Tekkis viga. Kontrollige Frigate'i logisid."
+      "finishingShortly": "Lõpetan õige pea"
     }
   },
   "type": {
@@ -147,52 +107,8 @@
     },
     "recognizedLicensePlate": "Tuvastatud sõiduki numbrimärk",
     "description": {
-      "aiTips": "Frigate ei küsi sinu generatiivse tehisaru teenusepakkujalt kirjeldust enne, kui jälgitava objekti elutsükkel on lõppenud.",
-      "label": "Kirjeldus",
-      "placeholder": "Jälgitava objekti kirjeldus"
-    },
-    "label": "Silt",
-    "editSubLabel": {
-      "title": "Muuda alamsilti",
-      "desc": "Sisesta sildile '{{label}}' uus alamsilt",
-      "descNoLabel": "Sisesta sellele jälgitavale objektile uus alamsilt"
-    },
-    "camera": "Kaamera",
-    "zones": "Tsoonid",
-    "title": {
-      "label": "Pealkiri"
-    },
-    "button": {
-      "findSimilar": "Leia sarnane",
-      "regenerate": {
-        "title": "Taasloomine",
-        "label": "Jälgitava objekti kirjelduse uuesti genereerimine"
-      }
-    },
-    "topScore": {
-      "label": "Parim punktiskoor",
-      "info": "Kõrgeim skoor on jälgitava objekti kõrgeim mediaanskoor, seega võib see erineda otsingutulemuste pisipildil kuvatavast skoorist."
-    },
-    "objects": "Objektid",
-    "tips": {
-      "descriptionSaved": "Kirjeldus salvestati edukalt",
-      "saveDescriptionFailed": "Kirjelduse uuendamine ebaõnnestus: {{errorMessage}}"
-    },
-    "attributes": "Klassifikatsiooni atribuudid",
-    "estimatedSpeed": "Hinnanguline kiirus",
-    "editAttributes": {
-      "title": "Atribuutide muutmine",
-      "desc": "Valige selle sildi '{{label}}' jaoks klassifikatsiooniatribuudid"
+      "aiTips": "Frigate ei küsi sinu generatiivse tehisaru teenusepakkujalt kirjeldust enne, kui jälgitava objekti elutsükkel on lõppenud."
     }
   },
-  "trackedObjectDetails": "Jälgitava objekti üksikasjad",
-  "aiAnalysis": {
-    "title": "Tehisintellekti analüüs"
-  },
-  "concerns": {
-    "label": "Mured"
-  },
-  "objectLifecycle": {
-    "noImageFound": "Selle jälgitava objekti kohta ei leitud pilti."
-  }
+  "trackedObjectDetails": "Jälgitava objekti üksikasjad"
 }

web/public/locales/et/views/exports.json

@@ -16,15 +16,12 @@
     "downloadVideo": "Laadi video alla",
     "editName": "Muuda nime",
     "deleteExport": "Kustuta eksporditud sisu",
-    "assignToCase": "Lisa juhtumile",
-    "removeFromCase": "Eemalda juhtumist"
+    "assignToCase": "Lisa juhtumile"
   },
   "toast": {
     "error": {
       "renameExportFailed": "Eksporditud sisu nime muutmine ei õnnestunud: {{errorMessage}}",
-      "assignCaseFailed": "Juhtumiga seose uuendamine ei õnnestunud: {{errorMessage}}",
-      "caseSaveFailed": "Juhtumi salvestamine ei õnnestunud: {{errorMessage}}",
-      "caseDeleteFailed": "Juhtumi kustutamine ei õnnestunud: {{errorMessage}}"
+      "assignCaseFailed": "Juhtumiga seose uuendamine ei õnnestunud: {{errorMessage}}"
     }
   },
   "headings": {
@@ -38,44 +35,5 @@
     "nameLabel": "Juhtumi nimi",
     "descriptionLabel": "Kirjeldus",
     "description": "Vali olemasolev juhtum või lisa uus."
-  },
-  "toolbar": {
-    "newCase": "Uus juhtum",
-    "addExport": "Lisa eksportimiseks",
-    "editCase": "Muuda juhtumit",
-    "deleteCase": "Kustuta juhtum"
-  },
-  "deleteCase": {
-    "label": "Kustuta juhtum",
-    "desc": "Kas oled kindel, et soovid „{{caseName}}“ juhtumi kustutada?"
-  },
-  "caseCard": {
-    "emptyCase": "Eksportimise veel pole"
-  },
-  "jobCard": {
-    "defaultName": "Eksportimine kaamerast „{{camera}}“",
-    "queued": "Lisatud järjekorda",
-    "running": "Töös",
-    "preparing": "Ettevalmistamisel",
-    "copying": "Kopeerimisel",
-    "encoding": "Kodeerimisel",
-    "encodingRetry": "Kodeerimisel (uuesti)",
-    "finalizing": "Lõpetamisel"
-  },
-  "caseView": {
-    "noDescription": "Kirjeldust pole",
-    "createdAt": "Loodud {{value}}",
-    "exportCount_one": "1 eksportimine",
-    "exportCount_other": "{{count}} eksportimist",
-    "cameraCount_one": "1 kaamera",
-    "cameraCount_other": "{{count}} kaamerat",
-    "showMore": "Näita rohkem",
-    "showLess": "Näita vähem",
-    "emptyTitle": "See juhtum on tühi"
-  },
-  "caseEditor": {
-    "namePlaceholder": "Juhtumi nimi",
-    "editTitle": "Muuda juhtumit",
-    "createTitle": "Lisa juhtum"
   }
 }

web/public/locales/et/views/faceLibrary.json

@@ -1,11 +1,6 @@
 {
   "button": {
-    "uploadImage": "Laadi pilt üles",
-    "deleteFaceAttempts": "Kustuta näod",
-    "addFace": "Lisa nägu",
-    "renameFace": "Nimeta nägu ümber",
-    "deleteFace": "Kustuta nägu",
-    "reprocessFace": "Käivita näotuvastus uuesti"
+    "uploadImage": "Laadi pilt üles"
   },
   "collections": "Kogumikud",
   "description": {
@@ -16,41 +11,28 @@
   },
   "documentTitle": "Näoteek - Frigate",
   "createFaceLibrary": {
-    "new": "Lisa uus nägu",
-    "nextSteps": "Tugeva tuvastusaluse loomiseks:<li>Kasuta vahekaarti \"Hiljutised tuvastused\", et valida pilte ja treenida isikutuvastust.</li><li>Parima tulemuse saavutamiseks keskendu otsepiltidele; väldi nurga all olevaid nägusid treenimiseks.</li></ul>"
+    "new": "Lisa uus nägu"
   },
   "deleteFaceLibrary": {
-    "title": "Kustuta nimi",
-    "desc": "Kas oled kindel, et soovid isiku '{{name}}' kollektsiooni kustutada? See kustutab jäädavalt kõik seotud näod."
+    "title": "Kustuta nimi"
   },
   "toast": {
     "error": {
       "addFaceLibraryFailed": "Näo sidumine nimega ei õnnestunud: {{errorMessage}}",
-      "updateFaceScoreFailed": "Näo punktiskoori uuendamine ei õnnestunud: {{errorMessage}}",
-      "uploadingImageFailed": "Pildi üleslaadimine ebaõnnestus: {{errorMessage}}",
-      "deleteFaceFailed": "Kustutamine ebaõnnestus: {{errorMessage}}",
-      "deleteNameFailed": "Nime kustutamine ebaõnnestus: {{errorMessage}}",
-      "renameFaceFailed": "Näo ümbernimetamine ebaõnnestus: {{errorMessage}}",
-      "trainFailed": "Treenimine ebaõnnestus: {{errorMessage}}",
-      "reclassifyFailed": "Näo ümberklassifitseerimine ebaõnnestus: {{errorMessage}}"
+      "updateFaceScoreFailed": "Näo punktiskoori uuendamine ei õnnestunud: {{errorMessage}}"
     },
     "success": {
-      "addFaceLibrary": "Lisamine nägude kogusse õnnestus: {{name}}!",
+      "addFaceLibrary": "Lisamine Näoteeki õnnestus: {{name}}!",
       "deletedFace_one": "{{count}} näo kustutamine õnnestus.",
       "deletedFace_other": "{{count}} näo kustutamine õnnestus.",
       "deletedName_one": "{{count}} näo kustutamine õnnestus.",
       "deletedName_other": "{{count}} näo kustutamine õnnestus.",
-      "updatedFaceScore": "Näo punktiskoori uuendamine õnnestus: {{name}} ({{score}}).",
-      "uploadedImage": "Pildi üleslaadimine õnnestus.",
-      "renamedFace": "Näo ümbernimetamine õnnestus, uus nimi on {{name}}",
-      "trainedFace": "Edukalt treenitud nägu.",
-      "reclassifiedFace": "Näo ümberklassifitseerimine õnnestus."
+      "updatedFaceScore": "Näo punktiskoori uuendamine õnnestus: {{name}} ({{score}})."
     }
   },
   "deleteFaceAttempts": {
     "desc_one": "Kas oled kindel, et soovid kustutada {{count}} näo? Seda tegevust ei saa tagasi pöörata.",
-    "desc_other": "Kas oled kindel, et soovid kustutada {{count}} nägu? Seda tegevust ei saa tagasi pöörata.",
-    "title": "Kustuta näod"
+    "desc_other": "Kas oled kindel, et soovid kustutada {{count}} nägu? Seda tegevust ei saa tagasi pöörata."
   },
   "details": {
     "timestamp": "Ajatampel",
@@ -60,40 +42,5 @@
   "uploadFaceImage": {
     "title": "Laadi näopilt üles",
     "desc": "Laadi üles pilt, et otsida sellelt nägusid ja lisada see {{pageToggle}}'i jaoks"
-  },
-  "steps": {
-    "faceName": "Lisa näole nimi",
-    "uploadFace": "Lae näopilt üles",
-    "nextSteps": "Järgmised sammud",
-    "description": {
-      "uploadFace": "Laadi üles pilt isikust '{{name}}', mis näitab tema nägu eestvaates. Ainult nägu ei pea pildilt välja lõikama."
-    }
-  },
-  "train": {
-    "title": "Hiljutised tuvastamised",
-    "titleShort": "Hiljutised",
-    "aria": "Vali hiljutised tuvastamised",
-    "empty": "Hiljutisi näotuvastuse katseid pole",
-    "emptyNoLibrary": {
-      "title": "Laadi üles nägu",
-      "description": "Näotuvastuse toimimiseks peate lisama vähemalt ühe näo kogusse."
-    }
-  },
-  "renameFace": {
-    "title": "Nimeta nägu ümber",
-    "desc": "Sisesta uus nimi isiku '{{name}}' jaoks"
-  },
-  "imageEntry": {
-    "validation": {
-      "selectImage": "Palun vali pildifail."
-    },
-    "dropActive": "Lohista pilt siia…",
-    "dropInstructions": "Lohistage või kleepige pilt siia või klõpsake valimiseks",
-    "maxSize": "Maksimum suurus: {{size}}MB"
-  },
-  "nofaces": "Nägusid pole saadaval",
-  "trainFaceAs": "Treeni nägu kui:",
-  "trainFace": "Treeni nägu",
-  "reclassifyFaceAs": "Liigita nägu ümber järgmiselt:",
-  "reclassifyFace": "Näo ümberklassifitseerimine"
+  }
 }

web/public/locales/et/views/motionSearch.json

@@ -1,78 +1,4 @@
 {
     "documentTitle": "Liikumise tuvastus - Frigate",
-    "title": "Liikumise otsing",
-    "cancelSearch": "Tühista",
-    "startSearch": "Alusta otsingut",
-    "selectCamera": "Liikumisotsingut laaditakse",
-    "description": "Joonesta hulknurk, et määratleda huvipakkuv piirkond, ja määra ajavahemik, mille jooksul otsida liikumise muutusi selles piirkonnas.",
-    "searchStarted": "Otsing alustatud",
-    "searchCancelled": "Otsing tühistatud",
-    "searching": "Otsing on pooleli.",
-    "searchComplete": "Otsing lõpetatud",
-    "noResultsYet": "Käivita otsing valitud piirkonnas liikumise muutuste leidmiseks",
-    "noChangesFound": "Valitud piirkonnas ei tuvastatud pikslimuutusi",
-    "results": "Tulemused",
-    "polygonControls": {
-        "drawMode": "Joonista",
-        "moveMode": "Liiguta",
-        "reset": "Lähtesta hulknurk",
-        "undo": "Tühista viimane punkt",
-        "points_one": "{{count}} punkt",
-        "points_other": "{{count}} punkti"
-    },
-    "newSearch": "Uus otsing",
-    "clearResults": "Tühista tulemused",
-    "clearROI": "Tühista hulknurk",
-    "dialog": {
-        "cameraLabel": "Kaamera",
-        "title": "Liikumisotsing",
-        "previewAlt": "Kaamera '{{camera}}' eelvaade"
-    },
-    "timeRange": {
-        "title": "Otsinguvahemik",
-        "start": "Algusaeg",
-        "end": "Lõppaeg"
-    },
-    "settings": {
-        "title": "Otsinguseaded",
-        "parallelMode": "Paralleelrežiim",
-        "parallelModeDesc": "Skanni mitut salvestusvahemikku korraga (kiirem; kasutab rohkem dekodeerimisressursse)",
-        "threshold": "Tundlikkuse lävi",
-        "thresholdDesc": "Väiksemad väärtused tuvastavad väiksemaid muutusi (1–255)",
-        "minArea": "Minimaalne muutusala",
-        "minAreaDesc": "Ühe liikuva piirkonna minimaalne suurus protsentides huvipakkuvast piirkonnast",
-        "maxResults": "Maksimaalselt tulemusi",
-        "maxResultsDesc": "Peata pärast nii paljude ajatemplite sobivust"
-    },
-    "errors": {
-        "noCamera": "Palun vali kaamera",
-        "noROI": "Palun joonistage huvipakkuv piirkond",
-        "noTimeRange": "Palun valige ajavahemik",
-        "invalidTimeRange": "Lõppaeg peab olema pärast algusaega",
-        "searchFailed": "Otsing ebaõnnestus: {{message}}",
-        "polygonTooSmall": "Hulknurgal peab olema vähemalt 3 punkti",
-        "unknown": "Tundmatu viga"
-    },
-    "changePercentage": "{{percentage}}% muutus",
-    "metrics": {
-        "title": "Otsingumõõdikud",
-        "segmentsScanned": "Skannitud segmente",
-        "segmentsProcessed": "Töödeldud",
-        "segmentsSkippedInactive": "Vahele jäetud (tegevust pole)",
-        "segmentsSkippedHeatmap": "Vahele jäetud (kattuvaid piirkondi pole)",
-        "fallbackFullRange": "Varurežiimis täisulatusega skaneerimine",
-        "framesDecoded": "Kaadreid dekodeeritud",
-        "wallTime": "Otsingu aeg",
-        "seconds": "{{seconds}}s",
-        "minutesSeconds": "{{minutes}}m {{seconds}}s",
-        "segmentErrors": "Segmendi vead",
-        "scanSummary": "{{segments}} segmenti · {{time}}"
-    },
-    "jumpToTime": "Hüppa sellele ajale",
-    "framesProcessed": "{{count}} kaadrit töödeldud",
-    "changesFound_one": "Tuvastatud {{count}} liikumine",
-    "changesFound_other": "Tuvastatud {{count}} liikumist",
-    "motionHeatmapLabel": "Liikumise soojakaart",
-    "showSegmentHeatmap": "Soojakaart",
-    "scanning": "Skannimine {{time}}"
+    "title": "Liikumise otsing"
 }

web/public/locales/et/views/replay.json

@@ -12,48 +12,7 @@
         "selectFromTimeline": "Vali",
         "starting": "Käivitan kordust…",
         "startLabel": "Algus",
-        "endLabel": "Lõpp",
-        "title": "Alusta silumise taasesitust",
-        "description": "Looge ajutine taasesituskaamera, mis kordab ajaloolist salvestist objektide tuvastamise ja jälgimise probleemide silumiseks. Taasesituskaameral on sama tuvastusseadistus mis lähtekaameral. Valige algusaeg.",
-        "toast": {
-            "error": "Silumise taasesitus ebaõnnestus: {{error}}",
-            "alreadyActive": "Kordusseanss on juba aktiivne",
-            "stopError": "Silumise taasesituse peatamine ebaõnnestus: {{error}}",
-            "goToReplay": "Mine kordusesse"
-        }
+        "endLabel": "Lõpp"
     },
-    "title": "Kordus veaotsinguks",
-    "websocket_messages": "Sõnumid",
-    "description": "Mängi kaamera salvestisi veaotsinguks. Objektide loend näitab tuvastatud objektide ajalist viivitust ja vahekaart „Sõnumid” näitab Fregati sisemiste sõnumite voogu taasesituse materjalist.",
-    "page": {
-        "noSession": "Aktiivset silumis- ja taasesitusseanssi pole",
-        "noSessionDesc": "Alusta silumissalvestise taasesitust ajaloo vaates, klõpsates tööriistaribal nupul \"Toimingud\" ja valides silumissalvestise taasesituse.",
-        "goToRecordings": "Mine ajaloo vaatesse",
-        "preparingClip": "Klipi ettevalmistamine…",
-        "preparingClipDesc": "Frigate koondab valitud ajavahemiku salvestisi. Pikemate vahemike puhul võib see võtta kauem.",
-        "startingCamera": "Silumise taasesituse käivitamine…",
-        "startError": {
-            "title": "Silumise taasesituse käivitamine ebaõnnestus",
-            "back": "Tagasi ajaloo vaatesse"
-        },
-        "sourceCamera": "Lähtekaamera",
-        "replayCamera": "Taasesituse kaamera",
-        "initializingReplay": "Silumise taasesituse initsialiseerimine...",
-        "stoppingReplay": "Silumise taasesituse peatamine...",
-        "stopReplay": "Peata kordusesitus",
-        "confirmStop": {
-            "title": "Peata silumise kordusesitus?",
-            "description": "See peatab seansi ja kustutab kõik ajutised andmed. Kas oled kindel?",
-            "confirm": "Peata kordusesitus",
-            "cancel": "Tühista"
-        },
-        "activity": "Toimingud",
-        "objects": "Objekti loend",
-        "audioDetections": "Audio tuvastused",
-        "noActivity": "Ühtegi tegevust ei tuvastatud",
-        "activeTracking": "Aktiivne jälgimine",
-        "noActiveTracking": "Aktiivset jälgimist pole",
-        "configuration": "Seaded",
-        "configurationDesc": "Peenhäälesta liikumistuvastuse ja objektide jälgimise sätteid silumis- ja taasesituskaamera jaoks. Frigate'i konfiguratsiooni faili muudatusi ei salvestata."
-    }
+    "title": "Kordus veaotsinguks"
 }

web/public/locales/et/views/settings.json

@@ -7,28 +7,7 @@
       "connectionSettings": "Ühenduse seadistused",
       "port": "Port",
       "username": "Kasutajanimi",
-      "usernamePlaceholder": "Valikuline",
-      "cameraName": "Kaamera nimi",
-      "cameraNamePlaceholder": "näiteks: eesmine_uks või Hoovi ülevaade",
-      "host": "Host/IP-aadress",
-      "cameraBrand": "Kaamera bränd",
-      "selectBrand": "Vali URL malli jaoks kaamera bränd",
-      "customUrl": "Kohandatud voo URL",
-      "brandInformation": "Brändi teave",
-      "brandUrlFormat": "Kaamerate puhul, mille RTSP URL-i vorming on järgmine: {{exampleUrl}}",
-      "selectTransport": "Valige transpordiprotokoll",
-      "description": "Sisestage oma kaamera andmed ja valige, kas soovite kaamerat tuvastada või valida tootja käsitsi.",
-      "onvifPort": "ONVIF port",
-      "probeMode": "Tuvasta kaamera",
-      "manualMode": "Manuaalne valik",
-      "errors": {
-        "nameRequired": "Kaamera nimi on kohustuslik",
-        "nameLength": "Kaamera nimi peab olema kuni 64 tähemärki pikk",
-        "invalidCharacters": "Kaamera nimi sisaldab sobimatuid märke",
-        "nameExists": "Kaamera nimi on juba olemas",
-        "brandOrCustomUrlRequired": "Valige kas kaamera bränd koos hosti/IP-aadressiga või valige „Muu” kohandatud URL-iga"
-      },
-      "detectionMethod": "Vootuvastus meetod"
+      "usernamePlaceholder": "Valikuline"
     },
     "step3": {
       "streamUrlPlaceholder": "rtsp://kasutajanimi:salasõna@host:port/asukoht",
@@ -38,37 +17,17 @@
       "roles": "Rollid",
       "roleLabels": {
         "record": "Salvestamine",
-        "audio": "Heliriba",
-        "detect": "Objektituvastus"
+        "audio": "Heliriba"
       },
       "connected": "Ühendatud",
-      "featuresTitle": "Funktsionaalsused",
-      "selectStream": "Vali voog",
-      "selectQuality": "Valige kvaliteet",
-      "notConnected": "Pole ühendatud",
-      "testFailedTitle": "Test ebaõnnestus",
-      "testStream": "Testi ühendust",
-      "testSuccess": "Voo test edukas!",
-      "testFailed": "Voo test ebaõnnestus",
-      "selectResolution": "Vali resolutsioon",
-      "noStreamFound": "Voogu ei leitud",
-      "addAnotherStream": "Lisa järgmine voog",
-      "streamTitle": "Voog {{number}}",
-      "streamUrl": "Voo URL",
-      "addStream": "Lisa voog",
-      "description": "Seadista voogedastusrolle ja lisa oma kaamerale täiendavaid vooge.",
-      "streamsTitle": "Kaamera vood"
+      "featuresTitle": "Funktsionaalsused"
     },
     "steps": {
-      "probeOrSnapshot": "Võta proov või tee hetkvõte",
-      "nameAndConnection": "Nimi ja ühendus",
-      "streamConfiguration": "Voo seaded",
-      "validationAndTesting": "Valideerimine ja testimine"
+      "probeOrSnapshot": "Võta proov või tee hetkvõte"
     },
     "step2": {
       "testing": {
-        "fetchingSnapshot": "Laadin kaamera hetkvõtet alla...",
-        "probingMetadata": "Tuvastan kaamera metaandmeid..."
+        "fetchingSnapshot": "Laadin kaamera hetkvõtet alla..."
       },
       "retry": "Proovi uuesti",
       "manufacturer": "Tootja",
@@ -78,30 +37,7 @@
       "presets": "Eelseadistused",
       "useCandidate": "Kasuta",
       "uriCopy": "Kopeeri",
-      "connected": "Ühendatud",
-      "testSuccess": "Ühenduse test õnnestus!",
-      "testFailed": "Ühenduse test ebaõnnestus. Palun kontrollige sisestatud andmeid ja proovige uuesti.",
-      "testFailedTitle": "Test ebaõnnestus",
-      "streamDetails": "Voo üksikasjad",
-      "probing": "Tuvastan kaamerat...",
-      "ptzSupport": "PTZ tugi",
-      "testConnection": "Testi ühendust",
-      "toggleUriView": "Klõpsake täieliku URI vaate sisse/välja lülitamiseks",
-      "notConnected": "Pole ühendatud",
-      "errors": {
-        "hostRequired": "Hosti/IP-aadress on kohustuslik"
-      },
-      "candidateStreamTitle": "Kandidaat {{number}}",
-      "probeSuccessful": "Tuvastamine õnnestus",
-      "probeError": "Tuvastamise viga",
-      "probeNoSuccess": "Tuvastamine ebaõnnestus",
-      "deviceInfo": "Seadme info",
-      "autotrackingSupport": "Automaatse jälgimise tugi",
-      "uriCopied": "URI kopeeriti lõikelauale",
-      "rtspCandidates": "RTSP kandidaadid",
-      "probingDevice": "Tuvastan seadet...",
-      "description": "Tuvasta kaamera vooge või seadista käsitsi seaded vastavalt valitud tuvastusmeetodile.",
-      "probeFailed": "Kaamera tuvastamine ebaõnnestus: {{error}}"
+      "connected": "Ühendatud"
     },
     "testResultLabels": {
       "resolution": "Resolutsioon",
@@ -120,17 +56,7 @@
       "roles": "Rollid",
       "none": "Määramata",
       "error": "Viga"
-    },
-    "commonErrors": {
-      "noUrl": "Palun sisestage kehtiv voogesituse URL",
-      "testFailed": "Voo test ebaõnnestus: {{error}}"
-    },
-    "save": {
-      "success": "Uue kaamera '{{cameraName}}' salvestamine õnnestus.",
-      "failure": "Viga kaamera '{{cameraName}}' salvestamisel."
-    },
-    "title": "Lisa kaamera",
-    "description": "Uue kaamera lisamiseks oma Frigate paigaldisesse järgige alltoodud samme."
+    }
   },
   "users": {
     "updatePassword": "Lähtesta salasõna",
@@ -246,32 +172,24 @@
   },
   "documentTitle": {
     "default": "Seadistused - Frigate",
-    "authentication": "Autentimise seaded - Frigate",
-    "cameraReview": "Kaamerate kordusvaatuste seaded - Frigate",
-    "general": "Profiili seaded - Frigate",
-    "frigatePlus": "Frigate+ seaded - Frigate",
-    "notifications": "Teavituste seaded - Frigate",
+    "authentication": "Autentimise seadistused - Frigate",
+    "cameraReview": "Kaamerate kordusvaatuste seadistused - Frigate",
+    "general": "Profiili seadistused - Frigate",
+    "frigatePlus": "Frigate+ seadistused - Frigate",
+    "notifications": "Teavituste seadistused - Frigate",
     "cameraManagement": "Kaamerate haldus - Frigate",
     "masksAndZones": "Maskide ja tsoonide haldus - Frigate",
-    "object": "Silumine ja veaotsing - Frigate",
-    "enrichments": "Rikastamise seaded - Frigate",
-    "motionTuner": "Liikumise häälestaja – Frigate",
-    "globalConfig": "Globaalsed seaded – Frigate",
-    "cameraConfig": "Kaamera seaded - Frigate",
-    "detectorsAndModel": "Detektorid ja mudel – Frigate",
-    "maintenance": "Hooldus – Frigate",
-    "profiles": "Profiilid - Frigate"
+    "object": "Silumine ja veaotsing - Frigate"
   },
   "general": {
-    "title": "Kasutajaliidese seadistused",
+    "title": "Profiili seadistused",
     "cameraGroupStreaming": {
       "clearAll": "Kustuta kõik voogedastuse seadistused"
     },
     "liveDashboard": {
       "title": "Töölaud reaalajas",
       "automaticLiveView": {
-        "label": "Automaatne otseülekande vaade",
-        "desc": "Aktiveerib automaatselt kaamera reaalajas vaate, kui tuvastatakse tegevus. Selle valiku keelamisel uuendatakse kaamerapilti töölaual ainult üks kord minutis."
+        "label": "Automaatne otseülekande vaade"
       }
     },
     "calendar": {
@@ -417,7 +335,7 @@
   },
   "menu": {
     "ui": "Kasutajaliides",
-    "cameraManagement": "Kaamera haldus",
+    "cameraManagement": "Haldus",
     "masksAndZones": "Maskid ja tsoonid",
     "triggers": "Päästikud",
     "debug": "Silumine ja veaotsing",
@@ -455,37 +373,7 @@
     "systemMqtt": "MQTT",
     "systemGo2rtcStreams": "go2rtc voogedastus",
     "integrationSemanticSearch": "Semantiline otsing",
-    "integrationGenerativeAi": "Generatiivne tehisaru",
-    "general": "Üldine",
-    "globalConfig": "Globaalsed seaded",
-    "system": "Süsteem",
-    "integrations": "Integratsioonid",
-    "cameras": "Kaamera seaded",
-    "integrationFaceRecognition": "Nöotuvastus",
-    "cameraDetect": "Objektituvastus",
-    "cameraFfmpeg": "Vood (FFmpeg)",
-    "cameraRecording": "Salvestus",
-    "cameraSnapshots": "Hetktõmmised",
-    "cameraMotion": "Liikumistuvastus",
-    "cameraObjects": "Objektid",
-    "cameraConfigReview": "Ülevaade",
-    "cameraAudioEvents": "audiotuvastus",
-    "cameraAudioTranscription": "Audio transkriptsioon",
-    "cameraNotifications": "Teated",
-    "cameraLivePlayback": "Otseülekanne",
-    "integrationAudioTranscription": "Audio transkriptsioon",
-    "integrationObjectClassification": "Objektide klassifitseerimine",
-    "cameraFaceRecognition": "Näotuvastus",
-    "cameraMqttConfig": "MQTT",
-    "cameraOnvif": "ONVIF",
-    "cameraUi": "Kaamera kasutajaliides",
-    "cameraTimestampStyle": "Ajatempli stiil",
-    "cameraMqtt": "Kaamera MQTT",
-    "maintenance": "Hooldus",
-    "mediaSync": "Meedia sünkroonimine",
-    "regionGrid": "Regioonide ruudustik",
-    "enrichments": "Andmete rikastamine",
-    "motionTuner": "Liikumistuvastuse seadistaja"
+    "integrationGenerativeAi": "Generatiivne tehisaru"
   },
   "dialog": {
     "unsavedChanges": {
@@ -501,11 +389,7 @@
     "semanticSearch": {
       "reindexNow": {
         "confirmButton": "Indekseeri uuesti",
-        "label": "Indekseeri kohe uuesti",
-        "alreadyInProgress": "Ümberindekseerimine on juba käimas.",
-        "error": "Uuesti indekseerimise alustamine ebaõnnestus: {{errorMessage}}",
-        "success": "Ümberindekseerimine algas edukalt.",
-        "confirmTitle": "Kinnita uuesti indekseerimine"
+        "label": "Indekseeri uuesti kohe"
       },
       "modelSize": {
         "small": {
@@ -513,9 +397,7 @@
         },
         "large": {
           "title": "suur"
-        },
-        "label": "Mudeli suurus",
-        "desc": "Semantilise otsingu manustamiseks kasutatava mudeli suurus."
+        }
       },
       "title": "Semantiline otsing"
     },
@@ -526,23 +408,14 @@
         },
         "large": {
           "title": "suur"
-        },
-        "label": "Mudeli suurus",
-        "desc": "Näotuvastuseks kasutatava mudeli suurus."
-      },
-      "title": "Näotuvastus"
+        }
+      }
     },
     "birdClassification": {
       "title": "Lindude klassifikatsioon"
     },
     "licensePlateRecognition": {
       "title": "Sõidukite numbrimärkide tuvastus"
-    },
-    "title": "Andmerikastuse seaded",
-    "restart_required": "Taaskäivitamine on vajalik (Andmerikastuse seadeid on muudetud)",
-    "toast": {
-      "success": "Andmerikastamise seaded on salvestatud. Muudatuste rakendamiseks taaskäivitage Frigate.",
-      "error": "Seadete muudatuste salvestamine ebaõnnestus: {{errorMessage}}"
     }
   },
   "cameraReview": {
@@ -624,31 +497,5 @@
     "lpr": {
       "vehicleNotTracked": "Sõidukite numbrimärkide tuvastus eeldab, et auto või mootorratas on jälgitav. Lülita menüüst Objektid sell kaamera jaoks sisse valikud „auto“ või „mootorratas“."
     }
-  },
-  "button": {
-    "overriddenGlobal": "Ülekirjutatud (Globaalne)",
-    "overriddenGlobalTooltip": "Käesolev kaamera kirjutab selles jaotises üle globaalsed seaded",
-    "overriddenGlobalHeading_one": "See kaamera sürjutab {{count}} üldise seadistuse välja:",
-    "overriddenGlobalHeading_other": "See kaamera sürjutab {{count}} üldise seadistuse välja:"
-  },
-  "saveAllPreview": {
-    "title": "Salvestatavad muudatused",
-    "triggerLabel": "Vaadake üle ootel olevad muudatused",
-    "empty": "Ootel muudatusi pole.",
-    "scope": {
-      "label": "Ulatus",
-      "global": "Globaalne",
-      "camera": "Kaamera: {{cameraName}}"
-    },
-    "profile": {
-      "label": "Profiil"
-    },
-    "field": {
-      "label": "Väli"
-    },
-    "value": {
-      "label": "Uus väärtus",
-      "reset": "Lähtesta"
-    }
   }
 }

web/public/locales/et/views/system.json

@@ -2,14 +2,7 @@
   "documentTitle": {
     "general": "Üldine statistika - Frigate",
     "cameras": "Kaamerate statistika - Frigate",
-    "storage": "Andmeruumi statistika - Frigate",
-    "logs": {
-      "frigate": "Frigate logid - Frigate",
-      "go2rtc": "Go2RTC logid - Frigate",
-      "nginx": "Nginx logid - Frigate",
-      "websocket": "Sõnumite logid - Frigate"
-    },
-    "enrichments": "Rikastus statistika - Frigate"
+    "storage": "Andmeruumi statistika - Frigate"
   },
   "logs": {
     "download": {
@@ -23,29 +16,11 @@
     "websocket": {
       "filter": {
         "cameras_count_one": "{{count}} kaamera",
-        "cameras_count_other": "{{count}} kaamerat",
-        "camera": "Kaamera",
-        "all_cameras": "Kõik kaamerad",
-        "events": "Sündmused",
-        "reviews": "Ülevaated",
-        "system": "Süsteem",
-        "topics": "Teemad",
-        "all": "Kõik teemad",
-        "face_recognition": "Näotuvastus",
-        "classification": "Klassifikatsioon",
-        "camera_activity": "Kaamera aktiivsus",
-        "lpr": "Numbrimärgituvastus"
+        "cameras_count_other": "{{count}} kaamerat"
       },
       "empty": "Ühtegi sõnumit pole veel hõivatud",
       "count_one": "{{count}} sõnum",
-      "count_other": "{{count}} sõnumit",
-      "pause": "Peata",
-      "resume": "Jätka",
-      "label": "Sõnumid",
-      "clear": "Tühista",
-      "expanded": {
-        "payload": "Last"
-      }
+      "count_other": "{{count}} sõnumit"
     },
     "type": {
       "label": "Tüüp",
@@ -61,170 +36,5 @@
       }
     }
   },
-  "title": "Süsteem",
-  "enrichments": {
-    "embeddings": {
-      "object_description_events_per_second": "Objekti kirjeldus",
-      "face_recognition": "Näotuvastus",
-      "plate_recognition": "Numbrimärgi tuvastus",
-      "object_description": "Objekti kirjeldus",
-      "review_description_events_per_second": "Ülevaate kirjeldus",
-      "review_description": "Ülevaate kirjeldus",
-      "yolov9_plate_detection": "YOLOv9 numbrimärgi tuvastus",
-      "yolov9_plate_detection_speed": "YOLOv9 numbrimärgi tuvastuskiirus",
-      "plate_recognition_speed": "Numbrimärgituvastuse kiirus",
-      "face_recognition_speed": "Näotuvastuse kiirus"
-    },
-    "title": "Andmerikastused"
-  },
-  "cameras": {
-    "connectionQuality": {
-      "reconnectsLastHour": "Uuesti ühendumisi (viimase tunni jooksul)",
-      "stallsLastHour": "Seiskumisi (viimase tunni jooksul)",
-      "title": "Ühenduse kvaliteet",
-      "excellent": "Suurepärane",
-      "fair": "Rahuldav",
-      "poor": "Kehv",
-      "unusable": "Mittekasutatav",
-      "fps": "Kaadrisagedus",
-      "expectedFps": "Eeldatav kaadrisagedus (FPS)"
-    },
-    "label": {
-      "camera": "kaamera",
-      "detect": "tuvasta",
-      "skipped": "vahele jäetud",
-      "ffmpeg": "FFmpeg",
-      "cameraFfmpeg": "{{camName}} FFmpeg",
-      "cameraGpu": "{{camName}} GPU",
-      "cameraDetect": "{{camName}} tuvastus",
-      "overallFramesPerSecond": "kaadreid sekundis kokku",
-      "overallDetectionsPerSecond": "kogutuvastusi sekundis",
-      "overallSkippedDetectionsPerSecond": "vahelejäänud tuvastusi sekundis kokku",
-      "cameraFramesPerSecond": "{{camName}} kaadreid sekundis",
-      "cameraDetectionsPerSecond": "{{camName}} tuvastusi sekundis",
-      "cameraSkippedDetectionsPerSecond": "{{camName}} vahelejäänud tuvastusi sekundis",
-      "capture": "jäädvustamine"
-    },
-    "noCameras": {
-      "title": "Ühtegi kaamerat ei leitud"
-    },
-    "framesAndDetections": "Kaadreid / Tuvastusi",
-    "info": {
-      "keyframes": {
-        "recordDisabled": "Selle kaamera salvestamine on välja lülitatud.",
-        "segmentLength": "Salvestuse segmendi pikkus:",
-        "recordStream": "Salvestusvoog:",
-        "keyframeCount": "Vaadeldud võtmekaadrid:",
-        "observedDuration": "Vaadeldud kestus:"
-      },
-      "audio": "Audio:",
-      "error": "Viga: {{error}}",
-      "codec": "Koodek:",
-      "resolution": "Resolutsioon:",
-      "video": "Video:",
-      "aspectRatio": "kuvasuhe",
-      "unknown": "Tundmatu",
-      "fetching": "Kaameraandmete toomine",
-      "stream": "Voog {{idx}}",
-      "streamDataFromFFPROBE": "Vooandmed saadakse <code>ffprobe</code> abil.",
-      "fps": "Kaadrisagedus (FPS):"
-    },
-    "title": "Kaamerad",
-    "overview": "Ülevaade"
-  },
-  "lastRefreshed": "Viimati uuendatud: ",
-  "stats": {
-    "healthy": "Süsteem on töökorras",
-    "detectIsSlow": "{{detect}} on aeglane ({{speed}} ms)",
-    "detectIsVerySlow": "{{detect}} on väga aeglane ({{speed}} ms)",
-    "cameraIsOffline": "{{camera}} on ühenduseta"
-  },
-  "storage": {
-    "cameraStorage": {
-      "camera": "Kaamera",
-      "unused": {
-        "title": "Kasutamata",
-        "tips": "See väärtus ei pruugi Frigate'i jaoks saadaolevat vaba ruumi täpselt kajastada, kui teie draivil on lisaks Frigate'i salvestistele ka muid faile. Frigate ei jälgi salvestusruumi kasutamist väljaspool oma salvestisi."
-      },
-      "bandwidth": "Ribalaius",
-      "storageUsed": "Salvestusmaht",
-      "percentageOfTotalUsed": "protsent kogusummast",
-      "unusedStorageInformation": "Kasutamata salvestusmahu info",
-      "title": "Kaamera salvestusmaht"
-    },
-    "title": "Säilitus",
-    "overview": "Ülevaade",
-    "recordings": {
-      "title": "Salvestused",
-      "earliestRecording": "Varaseim saadaolev salvestis:"
-    },
-    "shm": {
-      "title": "SHM (jagatud mälu) eraldus",
-      "frameLifetime": {
-        "title": "Kaadri eluiga"
-      }
-    }
-  },
-  "metrics": "Süsteemi mõõdikud",
-  "general": {
-    "title": "Üldine",
-    "hardwareInfo": {
-      "gpuUsage": "GPU kasutus",
-      "gpuMemory": "GPU mälu",
-      "gpuInfo": {
-        "vainfoOutput": {
-          "title": "Vainfo väljund",
-          "processOutput": "Protsessi väljund:",
-          "processError": "Protsessi viga:",
-          "returnCode": "Tagastuskood: {{code}}"
-        },
-        "closeInfo": {
-          "label": "Sulge GPU info"
-        },
-        "copyInfo": {
-          "label": "Kopeeri GPU info"
-        },
-        "nvidiaSMIOutput": {
-          "title": "Nvidia SMI väljund",
-          "name": "Nimi: {{name}}",
-          "driver": "Draiver: {{driver}}",
-          "cudaComputerCapability": "CUDA arvutusvõimekus: {{cuda_compute}}",
-          "vbios": "VBios info: {{vbios}}"
-        },
-        "toast": {
-          "success": "GPU info kopeeriti lõikelauale"
-        }
-      },
-      "gpuDecoder": "GPU dekooder",
-      "gpuTemperature": "GPU temperatuur",
-      "gpuEncoder": "GPU kodeerija",
-      "gpuCompute": "GPU arvutus / kodeerimine",
-      "title": "Riistvara info",
-      "npuUsage": "NPU kasutus",
-      "npuMemory": "NPU mälu",
-      "npuTemperature": "NPU temperatuur",
-      "intelGpuWarning": {
-        "title": "Inteli GPU statistika hoiatus",
-        "message": "GPU statistika pole saadaval"
-      }
-    },
-    "otherProcesses": {
-      "series": {
-        "go2rtc": "go2rtc",
-        "recording": "salvestus",
-        "review_segment": "Segmendi ülevaade",
-        "audio_detector": "audio detektor"
-      },
-      "processCpuUsage": "Protsessi CPU kasutus",
-      "processMemoryUsage": "Protsessi mälukasutus"
-    },
-    "detector": {
-      "title": "Detektorid",
-      "memoryUsage": "Detektori mälukasutus",
-      "cpuUsage": "Detektori CPU kasutus",
-      "temperature": "Detektori temperatuur",
-      "inferenceSpeed": "Detektori järelduskiirus",
-      "cpuUsageInformation": "Protsessori võimsus, mida kasutatakse tuvastusmudelite sisend- ja väljundandmete ettevalmistamisel. See väärtus ei mõõda järelduste kasutamist isegi siis, kui kasutatakse graafikaprotsessorit või kiirendit."
-    }
-  }
+  "title": "Süsteem"
 }

web/public/locales/fr/components/dialog.json

@@ -67,8 +67,7 @@
       "error": {
         "failed": "Échec du démarrage de l'exportation : {{error}}",
         "endTimeMustAfterStartTime": "L'heure de fin doit être postérieure à l'heure de début.",
-        "noVaildTimeSelected": "La plage horaire sélectionnée n'est pas valide.",
-        "noValidTimeSelected": "Interval de temps invalide"
+        "noVaildTimeSelected": "La plage horaire sélectionnée n'est pas valide."
       },
       "success": "Exportation démarrée avec succès. Consultez le fichier sur la page des exportations.",
       "view": "Vue",
@@ -89,9 +88,7 @@
     "export": "Exporter",
     "fromTimeline": {
       "saveExport": "Enregistrer l'exportation",
-      "previewExport": "Aperçu de l'exportation",
-      "queueingExport": "Traitement de l'export...",
-      "useThisRange": "Utiliser cet interval"
+      "previewExport": "Aperçu de l'exportation"
     },
     "case": {
       "label": "Dossier",
@@ -198,10 +195,6 @@
       "markAsReviewed": "Marquer comme traité",
       "deleteNow": "Supprimer maintenant",
       "markAsUnreviewed": "Marquer comme non traité"
-    },
-    "shareTimestamp": {
-      "label": "Partager cette date",
-      "title": "Partager cette date"
     }
   },
   "imagePicker": {

web/public/locales/hu/audio.json

@@ -433,22 +433,5 @@
   "trickle": "Csörgedezés",
   "gush": "Folyás",
   "stir": "Kavarás",
-  "thump": "Puffanás",
-  "arrow": "Nyíl",
-  "bouncing": "Pattog",
-  "vibration": "Vibrálás",
-  "inside": "Belül",
-  "outside": "Kívül",
-  "mains_hum": "Hálózati zaj",
-  "distortion": "Torzulás",
-  "throbbing": "Lüktetés",
-  "flap": "Csapkodás",
-  "scratch": "Kapar",
-  "scrape": "Karcolás",
-  "rub": "Dörzsölés",
-  "roll": "Gördül",
-  "crushing": "Összenyom",
-  "crumpling": "Gyűrődés",
-  "beep": "Sípolás",
-  "clang": "Csengés"
+  "thump": "Puffanás"
 }

web/public/locales/id/components/dialog.json

@@ -24,9 +24,6 @@
         },
         "state": {
           "submitted": "Terkirim"
-        },
-        "toast": {
-          "error": "Gagal submit ke Frigate+. Harap periksa koneksi jaringan Anda dan coba lagi."
         }
       }
     },
@@ -60,8 +57,7 @@
       "view": "Melihat",
       "batchSuccess_other": "{{count}} Ekspor dimulai. Membuka kasusnya sekarang.",
       "batchPartial": "Ekspor berhasil dimulai sebanyak {{successful}} dari total {{total}} ekspor. Kamera yang gagal: {{failedCameras}}",
-      "batchFailed": "Gagal memulai ekspor sebanyak {{total}}. Kamera yang gagal: {{failedCameras}}",
-      "batchQueuedPartial": "Antrian ekspor berhasil sebanyak {{successful}} dari total {{total}} ekspor. Kamera yang gagal: {{failedCameras}}"
+      "batchFailed": "Gagal memulai ekspor sebanyak {{total}}. Kamera yang gagal: {{failedCameras}}"
     },
     "case": {
       "newCaseOption": "Membuat Kasus Baru",
@@ -91,9 +87,7 @@
       "selectGroup": "Pilih grup",
       "noMatchingCameras": "Tidak ada kamera yang sesuai dengan pencarian Anda",
       "selectedCount": "{{terpilih}} / {{total}} terpilih",
-      "namePlaceholder": "Nama dasar opsional untuk ekspor ini",
-      "searchOrSelectGroup": "Cari, atau pilih grup kamera...",
-      "selectAll": "Pilih semua kamera"
+      "namePlaceholder": "Nama dasar opsional untuk ekspor ini"
     },
     "multi": {
       "title_other": "Ekspor {{count}} Ulasan",

web/public/locales/lv/audio.json

@@ -68,8 +68,8 @@
   "choir": "Koris",
   "yodeling": "Jodelēšana",
   "mantra": "Mantra",
-  "rapping": "Repošana",
-  "whistling": "Svilpošana",
+  "rapping": "Repot",
+  "whistling": "Svilpot",
   "sniff": "Ošņāt",
   "hands": "Rokas",
   "animal": "Dzīvnieks",
@@ -122,17 +122,5 @@
   "fireworks": "Uguņošana",
   "glass": "Stikls",
   "white_noise": "Baltais troksnis",
-  "radio": "Radio",
-  "chant": "Piedziedājums",
-  "synthetic_singing": "Sintētiskā dziedāšana",
-  "groan": "Vaidēšana",
-  "grunt": "Rukšķēšana",
-  "breathing": "Elpošana",
-  "wheeze": "Gārgšana",
-  "snoring": "Krākšana",
-  "gasp": "Elsošana",
-  "pant": "Elšana",
-  "snort": "Šņaukt",
-  "cough": "Klepus",
-  "throat_clearing": "Kakla tīrīšana"
+  "radio": "Radio"
 }

web/public/locales/nb-NO/components/dialog.json

@@ -64,8 +64,7 @@
       "error": {
         "failed": "Kunne ikke legge eksport i kø: {{error}}",
         "noVaildTimeSelected": "Ingen gyldig tidsperiode valgt",
-        "endTimeMustAfterStartTime": "Sluttid må være etter starttid",
-        "noValidTimeSelected": "Ingen gyldig tidsperiode valgt"
+        "endTimeMustAfterStartTime": "Sluttid må være etter starttid"
       },
       "view": "Vis",
       "queued": "Eksport lagt i kø. Se fremdrift på eksportsiden.",

web/public/locales/nl/components/dialog.json

@@ -34,9 +34,6 @@
           "label": "Bevestig dit label voor Frigate Plus",
           "ask_a": "Is dit object een <code>{{label}}</code>?",
           "ask_full": "Is dit object een <code>{{untranslatedLabel}}</code> ({{translatedLabel}})?"
-        },
-        "toast": {
-          "error": "Gefaald bij Frigate+ in te dienen. Controleer je netwerkverbinding en probeer opnieuw."
         }
       }
     },
@@ -107,14 +104,7 @@
       "namePlaceholder": "Optionele basisnaam voor deze exporten",
       "queueingButton": "Exporten in wachtrij plaatsen...",
       "exportButton_one": "Export 1 Camera",
-      "exportButton_other": "{{count}} camera's exporteren",
-      "searchOrSelectGroup": "Zoek of selecteer een cameragroep...",
-      "selectAll": "Selecteer alle camera's",
-      "clearSelection": "Wis selectie",
-      "selectWithActivity": "Camera's met gevolgde objecten",
-      "selectGroup": "Selecteer groep",
-      "noMatchingCameras": "Geen camera's komen overeen met je zoekopdracht",
-      "selectedCount": "{{selected}} / {{total}} geselecteerd"
+      "exportButton_other": "{{count}} camera's exporteren"
     },
     "multi": {
       "title_one": "Review 1 exporteren",

web/public/locales/pt-BR/components/dialog.json

@@ -19,8 +19,8 @@
         "question": {
           "label": "Confirmar esse rótulo para Frigate Plus",
           "ask_a": "Este objeto é um <code>{{label}}</code>?",
-          "ask_an": "Este objeto é um <code>{{label}}</code>?",
-          "ask_full": "Este objeto é um <code>{{untranslatedLabel}}</code> ({{translatedLabel}})?"
+          "ask_an": "Este objeto é um<code>{{label}}</code>?",
+          "ask_full": "Este objeto é um<code>{{untranslatedLabel}}</code> ({{translatedLabel}})?"
         },
         "state": {
           "submitted": "Enviado"
@@ -71,10 +71,7 @@
       "batchQueueFailed": "Falha ao enfileirar {{total}} exportações. Câmeras com falha: {{failedCameras}}",
       "batchPartial": "Iniciadas {{successful}} de {{total}} exportações. Câmeras com falha: {{failedCameras}}",
       "batchFailed": "Falha ao iniciar {{total}} exportações. Câmeras com falha: {{failedCameras}}",
-      "queued": "Exportação na fila. Acompanhe o progresso na página de exportações.",
-      "batchSuccess_one": "1 exportação iniciada. Abrindo o caso agora.",
-      "batchSuccess_many": "{{count}} exportações iniciadas. Abrindo o caso agora.",
-      "batchSuccess_other": "{{count}} exportações iniciadas. Abrindo o caso agora."
+      "queued": "Exportação na fila. Acompanhe o progresso na página de exportações."
     },
     "fromTimeline": {
       "saveExport": "Salvar Exportação",
@@ -135,10 +132,7 @@
         "started_many": "Iniciadas {{count}} exportações. Abrindo o caso agora.",
         "started_other": "",
         "failed": "Falha ao iniciar {{total}} exportações. Falhas: {{failedItems}}",
-        "partial": "Iniciadas {{successful}} de {{total}} exportações. Falhas: {{failedItems}}",
-        "startedNoCase_one": "1 exportação iniciada.",
-        "startedNoCase_many": "{{count}} exportações iniciadas.",
-        "startedNoCase_other": "{{count}} exportações iniciadas."
+        "partial": "Iniciadas {{successful}} de {{total}} exportações. Falhas: {{failedItems}}"
       }
     }
   },

web/public/locales/pt-BR/config/cameras.json

@@ -215,8 +215,7 @@
         "label": "Birdseye",
         "description": "Configurações para a visualização composta \"Birdseye\", que combina múltiplas transmissões de câmera em um único layout.",
         "enabled": {
-            "label": "Ativar Birdseye",
-            "description": "Habilita ou desabilita a função Birdseye."
+            "label": "Ativar Birdseye"
         }
     },
     "live": {
@@ -402,9 +401,7 @@
         "enhancement": {
             "label": "Nível de aprimoramento",
             "description": "Nível de aprimoramento (0-10) a ser aplicado aos recortes da placa antes do OCR; valores mais altos nem sempre melhoram os resultados, e níveis acima de 5 podem funcionar apenas com placas noturnas, devendo ser utilizados com cautela."
-        },
-        "label": "Reconhecimento de placa veicular",
-        "description": "Configurações de reconhecimento de placa veicular, incluindo limites de detecção, formatação e placas conhecidas."
+        }
     },
     "record": {
         "label": "Gravação",
@@ -542,18 +539,6 @@
             "enabled": {
                 "label": "Ativar detecções",
                 "description": "Ative ou desative eventos de detecção para esta câmera."
-            },
-            "labels": {
-                "label": "Rótulos de detecção",
-                "description": "Lista de rótulos de objetos que são considerados eventos de detecção."
-            },
-            "required_zones": {
-                "label": "Zonas requeridas",
-                "description": "Zonas em que um objeto deve entrar para ser considerado detectado. Deixe em branco para permitir qualquer zona."
-            },
-            "cutoff_time": {
-                "label": "Tempo limite de detecção",
-                "description": "Segundos a esperar após o fim da atividade antes de encerrar a detecção."
             }
         }
     }

web/public/locales/pt-BR/config/global.json

@@ -239,8 +239,7 @@
         "label": "Birdseye",
         "description": "Configurações para a visualização composta \"Birdseye\", que combina múltiplas transmissões de câmera em um único layout.",
         "enabled": {
-            "label": "Ativar Birdseye",
-            "description": "Habilita ou desabilita a função Birdseye."
+            "label": "Ativar Birdseye"
         }
     },
     "live": {
@@ -421,9 +420,7 @@
         "enhancement": {
             "label": "Nível de aprimoramento",
             "description": "Nível de aprimoramento (0-10) a ser aplicado aos recortes da placa antes do OCR; valores mais altos nem sempre melhoram os resultados, e níveis acima de 5 podem funcionar apenas com placas noturnas, devendo ser utilizados com cautela."
-        },
-        "label": "Reconhecimento de placa veicular",
-        "description": "Configurações de reconhecimento de placa veicular, incluindo limites de detecção, formatação e placas conhecidas."
+        }
     },
     "record": {
         "label": "Gravação",
@@ -556,18 +553,6 @@
             "description": "Configurações que definem para quais objetos rastreados são geradas detecções (sem gerar alerta) e como essas detecções são retidas.",
             "enabled": {
                 "label": "Ativar detecções"
-            },
-            "labels": {
-                "label": "Rótulos de detecção",
-                "description": "Lista de rótulos de objetos que são considerados eventos de detecção."
-            },
-            "required_zones": {
-                "label": "Zonas requeridas",
-                "description": "Zonas em que um objeto deve entrar para ser considerado detectado. Deixe em branco para permitir qualquer zona."
-            },
-            "cutoff_time": {
-                "label": "Tempo limite de detecção",
-                "description": "Segundos a esperar após o fim da atividade antes de encerrar a detecção."
             }
         }
     }

web/public/locales/pt-BR/views/classificationModel.json

@@ -12,12 +12,12 @@
   },
   "toast": {
     "success": {
-      "deletedCategory_one": "{{count}} classe removida",
-      "deletedCategory_many": "{{count}} classes removidas",
-      "deletedCategory_other": "{{count}} classes removidas",
-      "deletedImage_one": "{{count}} imagem removida",
-      "deletedImage_many": "{{count}} imagens removidas",
-      "deletedImage_other": "{{count}} imagens removidas",
+      "deletedCategory_one": "Classe Apagada",
+      "deletedCategory_many": "Classes apagadas",
+      "deletedCategory_other": "",
+      "deletedImage_one": "Imagen Apagada",
+      "deletedImage_many": "Imagens Apagadas",
+      "deletedImage_other": "",
       "categorizedImage": "Imagem Classificada com Sucesso",
       "trainedModel": "Modelo treinado com sucesso.",
       "trainingModel": "Treinamento do modelo iniciado com sucesso.",

web/public/locales/pt-BR/views/settings.json

@@ -296,7 +296,7 @@
       }
     },
     "motionMaskLabel": "Máscara de Movimento {{number}}",
-    "objectMaskLabel": "Máscara de Objeto {{number}}",
+    "objectMaskLabel": "Máscara de Objeto {{number}} ({{label}})",
     "form": {
       "zoneName": {
         "error": {
@@ -437,7 +437,7 @@
       "add": "Nova Máscara de Movimento",
       "edit": "Editar Máscara de Movimento",
       "context": {
-        "title": "Máscaras de movimento são usadas para prevenir tipos de movimento não desejados de ativarem uma detecção (exemplo: galhos de árvores, timestamps de câmeras). Máscaras de movimento devem ser usadas <em>com moderação</em>. Excesso de mascaramento tornará o rastreamento de objetos mais difícil.",
+        "title": "Máscaras de movimento são usadas para prevenir tipos de movimento não desejados de ativarem uma detecção (exemplo: galhos de árvores, timestamps de câmeras). Máscaras de movimento devem ser usadas <em> com moderação </em>. Excesso de mascaramento tornará o rastreamento de objetos mais difícil.",
         "documentation": "Leia a documentação"
       },
       "point_one": "{{count}} ponto",
@@ -723,7 +723,7 @@
       "title": "Configuração de Captura de Imagem",
       "desc": "Envios ao Frigate+ requerem tanto a captura de imagem normais quanto a captura de imagem <code>clean_copy</code> estarem habilitadas na sua configuração.",
       "documentation": "Leia a documentação",
-      "cleanCopyWarning": "Algumas câmeras estão com os snapshots desativados",
+      "cleanCopyWarning": "Algumas câmeras possuem captura de imagem habilitada porém têm a cópia limpa desabilitada. Você precisa habilitar a <code>clean_copy</code> nas suas configurações de captura de imagem para poder submeter imagems dessa câmera ao Frigate+.",
       "table": {
         "camera": "Câmera",
         "snapshots": "Capturas de Imagem",

web/public/locales/ro/audio.json

@@ -3,7 +3,7 @@
   "machine_gun": "Mitraliera",
   "speech": "Vorbire",
   "babbling": "Murmur",
-  "yell": "Strigăt",
+  "yell": "Striga",
   "bellow": "Sub",
   "dog": "Câine",
   "horse": "Cal",

web/public/locales/ro/components/dialog.json

@@ -32,9 +32,6 @@
           "ask_a": "Este acest obiect un <code>{{label}}</code>?",
           "ask_an": "Este acest obiect un <code>{{label}}</code>?",
           "ask_full": "Este acest obiect un <code>{{untranslatedLabel}}</code> ({{translatedLabel}})?"
-        },
-        "toast": {
-          "error": "Trimiterea către Frigate+ a eșuat. Te rog să verifici conexiunea la rețea și să încerci din nou."
         }
       },
       "submitToPlus": {
@@ -99,8 +96,7 @@
       "error": {
         "failed": "Nu s-a putut adăuga exportul în coadă: {{error}}",
         "endTimeMustAfterStartTime": "Ora de sfârșit trebuie să fie după ora de început",
-        "noVaildTimeSelected": "Nu a fost selectat un interval de timp valid",
-        "noValidTimeSelected": "Niciun interval de timp valid selectat"
+        "noVaildTimeSelected": "Nu a fost selectat un interval de timp valid"
       },
       "view": "Vizualizează",
       "queued": "Export pus la coadă. Vezi progresul pe pagina de exporturi.",
@@ -149,14 +145,7 @@
       "queueingButton": "Se adaugă exporturile la coadă...",
       "exportButton_one": "Exportă 1 cameră",
       "exportButton_few": "Exportă {{count}} camere",
-      "exportButton_other": "Exportă {{count}} de camere",
-      "searchOrSelectGroup": "Caută sau selectează un grup de camere...",
-      "selectAll": "Selectează toate camerele",
-      "clearSelection": "Șterge selecția",
-      "selectWithActivity": "Camere cu obiecte urmărite",
-      "selectGroup": "Selectează grupul",
-      "noMatchingCameras": "Nicio cameră nu corespunde căutării tale",
-      "selectedCount": "{{selected}} / {{total}} selectate"
+      "exportButton_other": "Exportă {{count}} de camere"
     },
     "multi": {
       "title_one": "Exportă o revizuire",

web/public/locales/ro/config/cameras.json

@@ -371,7 +371,7 @@
                 "description": "Folosește snapshot-urile obiectelor în loc de miniaturi pentru GenAI."
             },
             "prompt": {
-                "label": "Prompt de descriere",
+                "label": "Prompt descriere",
                 "description": "Șablonul de prompt implicit pentru descrierile GenAI."
             },
             "object_prompts": {
@@ -493,9 +493,6 @@
             "max_concurrent": {
                 "description": "Numărul maxim de sarcini de export de procesat în același timp.",
                 "label": "Număr maxim de exporturi simultane"
-            },
-            "chapters": {
-                "label": "Metadate de capitol de încorporat în înregistrările exportate"
             }
         },
         "preview": {
@@ -771,7 +768,7 @@
             "description": "Adresa de email folosită pentru notificări push sau cerută de anumiți furnizori de notificări."
         },
         "cooldown": {
-            "label": "Perioadă de repaus",
+            "label": "Perioadă de răcire",
             "description": "Timpul de așteptare (secunde) între notificări pentru a evita spamarea destinatarilor."
         },
         "enabled_in_config": {

web/public/locales/ro/config/global.json

@@ -217,7 +217,7 @@
     },
     "ffmpeg": {
         "label": "FFmpeg",
-        "description": "Setări FFmpeg: inclusiv calea către binar, argumente, accelerare hardware și ieșiri per rol.",
+        "description": "Setări FFmpeg: cale binar, argumente, accelerare hardware și ieșiri per rol.",
         "path": {
             "label": "Cale FFmpeg",
             "description": "Calea către binarul FFmpeg sau un alias de versiune (\"7.0\" sau \"8.0\")."
@@ -481,7 +481,7 @@
                 "description": "Folosește snapshot-urile obiectelor în loc de miniaturi pentru GenAI."
             },
             "prompt": {
-                "label": "Prompt de descriere",
+                "label": "Prompt descriere",
                 "description": "Șablonul de prompt implicit pentru descrierile GenAI."
             },
             "object_prompts": {
@@ -637,9 +637,6 @@
             "max_concurrent": {
                 "description": "Numărul maxim de sarcini de export de procesat în același timp.",
                 "label": "Număr maxim de exporturi simultane"
-            },
-            "chapters": {
-                "label": "Metadate de capitol de încorporat în înregistrările exportate"
             }
         },
         "preview": {
@@ -955,7 +952,7 @@
             "description": "Adresa de email folosită pentru notificări push sau cerută de anumiți furnizori de notificări."
         },
         "cooldown": {
-            "label": "Perioadă de repaus",
+            "label": "Perioadă de răcire",
             "description": "Timpul de așteptare (secunde) între notificări pentru a evita spamarea destinatarilor."
         },
         "enabled_in_config": {

web/public/locales/ro/views/classificationModel.json

@@ -192,20 +192,7 @@
     "title": "Editează modelul de clasificare",
     "descriptionState": "Editează clasele pentru acest model de clasificare a stării. Modificările vor necesita reantrenarea modelului.",
     "descriptionObject": "Editează tipul de obiect și tipul de clasificare pentru acest model de clasificare a obiectelor.",
-    "stateClassesInfo": "Model actualizat. Reantrenează modelul pentru ca modificările claselor să aibă efect.",
-    "enabled": "Activat",
-    "enabledDesc": "Rulează acest model. Când este dezactivat, se oprește și nu mai clasifică.",
-    "saveAttempts": "Încercări de salvare",
-    "saveAttemptsDesc": "Numărul de imagini cu încercări de clasificare de păstrat pentru interfața de clasificări recente.",
-    "motion": "Rulează la mișcare",
-    "motionDesc": "Rulează clasificarea atunci când este detectată mișcare în decupajul configurat.",
-    "interval": "Interval",
-    "intervalDesc": "Secunde între rulările periodice de clasificare. Lasă necompletat pentru a rula doar la mișcare.",
-    "intervalPlaceholder": "Niciun interval",
-    "errors": {
-      "saveAttemptsInvalid": "Încercările de salvare trebuie să fie un număr întreg de 0 sau mai mare",
-      "intervalInvalid": "Intervalul trebuie să fie un număr întreg mai mare decât 0"
-    }
+    "stateClassesInfo": "Notă: Modificarea claselor de stare necesită reantrenarea modelului cu clasele actualizate."
   },
   "tooltip": {
     "trainingInProgress": "Modelul este în curs de antrenare",
@@ -215,6 +202,5 @@
   },
   "none": "Niciuna",
   "reclassifyImageAs": "Reclasifică imaginea ca:",
-  "reclassifyImage": "Reclasifică imaginea",
-  "disabled": "Dezactivat"
+  "reclassifyImage": "Reclasifică imaginea"
 }

web/public/locales/ro/views/explore.json

@@ -120,7 +120,7 @@
     },
     "editSubLabel": {
       "title": "Editează subeticheta",
-      "desc": "Introdu o sub-etichetă nouă pentru acest/această {{label}}",
+      "desc": "Introdu o sub-etichetă nouă pentru acest {{label}}",
       "descNoLabel": "Introduceți o nouă subetichetă pentru acest obiect urmărit"
     },
     "editLPR": {

web/public/locales/ro/views/settings.json

@@ -122,7 +122,7 @@
         "desc": "Arată întotdeauna numele camerelor într-un tag (chip) în dashboard-ul live multi-cameră."
       },
       "liveFallbackTimeout": {
-        "label": "Timp de expirare pentru player-ul live",
+        "label": "Timeout Rezecție Player Live",
         "desc": "Când stream-ul live de înaltă calitate nu este disponibil, comută pe modul de bandă redusă după acest număr de secunde. Implicit: 3."
       }
     },
@@ -1337,7 +1337,7 @@
         "reviewHelp": "Arată această cameră în revizuiri, inclusiv filtrul de camere, revizuirea mișcărilor și vizualizarea istoricului."
       },
       "label": "Stare cameră",
-      "description": "Setează starea de funcționare pentru fiecare cameră.<br /><br /><strong>Pornit</strong>: stream-urile sunt procesate normal.<br /><strong>Oprit</strong>: pune temporar pe pauză procesarea. Nu se menține după repornirile Frigate.<br /><strong>Dezactivat</strong>: oprește procesarea și salvează modificarea în configurația ta. Este necesară o repornire pentru a reactiva o cameră dezactivată.<br /><br /><em>Notă: Dezactivarea nu afectează restream-urile go2rtc.</em><br /><br />Trage⋮ pentru a reordona camerele active așa cum apar în interfață, inclusiv în panoul Live și în meniurile drop-down de selecție a camerei.",
+      "description": "Setează starea de funcționare pentru fiecare cameră.<br /><br /><strong>Pornit</strong>: stream-urile sunt procesate normal.<br /><strong>Oprit</strong>: pune temporar pe pauză procesarea. Nu se menține după repornirile Frigate.<br /><strong>Dezactivat</strong>: oprește procesarea și salvează modificarea în configurația ta. Este necesară o repornire pentru a reactiva o cameră dezactivată.<br /><br /><em>Notă: Dezactivarea nu afectează restream-urile go2rtc.</em><br /><br />Trage de mâner pentru a reordona camerele active așa cum apar în interfață, inclusiv în panoul Live și în meniurile drop-down de selecție a camerei.",
       "disabledSubheading": "Dezactivat în configurație",
       "status": {
         "on": "Pornit",
@@ -1643,14 +1643,7 @@
       "keyLabel": "Cheie",
       "valueLabel": "Valoare",
       "keyPlaceholder": "Cheie nouă",
-      "remove": "Elimină",
-      "providerNamePlaceholder": "de ex., openai",
-      "providerNameLabel": "Nume furnizor",
-      "variableNameLabel": "Nume variabilă",
-      "variableNamePlaceholder": "de ex., MY_VARIABLE",
-      "loggerNameLabel": "Nume logger",
-      "loggerNamePlaceholder": "de ex., frigate.record",
-      "keyPatternError": "Folosește doar litere, cifre, cratime și linii de subliniere (fără spații)"
+      "remove": "Elimină"
     },
     "timezone": {
       "defaultOption": "Folosește fusul orar al browserului"
@@ -2105,10 +2098,6 @@
     },
     "ffmpeg": {
       "hwaccelManualNotRecommended": "Argumentele manuale pentru accelerarea hardware nu sunt recomandate. Dacă nu există o cerință specifică, selectează presetarea care se potrivește cu hardware-ul tău."
-    },
-    "model": {
-      "optimizedFor320": "Frigate este optimizat pentru un model de 320x320, care este cea mai bună alegere pentru majoritatea configurațiilor. Un model de 640x640 este mai lent și ajută doar în scenarii specifice.",
-      "inputDimensionsNotDetectResolution": "Lățimea și înălțimea de intrare ale modelului reprezintă dimensiunile de intrare ale modelului de detectare a obiectelor, nu rezoluția de detecție a camerei tale. Acestea ar trebui să se potrivească cu dimensiunile modelului pe care îl folosești — de obicei o dimensiune pătrată, cum ar fi 320x320 sau 640x640."
     }
   },
   "birdseye": {

web/public/locales/sk/common.json

@@ -1,9 +1,9 @@
 {
   "time": {
-    "untilForTime": "Do {{time}}",
+    "untilForTime": "Do{{time}}",
     "untilForRestart": "Do reštartu Frigate.",
     "untilRestart": "Do reštartu",
-    "ago": "pred {{timeAgo}}",
+    "ago": "{{timeAgo}} pred časom",
     "justNow": "Práve teraz",
     "today": "Dnes",
     "yesterday": "Včera",
@@ -23,32 +23,32 @@
     "am": "ráno",
     "yr": "{{time}}r",
     "pm": "popoludní",
-    "year_one": "{{time}} rok",
-    "year_few": "{{time}} roky",
-    "year_other": "{{time}} rokov",
+    "year_one": "{{time}}rok",
+    "year_few": "{{time}}rokov",
+    "year_other": "{{time}}rokov",
     "mo": "{{time}}mes",
-    "month_one": "{{time}} mesiac",
+    "month_one": "{{time}}mesiac",
     "month_few": "{{time}} mesiace",
-    "month_other": "{{time}} mesiacov",
+    "month_other": "{{time}} mesiaca",
     "d": "{{time}}d",
-    "day_one": "{{time}} deň",
-    "day_few": "{{time}} dni",
-    "day_other": "{{time}} dní",
+    "day_one": "{{time}}deň",
+    "day_few": "{{time}}dni",
+    "day_other": "{{time}}dni",
     "h": "{{time}}h",
-    "hour_one": "{{time}} hodina",
-    "hour_few": "{{time}} hodiny",
-    "hour_other": "{{time}} hodín",
+    "hour_one": "{{time}}hodina",
+    "hour_few": "{{time}}hodiny",
+    "hour_other": "{{time}}hodin",
     "m": "{{time}} min",
     "s": "{{time}}s",
-    "minute_one": "{{time}} minúta",
-    "minute_few": "{{time}} minúty",
-    "minute_other": "{{time}} minút",
-    "second_one": "{{time}} sekunda",
-    "second_few": "{{time}} sekundy",
-    "second_other": "{{time}} sekúnd",
+    "minute_one": "{{time}}minuta",
+    "minute_few": "{{time}}minuty",
+    "minute_other": "{{time}}minut",
+    "second_one": "{{time}}sekunda",
+    "second_few": "{{time}}sekundy",
+    "second_other": "{{time}}sekund",
     "formattedTimestamp": {
-      "12hour": "d MMM, h:mm:ss aaa",
-      "24hour": "d MMM, HH:mm:ss"
+      "12hour": "Deň MMM, h:mm:ss aaa",
+      "24hour": "Deň MMM, HH:mm:ss"
     },
     "formattedTimestamp2": {
       "12hour": "MM/dd h:mm:ssa",
@@ -219,9 +219,9 @@
       "allCameras": "Všetky kamery",
       "cameras": {
         "title": "Kamery",
-        "count_one": "{{count}} kamera",
-        "count_few": "{{count}} kamery",
-        "count_other": "{{count}} kamier"
+        "count_one": "{{count}}kamera",
+        "count_few": "{{count}}kamery",
+        "count_other": "{{count}}kamier"
       }
     },
     "export": "Exportovať",

web/public/locales/sk/components/dialog.json

@@ -43,9 +43,9 @@
         "title": "Čas ukončenia",
         "label": "Vybrat čas ukončenia"
       },
-      "lastHour_one": "Posledná hodina",
-      "lastHour_few": "Posledné {{count}} hodiny",
-      "lastHour_other": "Posledných {{count}} hodín"
+      "lastHour_one": "Minulu hodinu",
+      "lastHour_few": "Minule{{count}}hodiny",
+      "lastHour_other": "Minulych{{count}}hodin"
     },
     "name": {
       "placeholder": "Pomenujte Export"

web/public/locales/sk/views/classificationModel.json

@@ -12,12 +12,12 @@
   },
   "toast": {
     "success": {
-      "deletedCategory_one": "Vymazaná {{count}} trieda",
-      "deletedCategory_few": "Vymazané {{count}} triedy",
-      "deletedCategory_other": "Vymazaných {{count}} tried",
-      "deletedImage_one": "Vymazaný {{count}} obrázok",
-      "deletedImage_few": "Vymazané {{count}} obrázky",
-      "deletedImage_other": "Vymazaných {{count}} obrázkov",
+      "deletedCategory_one": "Vymazaná Trieda",
+      "deletedCategory_few": "",
+      "deletedCategory_other": "",
+      "deletedImage_one": "Vymazané Obrázky",
+      "deletedImage_few": "",
+      "deletedImage_other": "",
       "categorizedImage": "Obrázok bol úspešne klasifikovaný",
       "trainedModel": "Úspešne vyškolený model.",
       "trainingModel": "Úspešne spustené trénovanie modelu.",
@@ -81,7 +81,7 @@
       "buttonText": "Vytvorte objektový model"
     },
     "state": {
-      "title": "Žiadne modely klasifikácie stavov",
+      "title": "Žiadne modely klasifikácie štátov",
       "description": "Vytvorte si vlastný model na monitorovanie a klasifikáciu zmien stavu v špecifických oblastiach kamery.",
       "buttonText": "Vytvorte model stavu"
     }
@@ -90,7 +90,7 @@
     "title": "Vytvorte novú klasifikáciu",
     "steps": {
       "nameAndDefine": "Názov a definícia",
-      "stateArea": "Oblasť stavu",
+      "stateArea": "Štátna oblasť",
       "chooseExamples": "Vyberte Príklady"
     },
     "step1": {
@@ -98,7 +98,7 @@
       "name": "Meno",
       "namePlaceholder": "Zadajte názov modelu...",
       "type": "Typ",
-      "typeState": "Stav",
+      "typeState": "štátu",
       "typeObject": "Objekt",
       "objectLabel": "Označenie objektu",
       "objectLabelPlaceholder": "Vyberte typ objektu...",
@@ -118,12 +118,12 @@
         "nameOnlyNumbers": "Názov modelu nemôže obsahovať iba čísla",
         "classRequired": "Vyžaduje sa aspoň 1 kurz",
         "classesUnique": "Názvy tried musia byť jedinečné",
-        "stateRequiresTwoClasses": "Stavové modely vyžadujú aspoň 2 triedy",
+        "stateRequiresTwoClasses": "Modely štátov vyžadujú aspoň 2 triedy",
         "objectLabelRequired": "Vyberte označenie objektu",
         "objectTypeRequired": "Vyberte typ klasifikácie",
         "noneNotAllowed": "Trieda 'none' nie je povolená"
       },
-      "states": "Stavy"
+      "states": "Štátov"
     },
     "step2": {
       "description": "Vyberte kamery a definujte oblasť, ktorú chcete pre každú kameru monitorovať. Model klasifikuje stav týchto oblastí.",
@@ -134,7 +134,7 @@
     },
     "step3": {
       "selectImagesPrompt": "Vybrať všetky obrázky s: {{className}}",
-      "selectImagesDescription": "Kliknite na obrázky a vyberte ich. Po dokončení tejto triedy kliknite na tlačidlo Pokračovať.",
+      "selectImagesDescription": "Kliknite na obrázky a vyberte ich. Po dokončení tejto hodiny kliknite na tlačidlo Pokračovať.",
       "generating": {
         "title": "Generovanie vzorových obrázkov",
         "description": "Frigate načítava reprezentatívne obrázky z vašich nahrávok. Môže to chvíľu trvať..."
@@ -155,9 +155,9 @@
         "classifyFailed": "Nepodarilo sa klasifikovať obrázky: {{error}}"
       },
       "generateSuccess": "Vzorové obrázky boli úspešne vygenerované",
-      "allImagesRequired_one": "Klasifikujte všetky obrázky. Zostáva {{count}} obrázok.",
-      "allImagesRequired_few": "Klasifikujte všetky obrázky. Zostávajú {{count}} obrázky.",
-      "allImagesRequired_other": "Klasifikujte všetky obrázky. Zostáva {{count}} obrázkov.",
+      "allImagesRequired_one": "Uveďte všetky obrázky. {{count}} obrázok zostáva.",
+      "allImagesRequired_few": "Uveďte všetky obrázky. {{count}} obrázky zostávajú.",
+      "allImagesRequired_other": "Uveďte všetky obrázky. {{count}} obrázkov zostávajú.",
       "modelCreated": "Model vytvorený úspešne. Použite aktuálne klasifikácie na pridanie obrázkov pre chýbajúce stavy a nasledne dajte trénovať model.",
       "missingStatesWarning": {
         "title": "Chýbajúce príklady stavov",
@@ -174,7 +174,7 @@
   },
   "menu": {
     "objects": "Objekty",
-    "states": "Stavy"
+    "states": "Štátov"
   },
   "details": {
     "scoreInfo": "Skóre predstavuje priemernú istotu klasifikácie naprieč všetkými detekciami tohoto objektu.",

web/public/locales/sk/views/events.json

@@ -40,8 +40,8 @@
   "detail": {
     "noDataFound": "Žiadne podrobné údaje na kontrolu",
     "aria": "Prepnúť zobrazenie detailov",
-    "trackedObject_one": "{{count}} objekt",
-    "trackedObject_other": "{{count}} objektov",
+    "trackedObject_one": "objekt",
+    "trackedObject_other": "objekty",
     "noObjectDetailData": "Nie sú k dispozícii žiadne podrobné údaje o objekte.",
     "label": "Detail",
     "settings": "Nastavenia podrobného zobrazenia",

web/public/locales/sk/views/faceLibrary.json

@@ -18,12 +18,12 @@
     "title": "Nahrať obrázok tváre",
     "desc": "Nahrajte obrázok na skenovanie tvárí a zahrňte ho do {{pageToggle}}"
   },
-  "collections": "Kolekcie",
+  "collections": "Zbierky",
   "createFaceLibrary": {
     "title": "Vytvoriť Zbierku",
     "desc": "Vytvoriť novú zbierku",
     "new": "Vytvoriť novú tvár",
-    "nextSteps": "Vybudovanie silného základu:<li>Použite kartu Nedávno rozpoznané tváre na výber a trénovanie obrázkov pre každú rozpoznanú osobu.</li><li>Pre dosiahnutie najlepších výsledkov sa zamerajte na priame obrázky; vyhnite sa trénovaniu obrázkov, ktoré zachytávajú tváre pod uhlom.</li></ul>"
+    "nextSteps": "Vybudovanie silného základu:<li>Použite kartu Nedávne rozpoznania na výber a trénovanie obrázkov pre každú rozpoznanú osobu.</li><li>Pre dosiahnutie najlepších výsledkov sa zamerajte na priame obrázky; vyhnite sa trénovaniu obrázkov, ktoré zachytávajú tváre pod uhlom.</li></ul>"
   },
   "steps": {
     "faceName": "Zadajte Meno tváre",
@@ -34,8 +34,8 @@
     }
   },
   "train": {
-    "title": "Nedávno rozpoznané tváre",
-    "aria": "Vyberte nedávno rozpoznané tváre",
+    "title": "Nedávne uznania",
+    "aria": "Vyberte posledné rozpoznania",
     "empty": "Neexistujú žiadne predchádzajúce pokusy o rozpoznávanie tváre"
   },
   "selectItem": "Vyberte {{item}}",
@@ -85,10 +85,9 @@
       "deletedName_one": "{{count}} tvár bola úspešne odstránená.",
       "deletedName_few": "{{count}} tváre boli úspešne odstránené.",
       "deletedName_other": "{{count}} tvárí bolo úspešne odstránených.",
-      "renamedFace": "Tvár bola úspešne premenovaná na {{name}}.",
-      "trainedFace": "Tvár bola úspešne natrénovaná.",
-      "updatedFaceScore": "Skóre tváre bolo úspešne aktualizované na {{name}} ({{score}}).",
-      "reclassifiedFace": "Tvár bola úspešne preklasifikovaná."
+      "renamedFace": "Úspešne premenovaná tvár na {{name}}",
+      "trainedFace": "Úspešne natrénovaná tvár.",
+      "updatedFaceScore": "Úspešne aktualizované skóre tváre."
     },
     "error": {
       "uploadingImageFailed": "Nepodarilo sa nahrať obrázok: {{errorMessage}}",
@@ -96,9 +95,8 @@
       "deleteFaceFailed": "Nepodarilo sa odstrániť: {{errorMessage}}",
       "deleteNameFailed": "Nepodarilo sa odstrániť meno: {{errorMessage}}",
       "renameFaceFailed": "Nepodarilo sa premenovať tvár: {{errorMessage}}",
-      "trainFailed": "Nepodarilo sa natrénovať tvár: {{errorMessage}}",
-      "updateFaceScoreFailed": "Nepodarilo sa aktualizovať skóre tváre: {{errorMessage}}",
-      "reclassifyFailed": "Nepodarilo sa preklasifikovať tvár: {{errorMessage}}"
+      "trainFailed": "Nepodarilo sa trénovať: {{errorMessage}}",
+      "updateFaceScoreFailed": "Nepodarilo sa aktualizovať skóre tváre: {{errorMessage}}"
     }
   }
 }

web/public/locales/sk/views/settings.json

@@ -339,9 +339,9 @@
       },
       "add": "Pridať zónu",
       "edit": "Upraviť zónu",
-      "point_one": "{{count}} bod",
-      "point_few": "{{count}} body",
-      "point_other": "{{count}} bodov"
+      "point_one": "{{count}}bod",
+      "point_few": "{{count}}body",
+      "point_other": "{{count}}bodov"
     },
     "motionMasks": {
       "label": "Maska Detekcia pohybu",
@@ -380,8 +380,8 @@
       "add": "Pridať Masku Objektu",
       "edit": "Upraviť Masku Objektu",
       "context": "Masky filtrovania objektov slúžia na odfiltrovanie falošných poplachov konkrétneho typu objektu na základe jeho umiestnenia.",
-      "point_one": "{{count}} bod",
-      "point_few": "{{count}} body",
+      "point_one": "{{count}}bod",
+      "point_few": "{{count}}body",
       "point_other": "{{count}} bodov",
       "clickDrawPolygon": "Kliknutím nakreslite polygón do obrázku.",
       "objects": {
@@ -397,7 +397,7 @@
       }
     },
     "motionMaskLabel": "Maska Detekcia pohybu {{number}}",
-    "objectMaskLabel": "Maska objektu {{number}}"
+    "objectMaskLabel": "Maska Objektu {{number}} {{label}}"
   },
   "motionDetectionTuner": {
     "title": "Ladenie detekcie pohybu",

web/public/locales/sk/views/system.json

@@ -3,7 +3,7 @@
     "cameras": "Štatistiky kamier - Frigate",
     "storage": "Štatistiky úložiska - Frigate",
     "general": "Všeobecné štatistiky - Frigate",
-    "enrichments": "Štatistiky AI funkcií - Frigate",
+    "enrichments": "Štatistiky obohatenia - Frigate",
     "logs": {
       "frigate": "Protokoly Frigate - Frigate",
       "go2rtc": "Protokoly Go2RTC - Frigate",
@@ -36,7 +36,7 @@
     }
   },
   "general": {
-    "title": "Všeobecné",
+    "title": "Hlavný",
     "detector": {
       "title": "Detektory",
       "inferenceSpeed": "Detekčná rýchlosť",
@@ -96,7 +96,7 @@
     }
   },
   "storage": {
-    "title": "Úložisko",
+    "title": "Skladovanie",
     "overview": "Prehľad",
     "recordings": {
       "title": "Nahrávky",
@@ -108,11 +108,11 @@
       "warning": "Aktuálna veľkosť SHM {{total}}MB je príliš malá. Zvýšte ju aspoň na {{min_shm}}MB."
     },
     "cameraStorage": {
-      "title": "Úložisko kamier",
+      "title": "Úložisko kamery",
       "camera": "Kamera",
-      "unusedStorageInformation": "Informácie o nevyužitom úložisku",
-      "storageUsed": "Úložisko",
-      "percentageOfTotalUsed": "Percento z celku",
+      "unusedStorageInformation": "Nepoužité informácie o úložisku",
+      "storageUsed": "Skladovanie",
+      "percentageOfTotalUsed": "Percento z celkového počtu",
       "bandwidth": "Šírka pásma",
       "unused": {
         "title": "Nepoužité",
@@ -125,7 +125,7 @@
     "overview": "Prehľad",
     "info": {
       "aspectRatio": "pomer strán",
-      "cameraProbeInfo": "Údaje o kamere {{camera}}",
+      "cameraProbeInfo": "{{camera}} Informácie o sonde kamery",
       "streamDataFromFFPROBE": "Údaje zo streamu sa získavajú pomocou príkazu <code>ffprobe</code>.",
       "fetching": "Načítavajú sa údaje z kamery",
       "stream": "Stream {{idx}}",
@@ -137,33 +137,32 @@
       "audio": "Zvuk:",
       "error": "Chyba: {{error}}",
       "tips": {
-        "title": "Údaje o kamere"
+        "title": "Informácie o kamerovej sonde"
       }
     },
-    "framesAndDetections": "Snímky / Detekcie",
+    "framesAndDetections": "Rámy / Detekcie",
     "label": {
       "camera": "kamera",
-      "detect": "detekcie",
+      "detect": "odhaliť",
       "skipped": "preskočené",
       "ffmpeg": "FFmpeg",
-      "capture": "zachytávanie",
+      "capture": "zachytiť",
       "cameraFfmpeg": "{{camName}} FFmpeg",
-      "cameraCapture": "{{camName}} zachytávanie",
-      "cameraDetect": "{{camName}} detekcie",
+      "cameraCapture": "zachytiť{{camName}}",
+      "cameraDetect": "Detekcia {{camName}}",
       "overallFramesPerSecond": "celkový počet snímok za sekundu",
       "overallDetectionsPerSecond": "celkový počet detekcií za sekundu",
-      "overallSkippedDetectionsPerSecond": "celkový počet preskočených detekcií za sekundu",
+      "overallSkippedDetectionsPerSecond": "celkový počet vynechaných detekcií za sekundu",
       "cameraFramesPerSecond": "{{camName}} snímky za sekundu",
-      "cameraDetectionsPerSecond": "{{camName}} detekcie za sekundu",
-      "cameraSkippedDetectionsPerSecond": "{{camName}} preskočené detekcie za sekundu",
-      "cameraGpu": "{{camName}} GPU"
+      "cameraDetectionsPerSecond": "{{camName}}detekcie za sekundu",
+      "cameraSkippedDetectionsPerSecond": "{{camName}} vynechaných detekcií za sekundu"
     },
     "toast": {
       "success": {
-        "copyToClipboard": "Údaje o kamere boli skopírované do schránky."
+        "copyToClipboard": "Dáta sondy boli skopírované do schránky."
       },
       "error": {
-        "unableToProbeCamera": "Nepodarilo sa načítať údaje z kamery: {{errorMessage}}"
+        "unableToProbeCamera": "Nepodarilo sa overiť kameru: {{errorMessage}}"
       }
     }
   },
@@ -179,7 +178,7 @@
     "shmTooLow": "Alokácia /dev/shm ({{total}} MB) by sa mala zvýšiť aspoň na {{min}} MB."
   },
   "enrichments": {
-    "title": "AI funkcie",
+    "title": "Obohatenia",
     "infPerSecond": "Inferencie za sekundu",
     "embeddings": {
       "image_embedding": "Vkladanie obrázkov",

web/public/locales/sr/common.json

@@ -75,9 +75,5 @@
       "24hour": "MM-dd-yy-HH-mm-ss"
     }
   },
-  "readTheDocumentation": "Прочитајте документацију",
-  "menu": {
-    "system": "Систем",
-    "profiles": "Профили"
-  }
+  "readTheDocumentation": "Прочитајте документацију"
 }

web/public/locales/sv/components/dialog.json

@@ -24,9 +24,6 @@
         },
         "state": {
           "submitted": "Inskickad"
-        },
-        "toast": {
-          "error": "Misslyckades att skicka till Frigate+. Kontrollera din nätverksanslutning och försök igen."
         }
       }
     },
@@ -109,10 +106,7 @@
       "selectAll": "Välj alla kameror",
       "selectWithActivity": "Kameror med spårade objekt",
       "selectGroup": "Välj grupp",
-      "noMatchingCameras": "Ingen kamera matchar din sökning",
-      "searchOrSelectGroup": "Sök, eller välj en kameragrupp...",
-      "clearSelection": "Rensa val",
-      "selectedCount": "{{selected}} / {{total}} valda"
+      "noMatchingCameras": "Ingen kamera matchar din sökning"
     },
     "multi": {
       "title_one": "Exportera 1 recension",

web/public/locales/sv/config/cameras.json

@@ -20,35 +20,10 @@
             "description": "Aktivera eller avaktivera ljudbaserad detektering för denna kamera."
         },
         "max_not_heard": {
-            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar.",
-            "label": "Avbryt paus"
+            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar."
         },
         "min_volume": {
-            "label": "Minsta ljudvolym",
-            "description": "Lägsta RMS volym för ljuddetektion; lägre värde ökar känslighet (t.e.x. 200 högt, 500 medium, 1000 lågt)."
-        },
-        "listen": {
-            "label": "Lyssningstyper",
-            "description": "Lista på typer av ljudevent att detektera (till exempel: skälla, brandlarm, tal, skrik)."
-        },
-        "filters": {
-            "label": "Ljudfilter",
-            "description": "Filterinställningar per ljudtyp, till exempel konfidinströskel som används för att minska falska positiva resultat.",
-            "threshold": {
-                "label": "Lägsta ljud-konfidinströskel",
-                "description": "Lägsta konfidinströskel för att ljudhändelsen ska räknas."
-            }
-        },
-        "enabled_in_config": {
-            "label": "Ursprungligt ljudtillstånd",
-            "description": "Indikerar om ljuddetektion ursprungligen var aktiverat i den statiska konfigurationsfilen."
-        },
-        "num_threads": {
-            "label": "Detekteringstrådar",
-            "description": "Antal trådar att använda för bearbetning av ljuddetektering."
+            "label": "Minsta ljudvolym"
         }
-    },
-    "audio_transcription": {
-        "label": "Ljudtranskribering"
     }
 }

web/public/locales/sv/config/global.json

@@ -8,35 +8,10 @@
             "label": "Aktivera ljuddetektering"
         },
         "max_not_heard": {
-            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar.",
-            "label": "Avbryt paus"
+            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar."
         },
         "min_volume": {
-            "label": "Minsta ljudvolym",
-            "description": "Lägsta RMS volym för ljuddetektion; lägre värde ökar känslighet (t.e.x. 200 högt, 500 medium, 1000 lågt)."
-        },
-        "listen": {
-            "label": "Lyssningstyper",
-            "description": "Lista på typer av ljudevent att detektera (till exempel: skälla, brandlarm, tal, skrik)."
-        },
-        "filters": {
-            "label": "Ljudfilter",
-            "description": "Filterinställningar per ljudtyp, till exempel konfidinströskel som används för att minska falska positiva resultat.",
-            "threshold": {
-                "label": "Lägsta ljud-konfidinströskel",
-                "description": "Lägsta konfidinströskel för att ljudhändelsen ska räknas."
-            }
-        },
-        "enabled_in_config": {
-            "label": "Ursprungligt ljudtillstånd",
-            "description": "Indikerar om ljuddetektion ursprungligen var aktiverat i den statiska konfigurationsfilen."
-        },
-        "num_threads": {
-            "label": "Detekteringstrådar",
-            "description": "Antal trådar att använda för bearbetning av ljuddetektering."
+            "label": "Minsta ljudvolym"
         }
-    },
-    "audio_transcription": {
-        "label": "Ljudtranskribering"
     }
 }

web/public/locales/tr/components/dialog.json

@@ -30,9 +30,6 @@
           "label": "Bu etiketi Frigate+ için onaylayın",
           "ask_a": "Bu nesne bir <code>{{label}}</code> mi?",
           "ask_full": "Bu nesne bir <code>{{untranslatedLabel}}</code> ({{translatedLabel}}) nesnesi mi?"
-        },
-        "toast": {
-          "error": "Frigate+'a gönderilemedi. Lütfen ağ bağlantınızı kontrol edin ve tekrar deneyin."
         }
       },
       "submitToPlus": {
@@ -65,7 +62,7 @@
     "toast": {
       "success": "Dışa aktarma başarıyla başlatıldı. Dosyayı dışa aktarmalar sayfasında görüntüleyebilirsiniz.",
       "error": {
-        "failed": "Dışa aktarım sıraya alınamadı: {{error}}",
+        "failed": "Dışa aktarım başlatılamadı: {{error}}",
         "endTimeMustAfterStartTime": "Bitiş zamanı başlangıç zamanından sonra olmalıdır",
         "noVaildTimeSelected": "Geçerli bir zaman aralığı seçilmedi"
       },

web/public/locales/zh-CN/common.json

@@ -239,7 +239,7 @@
       "label": "主题",
       "blue": "蓝色",
       "green": "绿色",
-      "nord": "极地蓝",
+      "nord": "Nord",
       "red": "红色",
       "contrast": "高对比度",
       "default": "默认",

web/public/locales/zh-CN/components/dialog.json

@@ -67,8 +67,7 @@
       "error": {
         "failed": "未能加入导出队列：{{error}}",
         "endTimeMustAfterStartTime": "结束时间必须在开始时间之后",
-        "noVaildTimeSelected": "未选择有效的时间范围",
-        "noValidTimeSelected": "未选择有效的时间范围"
+        "noVaildTimeSelected": "未选择有效的时间范围"
       },
       "view": "查看",
       "queued": "导出已加入队列。请在导出页面查看进度。",

web/public/locales/zh-CN/components/filter.json

@@ -99,7 +99,7 @@
     "label": "日志级别筛选",
     "filterBySeverity": "按严重程度筛选日志",
     "loading": {
-      "title": "实时加载",
+      "title": "加载中",
       "desc": "当日志面板滚动到底部时，新的日志会自动流式加载。"
     },
     "disableLogStreaming": "禁用日志流式加载",

web/public/locales/zh-CN/config/cameras.json

@@ -314,12 +314,12 @@
             "description": "画面变动轮廓被计入所需的最小轮廓区域（像素）。"
         },
         "delta_alpha": {
-            "label": "变化量权重",
-            "description": "该值用于调节帧间差异计算时的混合比例，影响运动检测的灵敏度。"
+            "label": "Delta alpha",
+            "description": "用于画面变动计算的帧差异中使用的 alpha 混合因子。"
         },
         "frame_alpha": {
-            "label": "背景更新速度",
-            "description": "该值在运动检测前对画面进行预处理，控制帧混合程度，影响后续检测的输入质量。"
+            "label": "画面 alpha 通道",
+            "description": "画面变动预处理时混合画面所使用的 alpha 值。"
         },
         "frame_height": {
             "label": "画面高度",
@@ -452,15 +452,15 @@
         },
         "continuous": {
             "label": "持续保留",
-            "description": "无论是否有追踪目标或画面变动，保留录像的天数。如果只想保留警报和检测的录制，请设置为 0。",
+            "description": "无论是否有追踪目标或动作，保留录像的天数。如果只想保留警报和检测的录像，请设置为 0。",
             "days": {
                 "label": "保留天数",
                 "description": "保留录像的天数。"
             }
         },
         "motion": {
-            "label": "画面变动录制保留",
-            "description": "无论是否有追踪目标，只要画面变动触发保存的录制保留天数。如果只想保留警报和检测的录制，请设置为 0。",
+            "label": "动作保留",
+            "description": "无论是否有追踪目标，由动作触发的录像保留天数。如果只想保留警报和检测的录像，请设置为 0。",
             "days": {
                 "label": "保留天数",
                 "description": "保留录像的天数。"
@@ -486,7 +486,7 @@
                 },
                 "mode": {
                     "label": "保留模式",
-                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
+                    "description": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
                 }
             }
         },
@@ -510,7 +510,7 @@
                 },
                 "mode": {
                     "label": "保留模式",
-                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
+                    "description": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
                 }
             }
         },

web/public/locales/zh-CN/config/global.json

@@ -1507,10 +1507,10 @@
     },
     "motion": {
         "label": "画面变动检测",
-        "description": "默认情况下，画面变动检测配置统一应用于各摄像头，除非对特定摄像头单独进行自定义。",
+        "description": "应用于摄像头的默认动作检测设置，除非按摄像头覆盖。",
         "enabled": {
             "label": "开启画面变动检测",
-            "description": "为所有摄像头启用或禁用画面变动检测。可以给指定摄像头单独覆盖此设置。"
+            "description": "为所有摄像头启用或禁用动作检测；可按摄像头覆盖。"
         },
         "threshold": {
             "label": "画面变动阈值",
@@ -1533,12 +1533,12 @@
             "description": "画面变动轮廓被计入所需的最小轮廓区域（像素）。"
         },
         "delta_alpha": {
-            "label": "变化量权重",
-            "description": "该值用于调节帧间差异计算时的混合比例，影响运动检测的灵敏度。"
+            "label": "Delta alpha",
+            "description": "用于画面变动计算的帧差异中使用的 alpha 混合因子。"
         },
         "frame_alpha": {
-            "label": "背景更新速度",
-            "description": "该值在运动检测前对画面进行预处理，控制帧混合程度，影响后续检测的输入质量。"
+            "label": "画面 alpha 通道",
+            "description": "画面变动预处理时混合画面所使用的 alpha 值。"
         },
         "frame_height": {
             "label": "画面高度",
@@ -1706,15 +1706,15 @@
         },
         "continuous": {
             "label": "持续保留",
-            "description": "无论是否有追踪目标或画面变动，保留录像的天数。如果只想保留警报和检测的录制，请设置为 0。",
+            "description": "无论是否有追踪目标或动作，保留录像的天数。如果只想保留警报和检测的录像，请设置为 0。",
             "days": {
                 "label": "保留天数",
                 "description": "保留录像的天数。"
             }
         },
         "motion": {
-            "label": "画面变动录制保留",
-            "description": "无论是否有追踪目标，只要画面变动触发保存的录制保留天数。如果只想保留警报和检测的录制，请设置为 0。",
+            "label": "动作保留",
+            "description": "无论是否有追踪目标，由动作触发的录像保留天数。如果只想保留警报和检测的录像，请设置为 0。",
             "days": {
                 "label": "保留天数",
                 "description": "保留录像的天数。"
@@ -1740,7 +1740,7 @@
                 },
                 "mode": {
                     "label": "保留模式",
-                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
+                    "description": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
                 }
             }
         },
@@ -1764,7 +1764,7 @@
                 },
                 "mode": {
                     "label": "保留模式",
-                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
+                    "description": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
                 }
             }
         },
@@ -2030,8 +2030,8 @@
                     }
                 },
                 "motion": {
-                    "label": "画面变动时运行",
-                    "description": "启用后，当在指定裁剪区域内检测到画面变动时进行分类。"
+                    "label": "动作时运行",
+                    "description": "启用后，当在指定裁剪区域内检测到动作时运行分类。"
                 },
                 "interval": {
                     "label": "分类间隔",

web/public/locales/zh-CN/views/classificationModel.json

@@ -178,20 +178,7 @@
     "title": "编辑分类模型",
     "descriptionState": "编辑此状态分类模型的类别；更改后需要重新训练模型。",
     "descriptionObject": "编辑此目标分类模型的目标类型和分类类型。",
-    "stateClassesInfo": "模型已更新。请重新训练模型以使类别更改生效。",
-    "enabled": "开启",
-    "enabledDesc": "运行此模型。禁用后，它将停止运行且不再进行分类。",
-    "saveAttempts": "保存尝试",
-    "saveAttemptsDesc": "保存在近期分类记录界面中显示的分类快照数量。",
-    "motion": "画面变动时运行",
-    "motionDesc": "检测到配置的裁剪区域内发生移动时，运行分类。",
-    "interval": "间隔",
-    "intervalDesc": "定期分类运行之间的间隔秒数。留空则仅在检测到移动时运行。",
-    "intervalPlaceholder": "无间隔",
-    "errors": {
-      "saveAttemptsInvalid": "保存在近期分类记录数量必须是大于或等于 0 的整数",
-      "intervalInvalid": "间隔必须是大于 0 的整数"
-    }
+    "stateClassesInfo": "注意：更改状态类别后需使用更新后的类别重新训练模型。"
   },
   "tooltip": {
     "trainingInProgress": "模型正在训练中",
@@ -201,6 +188,5 @@
   },
   "none": "无标签",
   "reclassifyImageAs": "重新分类图片为：",
-  "reclassifyImage": "重新分类图片",
-  "disabled": "关闭"
+  "reclassifyImage": "重新分类图片"
 }

web/public/locales/zh-CN/views/settings.json

@@ -1655,14 +1655,7 @@
       "keyLabel": "键",
       "valueLabel": "值",
       "keyPlaceholder": "新键名",
-      "remove": "移除",
-      "providerNameLabel": "提供商名称",
-      "providerNamePlaceholder": "例如：openai、deepseek",
-      "variableNameLabel": "变量名",
-      "variableNamePlaceholder": "例如：MY_VARIABLE",
-      "loggerNameLabel": "日志模块名称",
-      "loggerNamePlaceholder": "例如：frigate.record",
-      "keyPatternError": "只能使用字母、数字、连字符和下划线（不包含空格）"
+      "remove": "移除"
     },
     "roleMap": {
       "empty": "未配置权限组映射",
@@ -2181,7 +2174,7 @@
   },
   "review": {
     "imageSource": {
-      "recordings": "录制",
+      "recordings": "录制文件",
       "previews": "预览"
     }
   },

web/public/locales/zh-Hant/components/dialog.json

@@ -59,8 +59,7 @@
       "error": {
         "failed": "匯出失敗：{{error}}",
         "endTimeMustAfterStartTime": "結束時間必須要在開始時間之後",
-        "noVaildTimeSelected": "沒有選取有效的時間範圍",
-        "noValidTimeSelected": "未選擇有效的時間範圍"
+        "noVaildTimeSelected": "沒有選取有效的時間範圍"
       },
       "view": "查看",
       "queued": "匯出已加入佇列。請在匯出頁面檢視進度。",

web/public/locales/zh-Hant/config/cameras.json

@@ -497,9 +497,6 @@
             "max_concurrent": {
                 "label": "最大併發匯出數",
                 "description": "同時可處理的最大匯出任務數量。"
-            },
-            "chapters": {
-                "label": "匯出錄影時要嵌入的章節資訊"
             }
         },
         "preview": {

web/public/locales/zh-Hant/config/global.json

@@ -1043,9 +1043,6 @@
             "max_concurrent": {
                 "label": "最大併發匯出數",
                 "description": "同時可處理的最大匯出任務數量。"
-            },
-            "chapters": {
-                "label": "匯出錄影時要嵌入的章節資訊"
             }
         },
         "preview": {

web/public/locales/zh-Hant/views/settings.json

@@ -1484,14 +1484,7 @@
       "keyLabel": "鍵",
       "valueLabel": "值",
       "keyPlaceholder": "新鍵名",
-      "remove": "移除",
-      "providerNameLabel": "服務提供者名稱",
-      "providerNamePlaceholder": "例如：openai",
-      "variableNameLabel": "變數名稱",
-      "variableNamePlaceholder": "例如：MY_VARIABLE",
-      "loggerNameLabel": "日誌名稱",
-      "loggerNamePlaceholder": "例如：frigate.record",
-      "keyPatternError": "僅能使用英文字母、數字、連字號（-）和底線（_），且不得包含空格"
+      "remove": "移除"
     },
     "knownPlates": {
       "namePlaceholder": "例如：老婆的車",

web/src/components/config-form/sectionExtras/BirdseyeCameraReorder.tsx

@@ -91,7 +91,6 @@ export default function BirdseyeCameraReorder({
     try {
       await axios.put("config/set", {
         requires_restart: 0,
-        update_topic: "config/cameras/*/birdseye",
         config_data: { cameras: cameraUpdates },
       });
       await updateConfig();

web/src/components/icons/IconPicker.tsx

@@ -153,15 +153,11 @@ export default function IconPicker({
 }
 
 type IconRendererProps = {
-  icon: IconType | undefined;
+  icon: IconType;
   size?: number;
   className?: string;
 };
 
 export function IconRenderer({ icon, size, className }: IconRendererProps) {
-  if (!icon) {
-    return null;
-  }
-
   return <>{React.createElement(icon, { size, className })}</>;
 }

web/src/components/overlay/ExportDialog.tsx

@@ -65,7 +65,6 @@ import { Textarea } from "../ui/textarea";
 import { useNavigate } from "react-router-dom";
 import { useIsAdmin } from "@/hooks/use-is-admin";
 import { isReplayCamera } from "@/utils/cameraUtil";
-import { isValidIconName } from "@/utils/iconUtil";
 
 const EXPORT_OPTIONS = [
   "1",
@@ -1067,11 +1066,7 @@ export function ExportContent({
                                 }
                               >
                                 <IconRenderer
-                                  icon={
-                                    isValidIconName(group.icon)
-                                      ? LuIcons[group.icon]
-                                      : LuIcons.LuFolder
-                                  }
+                                  icon={LuIcons[group.icon]}
                                   className="mr-2 size-4 text-secondary-foreground"
                                 />
                                 <span className="truncate">{group.name}</span>

web/src/views/system/GeneralMetrics.tsx

@@ -470,6 +470,50 @@ export default function GeneralMetrics({
     return Object.keys(series).length > 0 ? Object.values(series) : undefined;
   }, [statsHistory]);
 
+  // Check if Intel GPU has all 0% usage values (known bug)
+  const showIntelGpuWarning = useMemo(() => {
+    if (!statsHistory || statsHistory.length < 3) {
+      return false;
+    }
+
+    const hasIntelGpu = Object.values(statsHistory[0]?.gpu_usages ?? {}).some(
+      (stats) => stats.vendor === "intel",
+    );
+
+    if (!hasIntelGpu) {
+      return false;
+    }
+
+    // Check if all GPU usage values are 0% across all stats
+    let allZero = true;
+    let hasDataPoints = false;
+
+    for (const stats of statsHistory) {
+      if (!stats) {
+        continue;
+      }
+
+      Object.values(stats.gpu_usages || {}).forEach((gpuStats) => {
+        if (gpuStats.vendor !== "intel") {
+          return;
+        }
+        if (gpuStats.gpu) {
+          hasDataPoints = true;
+          const gpuValue = parseFloat(gpuStats.gpu.slice(0, -1));
+          if (!isNaN(gpuValue) && gpuValue > 0) {
+            allZero = false;
+          }
+        }
+      });
+
+      if (!allZero) {
+        break;
+      }
+    }
+
+    return hasDataPoints && allZero;
+  }, [statsHistory]);
+
   // npu stats
 
   const npuSeries = useMemo(() => {
@@ -775,8 +819,46 @@ export default function GeneralMetrics({
                 <>
                   {statsHistory.length != 0 ? (
                     <div className="rounded-lg bg-background_alt p-2.5 md:rounded-2xl">
-                      <div className="mb-5">
+                      <div className="mb-5 flex flex-row items-center justify-between">
                         {t("general.hardwareInfo.gpuUsage")}
+                        {showIntelGpuWarning && (
+                          <Popover>
+                            <PopoverTrigger asChild>
+                              <button
+                                className="flex flex-row items-center gap-1.5 text-yellow-600 focus:outline-none dark:text-yellow-500"
+                                aria-label={t(
+                                  "general.hardwareInfo.intelGpuWarning.title",
+                                )}
+                              >
+                                <CiCircleAlert
+                                  className="size-5"
+                                  aria-label={t(
+                                    "general.hardwareInfo.intelGpuWarning.title",
+                                  )}
+                                />
+                                <span className="text-sm">
+                                  {t(
+                                    "general.hardwareInfo.intelGpuWarning.message",
+                                  )}
+                                </span>
+                              </button>
+                            </PopoverTrigger>
+                            <PopoverContent className="w-80">
+                              <div className="space-y-2">
+                                <div className="font-semibold">
+                                  {t(
+                                    "general.hardwareInfo.intelGpuWarning.title",
+                                  )}
+                                </div>
+                                <div>
+                                  {t(
+                                    "general.hardwareInfo.intelGpuWarning.description",
+                                  )}
+                                </div>
+                              </div>
+                            </PopoverContent>
+                          </Popover>
+                        )}
                       </div>
                       {gpuSeries.map((series) => (
                         <ThresholdBarGraph