Merge 28a9f81eb7 into c406a93d3d

Miscellaneous fixes (0.18 beta) (#23725 )
Translated using Weblate (Norwegian Bokmål)
2026-08-10 21:01:10 +03:00 · 2026-07-16 03:13:44 -07:00 · 2026-07-15 18:49:05 -06:00 · 2026-07-15 04:05:16 +00:00 · 2026-07-15 04:05:15 +00:00 · 2026-07-15 04:05:14 +00:00
125 changed files with 6281 additions and 682 deletions
@@ -12,6 +12,7 @@ config/*
 models
 *.mp4
 *.db
+*.db-*
 *.csv
 frigate/version.py
 web/build
@@ -274,6 +274,13 @@ http {
                include proxy.conf;
            }

+            location /api/logout {
+                auth_request off;
+                rewrite ^/api(/.*)$ $1 break;
+                proxy_pass http://frigate_api;
+                include proxy.conf;
+            }
+
            # Allow unauthenticated access to the first_time_login endpoint
            # so the login page can load help text before authentication.
            location /api/auth/first_time_login {
@@ -67,6 +67,12 @@ This section can be used to set environment variables for those unable to modify

 Variables prefixed with `FRIGATE_` can be referenced in config fields that support environment variable substitution (such as MQTT host and credentials, camera stream URLs, and ONVIF host and credentials) using the `{FRIGATE_VARIABLE_NAME}` syntax.

+:::note
+
+The `go2rtc` section is an exception. go2rtc runs as a separate process, so its stream definitions can only be substituted with variables that exist in the container's environment (set via Docker `-e`, the `environment:` section of `docker-compose.yml`, or Docker secrets). Variables defined in the `environment_vars` block above are not available to go2rtc streams. Home Assistant app users, who cannot set container environment variables, must instead put credentials directly in their go2rtc stream URLs.
+
+:::
+
 <ConfigTabs>
 <TabItem value="ui">

@@ -6,6 +6,7 @@ title: Live View
 import ConfigTabs from "@site/src/components/ConfigTabs";
 import TabItem from "@theme/TabItem";
 import NavPath from "@site/src/components/NavPath";
+import FaqItem from "@site/src/components/FaqItem";

 Frigate intelligently displays your camera streams on the Live view dashboard. By default, Frigate employs "smart streaming" where camera images update once per minute when no detectable activity is occurring to conserve bandwidth and resources. As soon as any motion or active objects are detected, cameras seamlessly switch to a live stream.

@@ -341,100 +342,155 @@ When your browser runs into problems playing back your camera streams, it will l

 ## Live view FAQ

-1. **Why don't I have audio in my Live view?**
+### Getting Live View Working

-   You must use go2rtc to hear audio in your live streams. If you have go2rtc already configured, you need to ensure your camera is sending PCMA/PCMU or AAC audio. If you can't change your camera's audio codec, you need to [transcode the audio](https://github.com/AlexxIT/go2rtc?tab=readme-ov-file#source-ffmpeg) using go2rtc.
+<FaqItem id="why-dont-i-have-audio-in-my-live-view" question="Why don't I have audio in my Live view?">

-   Note that the low bandwidth mode player is a video-only stream. You should not expect to hear audio when in low bandwidth mode, even if you've set up go2rtc.
+You must use go2rtc to hear audio in your live streams. If you have go2rtc already configured, you need to ensure your camera is sending PCMA/PCMU or AAC audio. If you can't change your camera's audio codec, you need to [transcode the audio](https://github.com/AlexxIT/go2rtc?tab=readme-ov-file#source-ffmpeg) using go2rtc.

-2. **Frigate shows that my live stream is in "low bandwidth mode". What does this mean?**
+If the audio controls don't appear in the UI at all, verify that the Live view is actually using your go2rtc stream. If your go2rtc stream names don't match your Frigate camera name, you must map them with the `live -> streams` config (see [Setting Streams For Live UI](#setting-streams-for-live-ui) above); otherwise the UI falls back to the video-only jsmpeg player.

-   Frigate intelligently selects the live streaming technology based on a number of factors (user-selected modes like two-way talk, camera settings, browser capabilities, available bandwidth) and prioritizes showing an actual up-to-date live view of your camera's stream as quickly as possible.
+Note that the low bandwidth mode player is a video-only stream. You should not expect to hear audio when in low bandwidth mode, even if you've set up go2rtc.

-   When you have go2rtc configured, Live view initially attempts to load and play back your stream with a clearer, fluent stream technology (MSE). An initial timeout, a low bandwidth condition that would cause buffering of the stream, or decoding errors in the stream will cause Frigate to switch to the stream defined by the `detect` role, using the jsmpeg format. This is what the UI labels as "low bandwidth mode". On Live dashboards, the mode will automatically reset when smart streaming is configured and activity stops. Continuous streaming mode does not have an automatic reset mechanism, but you can use the _Reset_ option to force a reload of your stream.
+</FaqItem>

-   If you are using continuous streaming or you are loading more than a few high resolution streams at once on the dashboard, your browser may struggle to begin playback of your streams before the timeout. Frigate always prioritizes showing a live stream as quickly as possible, even if it is a lower quality jsmpeg stream. You can use the "Reset" link/button to try loading your high resolution stream again.
+<FaqItem id="i-have-unmuted-some-cameras-on-my-dashboard-but-i-do-not-hear-sound-why" question="I have unmuted some cameras on my dashboard, but I do not hear sound. Why?">

-   Errors in stream playback (e.g., connection failures, codec issues, or buffering timeouts) that cause the fallback to low bandwidth mode (jsmpeg) are logged to the browser console for easier debugging. These errors may include:
-   - Network issues (e.g., MSE or WebRTC network connection problems).
-   - Unsupported codecs or stream formats (e.g., H.265 in WebRTC, which is not supported in some browsers).
-   - Buffering timeouts or low bandwidth conditions causing fallback to jsmpeg.
-   - Browser compatibility problems (e.g., iOS Safari limitations with MSE).
+If your camera is streaming (as indicated by a red dot in the upper right, or if it has been set to continuous streaming mode), your browser may be blocking audio until you interact with the page. This is an intentional browser limitation. See [this article](https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide#autoplay_availability). Many browsers have a whitelist feature to change this behavior.

-   To view browser console logs:
-   1. Open the Frigate Live View in your browser.
-   2. Open the browser's Developer Tools (F12 or right-click > Inspect > Console tab).
-   3. Reproduce the error (e.g., load a problematic stream or simulate network issues).
-   4. Look for messages prefixed with the camera name.
+</FaqItem>

-   These logs help identify if the issue is player-specific (MSE vs. WebRTC) or related to camera configuration (e.g., go2rtc streams, codecs). If you see frequent errors:
-   - Verify your camera's H.264/AAC settings (see [Frigate's camera settings recommendations](#camera-settings-recommendations)).
-   - Check go2rtc configuration for transcoding (e.g., audio to AAC/OPUS).
-   - Test with a different stream via the UI dropdown (if `live -> streams` is configured).
-   - For WebRTC-specific issues, ensure port 8555 is forwarded and candidates are set (see [WebRTC Extra Configuration](#webrtc-extra-configuration)).
-   - If your cameras are streaming at a high resolution, your browser may be struggling to load all of the streams before the buffering timeout occurs. Frigate prioritizes showing a true live view as quickly as possible. If the fallback occurs often, change your live view settings to use a lower bandwidth substream.
+<FaqItem id="my-live-view-shows-a-black-screen-or-doesnt-load-but-the-debug-view-works-why" question="My live view shows a black screen or doesn't load, but the debug view works. Why?">

-3. **It doesn't seem like my cameras are streaming on the Live dashboard. Why?**
+The debug view plays the `detect` stream processed by Frigate itself, while the Live view plays your go2rtc stream directly in the browser. If the debug view works but the Live view doesn't, your browser usually can't decode what the camera is sending, most often H.265 video or an incompatible audio track.

-   On the default Live dashboard ("All Cameras"), your camera images will update once per minute when no detectable activity is occurring to conserve bandwidth and resources. As soon as any activity is detected, cameras seamlessly switch to a full-resolution live stream. If you want to customize this behavior, use a camera group.
+Work through the [go2rtc troubleshooting guide](/troubleshooting/go2rtc#live-view-is-black-buffering-or-stuck-in-low-bandwidth-mode) to isolate the problem. Two fixes resolve the majority of cases:

-4. **I see a strange diagonal line on my live view, but my recordings look fine. How can I fix it?**
+1. Restream through go2rtc's FFmpeg module by prefixing your source with `ffmpeg:`, for example `- ffmpeg:rtsp://user:password@192.168.1.5:554/stream`.
+2. If that doesn't help, transcode to compatible codecs: `- ffmpeg:rtsp://user:password@192.168.1.5:554/stream#video=h264#audio=aac#hardware`.

-   This is caused by incorrect dimensions set in your detect width or height (or incorrectly auto-detected), causing the jsmpeg player's rendering engine to display a slightly distorted image. You should enlarge the width and height of your `detect` resolution up to a standard aspect ratio (example: 640x352 becomes 640x360, and 800x443 becomes 800x450, 2688x1520 becomes 2688x1512, etc). If changing the resolution to match a standard (4:3, 16:9, or 32:9, etc) aspect ratio does not solve the issue, you can enable "compatibility mode" in your camera group dashboard's stream settings. Depending on your browser and device, more than a few cameras in compatibility mode may not be supported, so only use this option if changing your `detect` width and height fails to resolve the color artifacts and diagonal line.
+</FaqItem>

-5. **How does "smart streaming" work?**
+<FaqItem id="how-do-i-get-the-best-live-view-experience-in-home-assistant" question="How do I get the best live view experience in Home Assistant?">

-   Because a static image of a scene looks exactly the same as a live stream with no motion or activity, smart streaming updates your camera images once per minute when no detectable activity is occurring to conserve bandwidth and resources. As soon as any activity (motion or object/audio detection) occurs, cameras seamlessly switch to a live stream.
+For a full-resolution, low-latency live view in Home Assistant dashboards, use the [Advanced Camera Card](https://card.camera) with the [go2rtc live provider](https://card.camera/#/configuration/cameras/live-provider?id=go2rtc), which streams directly from Frigate's bundled go2rtc. This also supports audio and [two-way talk](#two-way-talk) on capable cameras. See the [Home Assistant integration docs](/integrations/home-assistant) for setup.

-   This static image is pulled from the stream defined in your config with the `detect` role. When activity is detected, images from the `detect` stream immediately begin updating at ~5 frames per second so you can see the activity until the live player is loaded and begins playing. This usually only takes a second or two. If the live player times out, buffers, or has streaming errors, the jsmpeg player is loaded and plays a video-only stream from the `detect` role. When activity ends, the players are destroyed and a static image is displayed until activity is detected again, and the process repeats.
+</FaqItem>

-   Smart streaming depends on having your camera's motion `threshold` and `contour_area` config values dialed in. Use the Motion Tuner in Settings in the UI to tune these values in real-time.
+### Streaming Behavior

-   This is Frigate's default and recommended setting because it results in a significant bandwidth savings, especially for high resolution cameras.
+<FaqItem id="how-does-smart-streaming-work" question={'How does "smart streaming" work?'}>

-6. **I have unmuted some cameras on my dashboard, but I do not hear sound. Why?**
+Because a static image of a scene looks exactly the same as a live stream with no motion or activity, smart streaming updates your camera images once per minute when no detectable activity is occurring to conserve bandwidth and resources. As soon as any activity (motion or object/audio detection) occurs, cameras seamlessly switch to a live stream.

-   If your camera is streaming (as indicated by a red dot in the upper right, or if it has been set to continuous streaming mode), your browser may be blocking audio until you interact with the page. This is an intentional browser limitation. See [this article](https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide#autoplay_availability). Many browsers have a whitelist feature to change this behavior.
+This static image is pulled from the stream defined in your config with the `detect` role. When activity is detected, images from the `detect` stream immediately begin updating at ~5 frames per second so you can see the activity until the live player is loaded and begins playing. This usually only takes a second or two. If the live player times out, buffers, or has streaming errors, the jsmpeg player is loaded and plays a video-only stream from the `detect` role. When activity ends, the players are destroyed and a static image is displayed until activity is detected again, and the process repeats.

-7. **My camera streams have lots of visual artifacts / distortion.**
+Smart streaming depends on having your camera's motion `threshold` and `contour_area` config values dialed in. Use the Motion Tuner in Settings in the UI to tune these values in real-time.

-   Some cameras don't include the hardware to support multiple connections to the high resolution stream, and this can cause unexpected behavior. In this case it is recommended to [restream](./restream.md) the high resolution stream so that it can be used for live view and recordings.
+This is Frigate's default and recommended setting because it results in a significant bandwidth savings, especially for high resolution cameras.

-8. **Why does my camera stream switch aspect ratios on the Live dashboard?**
+</FaqItem>

-   Your camera may change aspect ratios on the dashboard because Frigate uses different streams for different purposes. With go2rtc and Smart Streaming, Frigate shows a static image from the `detect` stream when no activity is present, and switches to the live stream when motion is detected. The camera image will change size if your streams use different aspect ratios.
+<FaqItem id="it-doesnt-seem-like-my-cameras-are-streaming-on-the-live-dashboard-why" question="It doesn't seem like my cameras are streaming on the Live dashboard. Why?">

-   To prevent this, make the `detect` stream match the go2rtc live stream's aspect ratio (resolution does not need to match, just the aspect ratio). You can either adjust the camera's output resolution or set the `width` and `height` values in your config's `detect` section to a resolution with an aspect ratio that matches.
+On the default Live dashboard ("All Cameras"), your camera images will update once per minute when no detectable activity is occurring to conserve bandwidth and resources. As soon as any activity is detected, cameras seamlessly switch to a full-resolution live stream. If you want to customize this behavior, use a camera group.

-   Example: Resolutions from two streams
-   - Mismatched (may cause aspect ratio switching on the dashboard):
-     - Live/go2rtc stream: 1920x1080 (16:9)
-     - Detect stream: 640x352 (~1.82:1, not 16:9)
+</FaqItem>

-   - Matched (prevents switching):
-     - Live/go2rtc stream: 1920x1080 (16:9)
-     - Detect stream: 640x360 (16:9)
+<FaqItem id="frigate-shows-that-my-live-stream-is-in-low-bandwidth-mode-what-does-this-mean" question={'Frigate shows that my live stream is in "low bandwidth mode". What does this mean?'}>

-   You can update the detect settings in your camera config to match the aspect ratio of your go2rtc live stream. For example:
+Frigate intelligently selects the live streaming technology based on a number of factors (user-selected modes like two-way talk, camera settings, browser capabilities, available bandwidth) and prioritizes showing an actual up-to-date live view of your camera's stream as quickly as possible.

-   ```yaml
-   cameras:
-     front_door:
-       detect:
-         width: 640
-         height: 360 # set this to 360 instead of 352
-       ffmpeg:
-         inputs:
-           - path: rtsp://127.0.0.1:8554/front_door # main stream 1920x1080
-             roles:
-               - record
-           - path: rtsp://127.0.0.1:8554/front_door_sub # sub stream 640x352
-             roles:
-               - detect
-   ```
+When you have go2rtc configured, Live view initially attempts to load and play back your stream with a clearer, fluent stream technology (MSE). An initial timeout, a low bandwidth condition that would cause buffering of the stream, or decoding errors in the stream will cause Frigate to switch to the stream defined by the `detect` role, using the jsmpeg format. This is what the UI labels as "low bandwidth mode". On Live dashboards, the mode will automatically reset when smart streaming is configured and activity stops. Continuous streaming mode does not have an automatic reset mechanism, but you can use the _Reset_ option to force a reload of your stream.

-   The same applies to your `record` stream: if its aspect ratio differs from your `detect` stream, your recordings will appear in a different shape than the live view. For consistent framing across live view and recordings, use the same aspect ratio for all of a camera's streams (the resolution can still differ).
+If you are using continuous streaming or you are loading more than a few high resolution streams at once on the dashboard, your browser may struggle to begin playback of your streams before the timeout. Frigate always prioritizes showing a live stream as quickly as possible, even if it is a lower quality jsmpeg stream. You can use the "Reset" link/button to try loading your high resolution stream again.

-9. **Why does Frigate prefer MSE over WebRTC for live view?**
+Errors in stream playback (e.g., connection failures, codec issues, or buffering timeouts) that cause the fallback to low bandwidth mode (jsmpeg) are logged to the browser console for easier debugging. These errors may include:

-   Frigate prefers MSE because it delivers a better out-of-the-box experience than WebRTC on nearly every axis that matters for a security camera system. MSE is an open standard optimized and supported by all modern browsers, works without any extra configuration (WebRTC requires port forwarding and candidate setup, and lacks H.265 support in some browsers), and requires no internet access for NAT traversal. More importantly, MSE runs over TCP, so every frame arrives and is decoded in order, so nothing is ever silently skipped. WebRTC optimizes for latency over UDP by discarding late or incomplete frames, which works against you on cellular or spotty Wi-Fi: you can end up with frozen video, visual corruption, or gaps in the feed without ever knowing you missed something. Frigate's enhanced MSE player has adaptive speed playback and has been tuned for latency and connection robustness that meets or exceeds WebRTC, so you get near-real-time playback with a guarantee that when the video plays, every frame is actually there - which, for an NVR whose whole purpose is letting you see what happened, matters more than shaving fractions of a second off a latency number. That's why Frigate defaults to MSE and reserves WebRTC for cases that require it, like two-way talk.
+- Network issues (e.g., MSE or WebRTC network connection problems).
+- Unsupported codecs or stream formats (e.g., H.265 in WebRTC, which is not supported in some browsers).
+- Buffering timeouts or low bandwidth conditions causing fallback to jsmpeg.
+- Browser compatibility problems (e.g., iOS Safari limitations with MSE).
+
+To view browser console logs:
+
+1. Open the Frigate Live View in your browser.
+2. Open the browser's Developer Tools (F12 or right-click > Inspect > Console tab).
+3. Reproduce the error (e.g., load a problematic stream or simulate network issues).
+4. Look for messages prefixed with the camera name.
+
+These logs help identify if the issue is player-specific (MSE vs. WebRTC) or related to camera configuration (e.g., go2rtc streams, codecs). If you see frequent errors:
+
+- Verify your camera's H.264/AAC settings (see [Frigate's camera settings recommendations](#camera-settings-recommendations)).
+- Check go2rtc configuration for transcoding (e.g., audio to AAC/OPUS).
+- Test with a different stream via the UI dropdown (if `live -> streams` is configured).
+- For WebRTC-specific issues, ensure port 8555 is forwarded and candidates are set (see [WebRTC Extra Configuration](#webrtc-extra-configuration)).
+- If your cameras are streaming at a high resolution, your browser may be struggling to load all of the streams before the buffering timeout occurs. Frigate prioritizes showing a true live view as quickly as possible. If the fallback occurs often, change your live view settings to use a lower bandwidth substream.
+
+</FaqItem>
+
+<FaqItem id="why-is-my-live-view-delayed-or-lagging-behind-real-time" question="Why is my live view delayed or lagging behind real time?">
+
+A delay when a stream first starts is usually caused by your camera's I-frame (keyframe) interval. Playback cannot begin until a keyframe arrives, so an interval set higher than your camera's frame rate makes the stream take longer to start. Set the I-frame interval to match the frame rate (or "1x" on Reolink) per the [camera settings recommendations](#camera-settings-recommendations).
+
+A stream that starts on time but falls further behind live is buffering, which is usually the browser struggling to decode too many high-resolution streams at once. Select a lower-bandwidth substream for your dashboards (see [Setting Streams For Live UI](#setting-streams-for-live-ui)), reduce the number of streams open at once, or improve the network connection between your browser and Frigate. Frigate's player automatically speeds up playback to catch up to live after buffering, and falls back to low bandwidth mode if it stalls for too long. The _Reset_ option forces a fresh connection at the live edge.
+
+</FaqItem>
+
+<FaqItem id="why-does-frigate-prefer-mse-over-webrtc-for-live-view" question="Why does Frigate prefer MSE over WebRTC for live view?">
+
+Frigate prefers MSE because it delivers a better out-of-the-box experience than WebRTC on nearly every axis that matters for a security camera system. MSE is an open standard optimized and supported by all modern browsers, works without any extra configuration (WebRTC requires port forwarding and candidate setup, and lacks H.265 support in some browsers), and requires no internet access for NAT traversal. More importantly, MSE runs over TCP, so every frame arrives and is decoded in order, so nothing is ever silently skipped. WebRTC optimizes for latency over UDP by discarding late or incomplete frames, which works against you on cellular or spotty Wi-Fi: you can end up with frozen video, visual corruption, or gaps in the feed without ever knowing you missed something. Frigate's enhanced MSE player has adaptive speed playback and has been tuned for latency and connection robustness that meets or exceeds WebRTC, so you get near-real-time playback with a guarantee that when the video plays, every frame is actually there - which, for an NVR whose whole purpose is letting you see what happened, matters more than shaving fractions of a second off a latency number. That's why Frigate defaults to MSE and reserves WebRTC for cases that require it, like two-way talk.
+
+</FaqItem>
+
+### Video Quality Issues
+
+<FaqItem id="i-see-a-strange-diagonal-line-on-my-live-view-but-my-recordings-look-fine-how-can-i-fix-it" question="I see a strange diagonal line on my live view, but my recordings look fine. How can I fix it?">
+
+This is caused by incorrect dimensions set in your detect width or height (or incorrectly auto-detected), causing the jsmpeg player's rendering engine to display a slightly distorted image. You should enlarge the width and height of your `detect` resolution up to a standard aspect ratio (example: 640x352 becomes 640x360, and 800x443 becomes 800x450, 2688x1520 becomes 2688x1512, etc). If changing the resolution to match a standard (4:3, 16:9, or 32:9, etc) aspect ratio does not solve the issue, you can enable "compatibility mode" in your camera group dashboard's stream settings. Depending on your browser and device, more than a few cameras in compatibility mode may not be supported, so only use this option if changing your `detect` width and height fails to resolve the color artifacts and diagonal line.
+
+</FaqItem>
+
+<FaqItem id="my-camera-streams-have-lots-of-visual-artifacts-or-distortion" question="My camera streams have lots of visual artifacts / distortion.">
+
+Some cameras don't include the hardware to support multiple connections to the high resolution stream, and this can cause unexpected behavior. In this case it is recommended to [restream](./restream.md) the high resolution stream so that it can be used for live view and recordings.
+
+</FaqItem>
+
+<FaqItem id="why-does-my-camera-stream-switch-aspect-ratios-on-the-live-dashboard" question="Why does my camera stream switch aspect ratios on the Live dashboard?">
+
+Your camera may change aspect ratios on the dashboard because Frigate uses different streams for different purposes. With go2rtc and Smart Streaming, Frigate shows a static image from the `detect` stream when no activity is present, and switches to the live stream when motion is detected. The camera image will change size if your streams use different aspect ratios.
+
+To prevent this, make the `detect` stream match the go2rtc live stream's aspect ratio (resolution does not need to match, just the aspect ratio). You can either adjust the camera's output resolution or set the `width` and `height` values in your config's `detect` section to a resolution with an aspect ratio that matches.
+
+Example: Resolutions from two streams
+
+- Mismatched (may cause aspect ratio switching on the dashboard):
+  - Live/go2rtc stream: 1920x1080 (16:9)
+  - Detect stream: 640x352 (~1.82:1, not 16:9)
+
+- Matched (prevents switching):
+  - Live/go2rtc stream: 1920x1080 (16:9)
+  - Detect stream: 640x360 (16:9)
+
+You can update the detect settings in your camera config to match the aspect ratio of your go2rtc live stream. For example:
+
+```yaml
+cameras:
+  front_door:
+    detect:
+      width: 640
+      height: 360 # set this to 360 instead of 352
+    ffmpeg:
+      inputs:
+        - path: rtsp://127.0.0.1:8554/front_door # main stream 1920x1080
+          roles:
+            - record
+        - path: rtsp://127.0.0.1:8554/front_door_sub # sub stream 640x352
+          roles:
+            - detect
+```
+
+The same applies to your `record` stream: if its aspect ratio differs from your `detect` stream, your recordings will appear in a different shape than the live view. For consistent framing across live view and recordings, use the same aspect ratio for all of a camera's streams (the resolution can still differ).
+
+</FaqItem>
@@ -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).
+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 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,6 +86,30 @@ 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.
@@ -484,7 +508,6 @@ Generate a Frigate Docker Compose configuration based on your hardware and requi

 <DockerComposeGenerator/>

-
  </TabItem>
  <TabItem value="original" label="Example Docker Compose File">
 ```yaml
@@ -9,6 +9,8 @@ The best way to integrate with Home Assistant is to use the [official integratio

 ### Preparation

+Frigate itself must be installed and running before setting up the integration. See the [installation documentation](../frigate/installation.md) for details.
+
 The Frigate integration requires the `mqtt` integration to be installed and
 manually configured first.

@@ -39,7 +39,9 @@ The per-clip variation is typically quite low and is mostly an artifact of keyfr

 Debug Replay lets you re-run Frigate's detection pipeline against a section of recorded video without manually configuring a dummy camera. It automatically extracts the recording, creates a temporary camera with the same detection settings as the original, and loops the clip through the pipeline so you can observe detections in real time.

-Debug Replay isn't intended to be a one-stop pane for all Frigate diagnostics or a comprehensive debugging environment for every Frigate feature. It merely makes it easier to spin up a "dummy camera" and perform some common adjustments in real-time. You'll still need to use the normal tools (logs, an MQTT client, etc) to debug your feature.
+The replay camera behaves like a live camera feed rather than History's video player: it loops the clip continuously as Frigate analyzes it and has no playback controls, so you cannot pause, scrub, or step through it frame by frame.
+
+Debug Replay isn't intended to be a one-stop pane for all Frigate diagnostics or a comprehensive debugging environment for every Frigate feature. It merely makes it easier to spin up a "dummy camera" and perform some common adjustments in real time. You'll still need to use the normal tools (logs, an MQTT client, etc) to debug your feature.

 ### When to use

@@ -3,6 +3,8 @@ id: recordings
 title: Recordings Errors
 ---

+import FaqItem from "@site/src/components/FaqItem";
+
 ## Why are my recordings not working? (empty Recordings, "No recordings found for this time")

 If Frigate shows live video but the History view is empty, or you see "No recordings found for this time", the cause is almost always in one of the three categories below. Segments are first written to the RAM cache and are only moved to disk if they match a retention policy _and_ the camera's `record` stream is producing valid, storable video. Work through the categories in order: retention configuration is by far the most common cause.
@@ -19,7 +21,7 @@ A healthy camera logs lines like `Copied /media/frigate/recordings/{segment_path

 ### Retention configuration issues

-#### Recording is enabled, but nothing is saved
+<FaqItem id="recording-is-enabled-but-nothing-is-saved" question="Recording is enabled, but nothing is saved">

 This is the single most common cause. Setting `record.enabled: True` on its own does **not** keep any footage: **continuous recording is disabled by default**, and segments in the cache are only moved to disk if they match a configured retention policy. You must configure at least one of `continuous`, `motion`, `alerts`, or `detections` retention.

@@ -34,7 +36,9 @@ record:

 See [Recording](/configuration/record) for the full set of common configurations, including reduced-storage and alerts-only setups.

-#### Motion or event-only recording keeps less than you expect
+</FaqItem>
+
+<FaqItem id="motion-or-event-only-recording-keeps-less-than-you-expect" question="Motion or event-only recording keeps less than you expect">

 If you only configured `motion`, `alerts`, or `detections` retention (with no `continuous`), Frigate keeps footage selectively based on the retention `mode`:

@@ -44,20 +48,26 @@ If you only configured `motion`, `alerts`, or `detections` retention (with no `c

 If you expected continuous footage but only configured motion/event retention, add a `continuous` retention period as shown above. To verify motion is actually being detected, watch the motion boxes in the debug view or the Motion Tuner in the UI.

-#### Alert and detection recordings require working object detection
+</FaqItem>
+
+<FaqItem id="alert-and-detection-recordings-require-working-object-detection" question="Alert and detection recordings require working object detection">

 `alerts` and `detections` retention only keep footage that overlaps a tracked object, so they depend on object detection running:

 - **Detection must be enabled.** If `detect: enabled: False`, no alerts or detections are ever created, so alert/detection retention keeps nothing. (Continuous and motion retention still work with detection disabled.)
 - **The object must be supported by your model.** If you track an object your model doesn't support (for example `deer` or `license_plate` on the default model), Frigate never detects it and never records for it. Check your logs for warnings such as `... is configured to track ['deer'] objects, which are not supported by the current model` and remove unsupported objects or switch to a model (e.g. [Frigate+](/plus/)) that includes them.

-#### You're following an outdated guide
+</FaqItem>
+
+<FaqItem id="youre-following-an-outdated-guide" question="You're following an outdated guide">

 Configuration keys change between major versions. The old `clips` config, for example, has not existed for a long time. If you copied a config from an old blog post or video, verify every key against the current [reference config](/configuration/advanced/reference).

+</FaqItem>
+
 ### Camera and stream issues

-#### Incompatible audio codec (recordings silently fail to save)
+<FaqItem id="incompatible-audio-codec-recordings-silently-fail-to-save" question="Incompatible audio codec (recordings silently fail to save)">

 Frigate stores recordings in an MP4 container, and some camera audio codecs (most commonly `pcm_alaw`, `pcm_mulaw`, or other G.711 variants) **cannot be placed in an MP4 container**. When this happens, ffmpeg fails to write the segment and no recording is saved, even though the live view works fine. This is a frequent cause on Tapo, TP-Link VIGI, and some Reolink cameras.

@@ -72,7 +82,9 @@ cameras:
        # or preset-record-generic to record with no audio
 ```

-#### The record stream isn't connecting
+</FaqItem>
+
+<FaqItem id="the-record-stream-isnt-connecting" question="The record stream isn't connecting">

 A message like `No new recording segments were created for <camera> in the last 120s` means ffmpeg cannot read the `record` stream. To diagnose:

@@ -81,17 +93,11 @@ A message like `No new recording segments were created for <camera> in the last
 - Test the exact RTSP URL (with the correct path, port, and credentials) in VLC or `ffplay`.
 - If you restream through go2rtc, make sure the `record` input path points at the correct go2rtc stream name. Copying a config between cameras without updating the stream name is a common mistake.

-#### Recordings play back with no video (or won't play at all)
-
-Frigate copies the `record` stream directly without re-encoding, so playback depends on your browser supporting the camera's codec. H265/HEVC recordings may not be playable in some browsers. If recordings appear as audio-only or a black screen, your camera is likely sending a codec your browser can't decode. Configure the camera to output **H264** for maximum compatibility.
-
-#### Segments are only ~1 second long
-
-If the record stream uses a "Smart Codec"/H.264+ mode or changes encoding parameters mid-stream, corrupt timestamps cause segments to be split far too frequently and fill the cache. This produces the "Too many unprocessed recording segments" warning. See [that section below](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) for the full diagnosis.
+</FaqItem>

 ### Storage and mounting issues

-#### The storage volume isn't mounted correctly
+<FaqItem id="the-storage-volume-isnt-mounted-correctly" question="The storage volume isn't mounted correctly">

 If the recordings volume (`/media/frigate`) points at the wrong location, isn't writable, or a network/encrypted mount failed to mount at boot, Frigate cannot save recordings, or it silently writes to the boot drive and then purges aggressively because the drive appears far smaller than expected.

@@ -100,21 +106,114 @@ If the recordings volume (`/media/frigate`) points at the wrong location, isn't
 - For a mount that may fail intermittently, protecting the mount point with `chattr +i` on an empty directory forces Frigate to error out (rather than silently writing to the boot drive) when the mount is missing.
 - Check `dmesg` and system logs for filesystem or I/O errors around the time recordings disappeared.

-If recordings _are_ being written but the copy is too slow to keep up, see the ["Unable to keep up with recording segments"](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) section below.
+If recordings _are_ being written but the copy is too slow to keep up, see the ["Unable to keep up with recording segments"](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) question below.

-## I have Frigate configured for motion recording only, but it still seems to be recording even with no motion. Why?
+</FaqItem>

-You'll want to:
+## Recordings won't play back

- Make sure your camera's timestamp is masked out with a motion mask. Even if there is no motion occurring in your scene, your motion settings may be sensitive enough to count your timestamp as motion.
- If you have audio detection enabled, keep in mind that audio that is heard above `min_volume` is considered motion.
- [Tune your motion detection settings](/configuration/motion_detection) either by editing your config file or by using the UI's Motion Tuner.
+<FaqItem id="pipeline-error-decode" question={"Recordings won't play back: \"PIPELINE_ERROR_DECODE\" (or \"Media failed to decode\")"}>

-## I see the message: WARNING : Unable to keep up with recording segments in cache for camera. Keeping the 5 most recent segments out of 6 and discarding the rest...
+When a recording refuses to play in the Frigate UI and you see an error like `Failed to play recordings (error 3): PIPELINE_ERROR_DECODE`, the message is coming from **your browser**, not from Frigate. `PIPELINE_ERROR_DECODE` is emitted exclusively by the media pipeline in **Chromium-based browsers** (Chrome, Edge, Brave, Vivaldi, Opera, Arc, and the Android WebView used by many in-app browsers) when the browser cannot decode a video or audio packet in the recording. WebKit browsers (Safari) report the same underlying problem with a different message, usually `Media failed to decode` or `DECODER_ERROR_NOT_SUPPORTED`.
+
+Frigate copies the `record` stream to disk **without re-encoding it**, so the browser must decode exactly what your camera produced, and Chromium's decoder is far stricter about malformed or nonstandard media than VLC or ffmpeg.
+
+:::warning
+
+The same recording playing perfectly in VLC, decoding cleanly with `ffprobe`/`ffmpeg`, or having a valid MP4 container does **not** mean the browser can decode it. VLC and ffmpeg are much more tolerant of codec quirks and damaged packets than a browser's media pipeline, so a "valid" file can still trigger `PIPELINE_ERROR_DECODE`. This is outside of Frigate's control, because Frigate never modifies the recording stream.
+
+:::
+
+#### Step 1: Confirm it is a browser issue
+
+Open the same recording in **Firefox** or **Safari**. Firefox and Safari both use a different media engine and cannot produce `PIPELINE_ERROR_DECODE`, so if playback works there you have confirmed a client-side codec or decoder problem rather than a bad recording. Switching browsers is a workaround, not a fix; the remaining steps address the root cause so that Chromium browsers work too.
+
+#### Step 2: Rule out H.265 / HEVC
+
+Browser support for H.265 (HEVC) is limited and depends on the operating system, GPU, hardware acceleration, and browser version, which makes it the most common cause of this error. Options, in order of reliability:
+
+- **Record H.264 instead.** Configure the camera's `record`/main stream to output H.264, the most compatible codec across all browsers. See [camera settings recommendations](/configuration/live#camera-settings-recommendations).
+- **Transcode to H.264 with go2rtc.** If you must keep HEVC on the camera, have go2rtc re-encode the recording stream. This increases CPU usage; add `#hardware` to use the GPU where available:
+
+  ```yaml
+  go2rtc:
+    streams:
+      your_camera:
+        # transcode video to h264 and audio to aac; #hardware uses the GPU if available
+        - "ffmpeg:rtsp://user:password@CAMERA_IP:554/stream#video=h264#audio=aac#hardware"
+  cameras:
+    your_camera:
+      ffmpeg:
+        inputs:
+          - path: rtsp://127.0.0.1:8554/your_camera
+            input_args: preset-rtsp-restream
+            roles:
+              - record
+  ```
+
+  The `#video=h264` parameter only takes effect with the `ffmpeg:` source module; adding it to a plain `rtsp://` go2rtc source does nothing.
+
+- **Keep HEVC but improve compatibility.** If your browser and OS do support HEVC, set [`apple_compatibility`](/configuration/camera_specific#h265-cameras-via-safari) on the camera. Some players (Safari and other clients) require a specific HEVC stream format that this option corrects:
+
+  ```yaml
+  cameras:
+    your_camera:
+      ffmpeg:
+        apple_compatibility: true
+  ```
+
+  You may also need to enable HEVC and hardware decoding in the browser itself (for example, Chrome's Settings → System → "Use hardware acceleration when available"). HEVC hardware support varies widely by GPU, OS, and browser version.
+
+#### Step 3: Clean up damaged packets from the camera
+
+If the error is **intermittent** (the same recording plays after a page refresh, or fails only after playing for a while), the camera is most likely emitting occasional corrupt or malformed packets. Some camera models are more prone to this than others. Routing the stream through go2rtc's `ffmpeg` module often "cleans up" the stream enough for the browser to decode it, even without changing the codec:
+
+```yaml
+go2rtc:
+  streams:
+    your_camera:
+      - "ffmpeg:rtsp://user:password@CAMERA_IP:554/stream#video=h264#audio=aac"
+```
+
+#### Step 4: Fix incompatible or corrupt audio
+
+Audio is one of the most common culprits, and a decode failure on the audio track fails the whole recording. Make sure the camera outputs **AAC** audio, transcode the audio to AAC with go2rtc (`#audio=aac`), or drop audio entirely. See [Incompatible audio codec](#incompatible-audio-codec-recordings-silently-fail-to-save) for a preset-based way to do this.
+
+#### Step 5: Avoid "smart" / "+" codecs and check the keyframe interval
+
+- Disable any **"Smart Codec"**, **"H.264+"**, or **"H.265+"** feature in the camera. These nonstandard modes drop keyframes and change encoding parameters mid-stream, producing exactly the kind of packets a browser refuses to decode. (They also cause [short recording segments](#segments-are-only-1-second-long).)
+- Set the camera's **I-frame (keyframe) interval equal to the frame rate** (for example `20` for a 20 fps stream). Long keyframe intervals slow the start of playback and make decode errors more likely.
+
+#### Step 6: Consider bitrate and the client hardware
+
+The browser decodes the video locally, so a stream that is too demanding can fail on one device while playing on another:
+
+- A **very high bitrate or resolution** (for example a 4K/8MP HEVC main stream) can overwhelm a low-power tablet, phone, or SBC and stall the decoder. Test the same recording on a desktop; if it plays there, lower the camera's bitrate or record a lower-resolution profile.
+- Errors that name the client's GPU decoder, such as `VaapiVideoDecoder: failed Initialize()ing the frame pool`, indicate a browser hardware-decode problem. Toggling the browser's "Use hardware acceleration" setting (on or off) often resolves these.
+
+</FaqItem>
+
+<FaqItem id="recordings-play-back-with-no-video-or-wont-play-at-all" question="Recordings play back with no video (or won't play at all)">
+
+Frigate copies the `record` stream directly without re-encoding, so playback depends on your browser supporting the camera's codec. H265/HEVC recordings may not be playable in some browsers. If recordings appear as audio-only or a black screen, your camera is likely sending a codec your browser can't decode. Configure the camera to output **H264** for maximum compatibility.
+
+If playback instead fails with an explicit `PIPELINE_ERROR_DECODE` or `Media failed to decode` error, see [Recordings won't play back with "PIPELINE_ERROR_DECODE"](#pipeline-error-decode) above.
+
+</FaqItem>
+
+## Recording cache warnings and errors
+
+<FaqItem id="segments-are-only-1-second-long" question="Segments are only ~1 second long">
+
+If the record stream uses a "Smart Codec"/H.264+ mode or changes encoding parameters mid-stream, corrupt timestamps cause segments to be split far too frequently and fill the cache. This produces the "Too many unprocessed recording segments" warning. See [that question below](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) for the full diagnosis.
+
+</FaqItem>
+
+<FaqItem id="i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest" question="I see the message: WARNING : Unable to keep up with recording segments in cache for camera. Keeping the 5 most recent segments out of 6 and discarding the rest...">

 This warning means the recording maintainer cannot move recording segments from the RAM cache to disk fast enough. When the cache fills up, Frigate discards the oldest segments to avoid running out of memory and crashing, so you lose recorded footage. This is almost always a storage throughput or system resource problem. Work through the steps below to identify which.

-### Step 1: Enable recording debug logging
+#### Step 1: Enable recording debug logging

 The first step is to measure how long each segment takes to move from the RAM cache to disk. Enable debug logging for the recording maintainer:

@@ -132,14 +231,14 @@ DEBUG   : Copied /media/frigate/recordings/{segment_path} in 0.2 seconds.

 Let this run until the warnings begin to appear, so you can confirm whether the disk is actually slowing down at the moment the error occurs.

-### Step 2: Interpret the copy times
+#### Step 2: Interpret the copy times

 The copy duration tells you which direction to investigate:

 - **Consistently longer than ~1 second**: your storage cannot keep up with the incoming recordings. Continue with Steps 3–5 to diagnose the slow storage.
 - **Consistently well under 1 second**: storage is fast enough, and the problem is more likely CPU or resource contention. Skip to Step 6.

-### Step 3: Check RAM, swap, cache, and disk utilization
+#### Step 3: Check RAM, swap, cache, and disk utilization

 If CPU, RAM, disk throughput, or bus I/O is insufficient, nothing inside Frigate will help. Review each aspect of available system resources while the warnings are occurring.

@@ -175,19 +274,21 @@ services:

 NOTE: These are hard limits for the container, so be sure there is enough headroom above what `docker stats` shows for your container. It will immediately halt if it hits `<MAXRAM>`. In general, keeping all cache and tmp filespace in RAM is preferable to disk I/O where possible.

-### Step 4: Check your storage type
+#### Step 4: Check your storage type

 Mounting a network share is a popular option for storing recordings, but it can lead to reduced copy times and cause problems. Some users have found that using `NFS` instead of `SMB` considerably decreased copy times and fixed the issue. It is also important to ensure that the network connection between the device running Frigate and the network share is stable and fast. A saturated or unreliable link will stall copies.

-### Step 5: Check your mount options
+#### Step 5: Check your mount options

 Some users found that mounting a drive via `fstab` with the `sync` option dramatically reduced performance and led to this issue. Using `async` instead greatly reduced copy times.

-### Step 6: Rule out CPU load
+#### Step 6: Rule out CPU load

 If the copy times are consistently under 1 second but you still see the warning, the machine's CPU load is likely too high for Frigate to have the resources to keep up. Try temporarily shutting down other services, and any resource-intensive Frigate features, to see if the issue improves.

-## I see the message: WARNING : Too many unprocessed recording segments in cache for camera. This likely indicates an issue with the detect stream...
+</FaqItem>
+
+<FaqItem id="i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream" question="I see the message: WARNING : Too many unprocessed recording segments in cache for camera. This likely indicates an issue with the detect stream...">

 This warning means that the detect stream for the affected camera has fallen behind or stopped processing frames. Frigate's recording cache holds segments waiting to be analyzed by the detector. When more than 6 segments pile up without being processed, Frigate discards the oldest ones to prevent the cache from filling up.

@@ -197,11 +298,11 @@ This error is a **symptom**, not the root cause. The actual cause is always logg

 :::

-### Step 1: Get the full logs
+#### Step 1: Get the full logs

 Collect complete Frigate logs from startup through the first occurrence of the error. Look for errors or warnings that appear **before** the "Too many unprocessed" messages begin. That is where the root cause will be found.

-### Step 2: Check the cache directory
+#### Step 2: Check the cache directory

 Exec into the Frigate container and inspect the recording cache:

@@ -211,7 +312,7 @@ docker exec -it frigate ls -la /tmp/cache

 Each camera should have a small number of `.mp4` segment files. If one camera has significantly more files than others, that camera is the source of the problem. A problem with a single camera can cascade and cause all cameras to show this error.

-### Step 3: Verify segment duration
+#### Step 3: Verify segment duration

 Recording segments should be approximately 10 seconds long. Run `ffprobe` on segments in the cache to check:

@@ -233,7 +334,7 @@ You don't have to run `ffprobe` by hand to catch this. Open a camera's **Camera

 :::

-### Step 4: Check for a stuck detector
+#### Step 4: Check for a stuck detector

 If the detect stream is not processing frames, segments will accumulate. Common causes:

@@ -242,7 +343,7 @@ If the detect stream is not processing frames, segments will accumulate. Common
 - **Model too large**: Use smaller model variants (e.g., YOLO `s` or `t` size, not `e` or `x`). Use 320x320 input size rather than 640x640 unless you have a powerful dedicated detector.
 - **Virtualization**: Running Frigate in a VM (especially Proxmox) can cause the detector to hang or stall. This is a known issue with GPU/TPU passthrough in virtualized environments and is not something Frigate can fix. Running Frigate in Docker on bare metal is recommended.

-### Step 5: Check for GPU hangs
+#### Step 5: Check for GPU hangs

 On the host machine, check `dmesg` for GPU-related errors:

@@ -252,7 +353,7 @@ dmesg | grep -i -E "gpu|drm|reset|hang"

 Messages like `trying reset from guc_exec_queue_timedout_job` or similar GPU reset/hang messages indicate a driver or hardware issue. Ensure your kernel and GPU drivers (especially Intel) are up to date.

-### Step 6: Verify hardware acceleration configuration
+#### Step 6: Verify hardware acceleration configuration

 An incorrect `hwaccel_args` preset can cause ffmpeg to fail silently or consume excessive CPU, starving the detector of resources.

@@ -260,11 +361,11 @@ An incorrect `hwaccel_args` preset can cause ffmpeg to fail silently or consume
 - For h265 cameras, use the corresponding h265 preset (e.g., `preset-intel-qsv-h265`).
 - Note that `hwaccel_args` are only relevant for the detect stream. Frigate does not decode the record stream.

-### Step 7: Verify go2rtc stream configuration
+#### Step 7: Verify go2rtc stream configuration

 Ensure that the ffmpeg source names in your go2rtc configuration match the correct camera stream. A misconfigured stream name (e.g., copying a config from one camera to another without updating the stream reference) will cause the wrong stream to be used or the stream to fail entirely.

-### Step 8: Check system resources
+#### Step 8: Check system resources

 If none of the above apply, the issue may be a general resource constraint. Monitor the following on your host:

@@ -275,7 +376,9 @@ If none of the above apply, the issue may be a general resource constraint. Moni

 Try temporarily disabling resource-intensive features like `genai` and `face_recognition` to see if the issue resolves. This can help isolate whether the detector is being starved of resources.

-## I see the message: ERROR : Error occurred when attempting to maintain recording cache
+</FaqItem>
+
+<FaqItem id="i-see-the-message-error--error-occurred-when-attempting-to-maintain-recording-cache" question="I see the message: ERROR : Error occurred when attempting to maintain recording cache">

 This message means the recording maintainer hit an error while moving segments from the cache to disk. It is a **generic wrapper**: the actual cause is always logged on the **very next line**. Frigate usually recovers and keeps running, but any affected segments are lost, so it is worth resolving.

@@ -287,27 +390,41 @@ Always read the line immediately following this message. `Error occurred when at

 Because these are operating-system-level errors, they must be resolved on the **host**, not within Frigate's configuration. The most common underlying errors are below.

-### [Errno 28] No space left on device
+#### [Errno 28] No space left on device

 The filesystem Frigate is writing to is full. Things to check:

 - **The recordings volume is genuinely full.** Check free space on the host with `df -h` for the path mapped to `/media/frigate`, and review the **Storage** page in the Frigate UI.
 - **The disk shows free space but is still "full".** This usually means the filesystem has run out of **inodes** (check with `df -i`), or recordings are landing on a different, smaller filesystem than you expect because of an incorrect bind mount. See [The storage volume isn't mounted correctly](#the-storage-volume-isnt-mounted-correctly) above.
- **`/tmp/cache` is full.** If you mounted `/tmp/cache` as a small `tmpfs`, a backlog of segments can fill it. Increase the tmpfs size, or address whatever is causing segments to pile up (see the [Too many unprocessed recording segments](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) section above).
+- **`/tmp/cache` is full.** If you mounted `/tmp/cache` as a small `tmpfs`, a backlog of segments can fill it. Increase the tmpfs size, or address whatever is causing segments to pile up (see the [Too many unprocessed recording segments](#i-see-the-message-warning--too-many-unprocessed-recording-segments-in-cache-for-camera-this-likely-indicates-an-issue-with-the-detect-stream) question above).
 - **The host blocks writes before Frigate can purge.** On some systems (for example Unraid with a fill-up threshold), the host stops writes before Frigate's emergency cleanup can run. Leave more headroom on the volume, or lower your retention so Frigate purges sooner.

-### [Errno 17] File exists (with ffmpeg "Error writing trailer" or "unable to re-open output file")
+#### [Errno 17] File exists (with ffmpeg "Error writing trailer" or "unable to re-open output file")

 Errors like `[Errno 17] File exists: '/media/frigate/recordings/.../<camera>'`, often alongside ffmpeg errors such as `Unable to re-open ... output file for shifting data` or `Error writing trailer: No such file or directory`, are a hallmark of an **unreliable network share** (NFS or SMB). The mount is dropping, serving stale directory entries, or mishandling file locking.

 - Confirm the network connection to the NAS is stable and fast. An intermittent link produces these errors sporadically.
 - Prefer **NFS over SMB** for the recordings mount; several users have found NFS more reliable and faster.
- Review your `fstab`/mount options for settings that hurt consistency or performance (see the `sync` vs `async` note in the [Unable to keep up with recording segments](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) section above).
+- Review your `fstab`/mount options for settings that hurt consistency or performance (see the `sync` vs `async` note in the [Unable to keep up with recording segments](#i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest) question above).
 - Enable `frigate.record.maintainer` debug logging to confirm whether the errors line up with the share becoming unavailable.

-### Errors referencing a camera you manually renamed or removed
+#### Errors referencing a camera you manually renamed or removed

 If the next-line error references a camera name that no longer exists in your config, orphaned data is left over from a rename or removal in a persistent `/tmp/cache` volume.

 - Using a `tmpfs` mount for `/tmp/cache` as recommended in the [installation docs](/frigate/installation#storage) prevents stale cache files under the old camera name from surviving a restart, which avoids this issue entirely.
 - If errors persist, stop Frigate and remove any leftover segments for the old camera name from `/tmp/cache`.
+
+</FaqItem>
+
+## Other recording questions
+
+<FaqItem id="i-have-frigate-configured-for-motion-recording-only-but-it-still-seems-to-be-recording-even-with-no-motion-why" question="I have Frigate configured for motion recording only, but it still seems to be recording even with no motion. Why?">
+
+You'll want to:
+
+- Make sure your camera's timestamp is masked out with a motion mask. Even if there is no motion occurring in your scene, your motion settings may be sensitive enough to count your timestamp as motion.
+- If you have audio detection enabled, keep in mind that audio that is heard above `min_volume` is considered motion.
+- [Tune your motion detection settings](/configuration/motion_detection) either by editing your config file or by using the UI's Motion Tuner.
+
+</FaqItem>
@@ -55,7 +55,7 @@ export default function FaqItem({ id, question, children }) {
          aria-controls={`${id}-content`}
          onClick={toggle}
        >
-          {question}
+          <span className={styles.question}>{question}</span>
        </button>
      </Heading>
      <div id={`${id}-content`} className={styles.content}>
@@ -44,6 +44,11 @@
  transform: rotate(45deg);
 }

+.question {
+  flex: 1;
+  min-width: 0;
+}
+
 .content {
  display: none;
  padding: 0 0 0.85rem;
@@ -61,7 +66,7 @@
 /* Desktop: render as a normal expanded heading + answer. */
@media (min-width: 997px) {
  .heading {
-    margin: 1.75rem 0 0.5rem;
+    margin: 1.75rem 0 0.85rem;
  }

  .toggle {
@@ -78,7 +83,8 @@

  .content {
    display: block;
-    padding: 0;
+    padding: 0 0 0.5rem 1rem;
+    border-left: 2px solid var(--ifm-color-emphasis-200);
  }

  .heading :global(.hash-link) {
@@ -971,7 +971,11 @@ def config_set(request: Request, body: AppConfigSetBody):
                content=(
                    {
                        "success": True,
-                        "message": "Config successfully updated, restart to apply",
+                        "message": (
+                            "Config successfully updated"
+                            if body.requires_restart == 0
+                            else "Config successfully updated, restart to apply"
+                        ),
                    }
                ),
                status_code=200,
@@ -415,7 +415,7 @@ def create_encoded_jwt(user, role, expiration, secret):
    )


-def set_jwt_cookie(response: Response, cookie_name, encoded_jwt, expiration, secure):
+def set_jwt_cookie(response: Response, cookie_name, encoded_jwt, max_age, secure):
    # TODO: ideally this would set secure as well, but that requires TLS
    # SameSite is intentionally left unset (browsers default to Lax). Setting
    # SameSite=Lax/Strict would stop the cookie from being sent in cross-origin
@@ -427,7 +427,7 @@ def set_jwt_cookie(response: Response, cookie_name, encoded_jwt, expiration, sec
        key=cookie_name,
        value=encoded_jwt,
        httponly=True,
-        expires=expiration,
+        max_age=max_age,
        secure=secure,
    )

@@ -762,7 +762,7 @@ def auth(request: Request):
                success_response,
                JWT_COOKIE_NAME,
                new_encoded_jwt,
-                new_expiration,
+                JWT_SESSION_LENGTH,
                JWT_COOKIE_SECURE,
            )

@@ -875,7 +875,11 @@ def login(request: Request, body: AppPostLoginBody):
        encoded_jwt = create_encoded_jwt(user, role, expiration, request.app.jwt_token)
        response = Response("", 200)
        set_jwt_cookie(
-            response, JWT_COOKIE_NAME, encoded_jwt, expiration, JWT_COOKIE_SECURE
+            response,
+            JWT_COOKIE_NAME,
+            encoded_jwt,
+            JWT_SESSION_LENGTH,
+            JWT_COOKIE_SECURE,
        )
        # Clear admin_first_time_login flag after successful admin login so the
        # UI stops showing the first-time login documentation link.
@@ -1037,7 +1041,11 @@ async def update_password(
        )
        # Set new JWT cookie on response
        set_jwt_cookie(
-            response, JWT_COOKIE_NAME, encoded_jwt, expiration, JWT_COOKIE_SECURE
+            response,
+            JWT_COOKIE_NAME,
+            encoded_jwt,
+            JWT_SESSION_LENGTH,
+            JWT_COOKIE_SECURE,
        )

    return response
@@ -7,7 +7,7 @@ import operator
 import time
 from datetime import datetime
 from functools import reduce
-from typing import Any
+from typing import Any, Literal

 import cv2
 from fastapi import APIRouter, Body, Depends, HTTPException, Request
@@ -37,6 +37,7 @@ from frigate.api.defs.response.chat_response import (
 from frigate.api.defs.tags import Tags
 from frigate.api.event import _build_attribute_filter_clause, events
 from frigate.config import FrigateConfig
+from frigate.config.classification import SemanticSearchModelEnum
 from frigate.genai.prompts import (
    build_chat_system_prompt,
    get_attribute_classifications,
@@ -86,10 +87,23 @@ def get_tools(request: Request) -> JSONResponse:
    tools = get_tool_definitions(
        semantic_search_enabled=semantic_search_enabled,
        attribute_classifications=attribute_classifications,
+        embeddings_language=_embeddings_language(config),
    )
    return JSONResponse(content={"tools": tools})


+def _embeddings_language(config: FrigateConfig) -> Literal["english", "multi"]:
+    """Return the language capability of the configured embeddings model.
+
+    JinaV1 is English-only; every other option (JinaV2 or a GenAI embeddings
+    provider) handles multiple languages.
+    """
+    if config.semantic_search.model == SemanticSearchModelEnum.jinav1:
+        return "english"
+
+    return "multi"
+
+
 def _resolve_zones(
    zones: list[str],
    config: FrigateConfig,
@@ -98,11 +112,14 @@ def _resolve_zones(
    """Map zone names to their canonical config keys, case-insensitively.

    LLMs frequently echo a user's casing ("Front Yard") instead of the
-    configured key ("front_yard"). The downstream zone filter is a SQLite GLOB
-    over the JSON-encoded zones column, which is case-sensitive — so an
-    unnormalized name silently returns zero matches. Build a lookup over the
-    relevant cameras' configured zones and substitute when we find a match;
-    unknown names pass through so behavior matches what the model asked for.
+    configured key ("front_yard"), or fall back to a zone's friendly name
+    ("Front Walkway") instead of its ID ("front_walk"). The downstream zone
+    filter is a SQLite GLOB over the JSON-encoded zones column, which stores
+    config keys and is case-sensitive — so an unnormalized name silently
+    returns zero matches. Build a lookup over the relevant cameras' configured
+    zones, keyed by both the config key and the friendly name, and substitute
+    when we find a match; unknown names pass through so behavior matches what
+    the model asked for.
    """
    if not zones:
        return zones
@@ -112,8 +129,11 @@ def _resolve_zones(
        camera_config = config.cameras.get(camera_id)
        if camera_config is None:
            continue
-        for zone_name in camera_config.zones.keys():
+        for zone_name, zone_config in camera_config.zones.items():
            lookup.setdefault(zone_name.lower(), zone_name)
+            lookup.setdefault(
+                zone_config.get_formatted_name(zone_name).lower(), zone_name
+            )

    return [lookup.get(z.lower(), z) for z in zones]

@@ -1134,6 +1154,7 @@ async def chat_completion(
    tools = get_tool_definitions(
        semantic_search_enabled=semantic_search_enabled,
        attribute_classifications=attribute_classifications,
+        embeddings_language=_embeddings_language(config),
    )
    conversation = []

@@ -117,7 +117,9 @@ class CameraMaintainer(threading.Thread):

        if runtime:
            self.camera_metrics[name] = CameraMetrics(self.metrics_manager)
-            self.ptz_metrics[name] = PTZMetrics(autotracker_enabled=False)
+            self.ptz_metrics[name] = PTZMetrics(
+                autotracker_enabled=config.onvif.autotracking.enabled
+            )
            self.region_grids[name] = get_camera_regions_grid(
                name,
                config.detect,
@@ -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[
+                    and self.ptz_autotracker_thread.ptz_autotracker.autotracker_init.get(
                        self.name
-                    ]
+                    )
                    and self.ptz_autotracker_thread.ptz_autotracker.tracked_object[
                        self.name
                    ]
@@ -588,6 +588,10 @@ 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:
@@ -14,6 +14,7 @@ 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"
@@ -145,6 +146,8 @@ 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:
@@ -400,6 +400,9 @@ def verify_objects_track(
        )
        camera_config.objects.track = valid_objects

+        for label in invalid_objects:
+            camera_config.objects.filters.pop(label, None)
+

 def verify_lpr_and_face(
    frigate_config: FrigateConfig, camera_config: CameraConfig
@@ -1,9 +1,11 @@
-import re
 import sqlite3
 from typing import Any

+import regex
 from playhouse.sqliteq import SqliteQueueDatabase

+REGEXP_TIMEOUT_SECONDS = 1.0
+

 class SqliteVecQueueDatabase(SqliteQueueDatabase):
    def __init__(
@@ -34,8 +36,10 @@ class SqliteVecQueueDatabase(SqliteQueueDatabase):
            if item is None:
                return False
            try:
-                return re.search(expr, item) is not None
-            except re.error:
+                return (
+                    regex.search(expr, item, timeout=REGEXP_TIMEOUT_SECONDS) is not None
+                )
+            except (regex.error, TimeoutError):
                return False

        conn.create_function("REGEXP", 2, regexp)
@@ -21,8 +21,6 @@ from frigate.config.camera.updater import (
    CameraConfigUpdateTopic,
 )
 from frigate.const import (
-    CLIPS_DIR,
-    RECORD_DIR,
    REPLAY_CAMERA_PREFIX,
    REPLAY_DIR,
    THUMB_DIR,
@@ -331,12 +329,14 @@ def cleanup_replay_cameras() -> None:
    """
    stale_cameras: set[str] = set()

-    # Scan filesystem for leftover replay artifacts to derive camera names
-    for dir_path in [RECORD_DIR, CLIPS_DIR, THUMB_DIR]:
-        if os.path.isdir(dir_path):
-            for entry in os.listdir(dir_path):
-                if entry.startswith(REPLAY_CAMERA_PREFIX):
-                    stale_cameras.add(entry)
+    # Derive stale camera names from THUMB_DIR (per-camera dirs) and
+    # REPLAY_DIR (the session's source clip); both listings are bounded by
+    # camera count. cleanup_camera_files below removes any remaining
+    # per-camera artifacts (snapshots, thumbnails, LPR images, etc.) by name.
+    if os.path.isdir(THUMB_DIR):
+        for entry in os.listdir(THUMB_DIR):
+            if entry.startswith(REPLAY_CAMERA_PREFIX):
+                stale_cameras.add(entry)

    if os.path.isdir(REPLAY_DIR):
        for entry in os.listdir(REPLAY_DIR):
@@ -376,20 +376,22 @@ class EmbeddingMaintainer(threading.Thread):
            logger.info(f"Disabled classification processor for model: {model_name}")
            return

-        # Check if processor already exists
        for processor in self.realtime_processors:
-            if isinstance(
-                processor,
-                (
-                    CustomStateClassificationProcessor,
-                    CustomObjectClassificationProcessor,
-                ),
+            if (
+                isinstance(
+                    processor,
+                    (
+                        CustomStateClassificationProcessor,
+                        CustomObjectClassificationProcessor,
+                    ),
+                )
+                and processor.model_config.name == model_name
            ):
-                if processor.model_config.name == model_name:
-                    logger.debug(
-                        f"Classification processor for model {model_name} already exists, skipping"
-                    )
-                    return
+                processor.model_config = model_config
+                logger.debug(
+                    f"Updated config for classification processor: {model_name}"
+                )
+                return

        if model_config.state_config is not None:
            processor = CustomStateClassificationProcessor(
@@ -57,6 +57,12 @@ class BaseEmbedding(ABC):
    def _preprocess_inputs(self, raw_inputs: Any) -> Any:
        pass

+    @staticmethod
+    def _bgr_to_rgb(frame: Any) -> Any:
+        if isinstance(frame, np.ndarray) and frame.ndim == 3:
+            return np.ascontiguousarray(frame[:, :, ::-1])
+        return frame
+
    def _process_image(self, image, output: str = "RGB") -> Image.Image:
        if isinstance(image, str):
            if image.startswith("http"):
@@ -73,7 +73,7 @@ class FaceNetEmbedding(BaseEmbedding):
            self.tensor_output_details = self.runner.get_output_details()

    def _preprocess_inputs(self, raw_inputs):
-        pil = self._process_image(raw_inputs[0])
+        pil = self._process_image(self._bgr_to_rgb(raw_inputs[0]))

        # handle images larger than input size
        width, height = pil.size
@@ -159,7 +159,7 @@ class ArcfaceEmbedding(BaseEmbedding):
            )

    def _preprocess_inputs(self, raw_inputs):
-        pil = self._process_image(raw_inputs[0])
+        pil = self._process_image(self._bgr_to_rgb(raw_inputs[0]))

        # handle images larger than input size
        width, height = pil.size
@@ -150,7 +150,11 @@ PRESETS_HW_ACCEL_SCALE["preset-rk-h265"] = PRESETS_HW_ACCEL_SCALE[FFMPEG_HWACCEL
 PRESETS_HW_ACCEL_ENCODE_BIRDSEYE = {
    "preset-rpi-64-h264": "{0} -hide_banner {1} -c:v h264_v4l2m2m {2}",
    "preset-rpi-64-h265": "{0} -hide_banner {1} -c:v hevc_v4l2m2m {2}",
-    FFMPEG_HWACCEL_VAAPI: "{0} -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_device {3} {1} -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf format=vaapi|nv12,hwupload {2}",
+    # -vaapi_device is required in addition to -hwaccel_device: this is the only
+    # birdseye preset that uses hwupload, and ffmpeg 8 initializes filters before
+    # the decoder creates a device, so hwupload cannot see an -hwaccel_device one.
+    # See https://github.com/AlexxIT/go2rtc/issues/1984
+    FFMPEG_HWACCEL_VAAPI: "{0} -hide_banner -vaapi_device {3} -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_device {3} {1} -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf format=vaapi|nv12,hwupload {2}",
    "preset-intel-qsv-h264": "{0} -hide_banner {1} -c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1 {2}",
    "preset-intel-qsv-h265": "{0} -hide_banner {1} -c:v h264_qsv -g 50 -bf 0 -profile:v main -level:v 4.1 -async_depth:v 1 {2}",
    FFMPEG_HWACCEL_NVIDIA: "{0} -hide_banner {1} -c:v h264_nvenc -g 50 -profile:v high -level:v auto -preset:v p2 -tune:v ll {2}",
@@ -281,6 +281,11 @@ class GenAIClient:
        """Whether the configured model exposes a per-request thinking toggle."""
        return False

+    @property
+    def supports_embeddings(self) -> bool:
+        """Whether the configured model can generate embeddings via embed()."""
+        return False
+
    def list_models(self) -> list[str]:
        """Return the list of model names available from this provider.

@@ -121,5 +121,6 @@ class GenAIClientManager:
                "models": client.list_models(),
                "roles": [r.value for r in genai_cfg.roles],
                "supports_toggleable_thinking": client.supports_toggleable_thinking,
+                "supports_embeddings": client.supports_embeddings,
            }
        return result
@@ -38,6 +38,37 @@ def _encode_thought_signature(signature: bytes | None) -> str | None:
    return base64.b64encode(signature).decode("ascii")


+def _decode_data_uri(url: str) -> tuple[str, bytes] | None:
+    """Decode a ``data:`` URI into ``(mime_type, bytes)``; None if not a data URI."""
+    if not isinstance(url, str) or not url.startswith("data:"):
+        return None
+    try:
+        header, b64 = url.split(",", 1)
+        mime = header[len("data:") :].split(";")[0] or "image/jpeg"
+        return mime, base64.b64decode(b64)
+    except (ValueError, binascii.Error):
+        return None
+
+
+def _parts_from_content(content: Any) -> list[types.Part]:
+    """Convert OpenAI-style message content (str or multimodal list) to Gemini parts."""
+    if isinstance(content, list):
+        parts: list[types.Part] = []
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            if item.get("type") == "text":
+                parts.append(types.Part.from_text(text=item.get("text") or ""))
+            elif item.get("type") == "image_url":
+                decoded = _decode_data_uri((item.get("image_url") or {}).get("url", ""))
+                if decoded is not None:
+                    mime, data = decoded
+                    parts.append(types.Part.from_bytes(data=data, mime_type=mime))
+        # Gemini rejects empty parts; fall back to a single space.
+        return parts or [types.Part.from_text(text=" ")]
+    return [types.Part.from_text(text=content or "")]
+
+
 def _stats_from_gemini_usage(usage: Any) -> dict[str, Any] | None:
    """Build a stats dict from a Gemini usage_metadata object."""
    prompt_tokens = getattr(usage, "prompt_token_count", None)
@@ -227,9 +258,7 @@ class GeminiClient(GenAIClient):
                    )
                else:  # user
                    gemini_messages.append(
-                        types.Content(
-                            role="user", parts=[types.Part.from_text(text=content)]
-                        )
+                        types.Content(role="user", parts=_parts_from_content(content))
                    )

            # Convert tools to Gemini format
@@ -485,9 +514,7 @@ class GeminiClient(GenAIClient):
                    )
                else:  # user
                    gemini_messages.append(
-                        types.Content(
-                            role="user", parts=[types.Part.from_text(text=content)]
-                        )
+                        types.Content(role="user", parts=_parts_from_content(content))
                    )

            # Convert tools to Gemini format
@@ -553,7 +580,7 @@ class GeminiClient(GenAIClient):
            # Use streaming API
            content_parts: list[str] = []
            reasoning_parts: list[str] = []
-            tool_calls_by_index: dict[int, dict[str, Any]] = {}
+            tool_calls_accum: list[dict[str, Any]] = []
            finish_reason = "stop"
            usage_stats: dict[str, Any] | None = None

@@ -600,7 +627,11 @@ class GeminiClient(GenAIClient):
                                content_parts.append(part.text)
                                yield ("content_delta", part.text)
                        elif part.function_call:
-                            # Handle function call
+                            # Gemini streams complete function calls (not partial
+                            # argument deltas), so each part is a distinct tool
+                            # call. Append rather than accumulate by name — the
+                            # latter concatenated parallel/repeated calls into one
+                            # invalid arguments string (e.g. `{...}{...}`).
                            try:
                                arguments = (
                                    dict(part.function_call.args)
@@ -610,40 +641,16 @@ class GeminiClient(GenAIClient):
                            except Exception:
                                arguments = {}

-                            # Store tool call
-                            tool_call_id = part.function_call.name or ""
-                            tool_call_name = part.function_call.name or ""
-
-                            # Check if we already have this tool call
-                            found_index = None
-                            for idx, tc in tool_calls_by_index.items():
-                                if tc["name"] == tool_call_name:
-                                    found_index = idx
-                                    break
-
-                            if found_index is None:
-                                found_index = len(tool_calls_by_index)
-                                tool_calls_by_index[found_index] = {
-                                    "id": tool_call_id,
-                                    "name": tool_call_name,
-                                    "arguments": "",
-                                    "thought_signature": None,
+                            tool_calls_accum.append(
+                                {
+                                    "id": part.function_call.name or "",
+                                    "name": part.function_call.name or "",
+                                    "arguments": arguments,
+                                    "thought_signature": getattr(
+                                        part, "thought_signature", None
+                                    ),
                                }
-
-                            # Accumulate arguments
-                            if arguments:
-                                tool_calls_by_index[found_index]["arguments"] += (
-                                    json.dumps(arguments)
-                                    if isinstance(arguments, dict)
-                                    else str(arguments)
-                                )
-
-                            # Capture latest thought_signature for this call
-                            chunk_sig = getattr(part, "thought_signature", None)
-                            if chunk_sig:
-                                tool_calls_by_index[found_index][
-                                    "thought_signature"
-                                ] = chunk_sig
+                            )

            # Build final message
            full_content = "".join(content_parts).strip() or None
@@ -651,25 +658,20 @@ class GeminiClient(GenAIClient):

            # Convert tool calls to list format
            tool_calls_list = None
-            if tool_calls_by_index:
-                tool_calls_list = []
-                for tc in tool_calls_by_index.values():
-                    try:
-                        # Try to parse accumulated arguments as JSON
-                        parsed_args = json.loads(tc["arguments"])
-                    except (json.JSONDecodeError, Exception):
-                        parsed_args = tc["arguments"]
-
-                    tool_calls_list.append(
-                        {
-                            "id": tc["id"],
-                            "name": tc["name"],
-                            "arguments": parsed_args,
-                            "thought_signature": _encode_thought_signature(
-                                tc.get("thought_signature")
-                            ),
-                        }
-                    )
+            if tool_calls_accum:
+                tool_calls_list = [
+                    {
+                        "id": tc["id"],
+                        "name": tc["name"],
+                        "arguments": tc["arguments"]
+                        if isinstance(tc["arguments"], dict)
+                        else {},
+                        "thought_signature": _encode_thought_signature(
+                            tc.get("thought_signature")
+                        ),
+                    }
+                    for tc in tool_calls_accum
+                ]
                finish_reason = "tool_calls"

            if usage_stats is not None:
@@ -76,29 +76,6 @@ def _parse_launch_arg(args: list[str], flag: str) -> str | None:
    return args[idx + 1]


-def _fetch_llama_props(base_url: str, model: str) -> dict[str, Any]:
-    """Fetch /props from a llama.cpp server, with llama-swap fallback.
-
-    Raises the underlying RequestException if both endpoints fail; callers
-    decide how to surface the failure.
-    """
-    try:
-        response = requests.get(
-            f"{base_url}/props",
-            params={"model": model},
-            timeout=10,
-        )
-        response.raise_for_status()
-        return cast(dict[str, Any], response.json())
-    except Exception:
-        response = requests.get(
-            f"{base_url}/upstream/{model}/props",
-            timeout=10,
-        )
-        response.raise_for_status()
-        return cast(dict[str, Any], response.json())
-
-
 def _to_jpeg(img_bytes: bytes) -> bytes | None:
    """Convert image bytes to JPEG. llama.cpp/STB does not support WebP."""
    try:
@@ -128,6 +105,48 @@ class LlamaCppClient(GenAIClient):
    _text_baseline_tokens: int | None
    _media_marker: str

+    @property
+    def supports_embeddings(self) -> bool:
+        """llama.cpp exposes an /embeddings endpoint for any loaded model."""
+        return True
+
+    def _auth_headers(self) -> dict | None:
+        """Bearer auth header when an API key is configured, else None."""
+        if self.genai_config.api_key:
+            return {"Authorization": "Bearer " + self.genai_config.api_key}
+
+        return None
+
+    def _get(self, url: str, **kwargs: Any) -> requests.Response:
+        """GET with the configured auth headers injected."""
+        return requests.get(url, headers=self._auth_headers(), **kwargs)
+
+    def _post(self, url: str, **kwargs: Any) -> requests.Response:
+        """POST with the configured auth headers injected."""
+        return requests.post(url, headers=self._auth_headers(), **kwargs)
+
+    def _fetch_llama_props(self, base_url: str, model: str) -> dict[str, Any]:
+        """Fetch /props from a llama.cpp server, with llama-swap fallback.
+
+        Raises the underlying RequestException if both endpoints fail; callers
+        decide how to surface the failure.
+        """
+        try:
+            response = self._get(
+                f"{base_url}/props",
+                params={"model": model},
+                timeout=10,
+            )
+            response.raise_for_status()
+            return cast(dict[str, Any], response.json())
+        except Exception:
+            response = self._get(
+                f"{base_url}/upstream/{model}/props",
+                timeout=10,
+            )
+            response.raise_for_status()
+            return cast(dict[str, Any], response.json())
+
    def _init_provider(self) -> str | None:
        """Initialize the client and query model metadata from the server."""
        self.provider_options = {
@@ -211,7 +230,7 @@ class LlamaCppClient(GenAIClient):

        model_entry: dict[str, Any] | None = None
        try:
-            response = requests.get(f"{base_url}/v1/models", timeout=10)
+            response = self._get(f"{base_url}/v1/models", timeout=10)
            response.raise_for_status()
            models_data = response.json()

@@ -272,7 +291,7 @@ class LlamaCppClient(GenAIClient):
                info["supports_tools"] = True

        try:
-            props = _fetch_llama_props(base_url, configured_model)
+            props = self._fetch_llama_props(base_url, configured_model)

            if info["context_size"] is None:
                default_settings = props.get("default_generation_settings", {})
@@ -358,7 +377,7 @@ class LlamaCppClient(GenAIClient):
            if self.supports_toggleable_thinking:
                payload["chat_template_kwargs"] = {"enable_thinking": enable_thinking}

-            response = requests.post(
+            response = self._post(
                f"{self.provider}/v1/chat/completions",
                json=payload,
                timeout=self.timeout,
@@ -408,7 +427,7 @@ class LlamaCppClient(GenAIClient):
        if base_url is None:
            return []
        try:
-            response = requests.get(f"{base_url}/v1/models", timeout=10)
+            response = self._get(f"{base_url}/v1/models", timeout=10)
            response.raise_for_status()
            models = []
            for m in response.json().get("data", []):
@@ -511,7 +530,7 @@ class LlamaCppClient(GenAIClient):
            "messages": [{"role": "user", "content": content}],
            "max_tokens": 1,
        }
-        response = requests.post(
+        response = self._post(
            f"{self.provider}/v1/chat/completions",
            json=payload,
            timeout=60,
@@ -621,7 +640,7 @@ class LlamaCppClient(GenAIClient):
        if self.provider is None:
            return False
        try:
-            props = _fetch_llama_props(self.provider, self.genai_config.model)
+            props = self._fetch_llama_props(self.provider, self.genai_config.model)
        except Exception as e:
            logger.warning("Failed to refresh llama.cpp media marker: %s", e)
            return False
@@ -682,7 +701,7 @@ class LlamaCppClient(GenAIClient):
            return content

        def post_embeddings() -> requests.Response:
-            return requests.post(
+            return self._post(
                f"{self.provider}/embeddings",
                json={"model": self.genai_config.model, "content": build_content()},
                timeout=self.timeout,
@@ -786,7 +805,7 @@ class LlamaCppClient(GenAIClient):
                stream=False,
                enable_thinking=enable_thinking,
            )
-            response = requests.post(
+            response = self._post(
                f"{self.provider}/v1/chat/completions",
                json=payload,
                timeout=self.timeout,
@@ -867,6 +886,7 @@ class LlamaCppClient(GenAIClient):
                    "POST",
                    f"{self.provider}/v1/chat/completions",
                    json=payload,
+                    headers=self._auth_headers(),
                ) as response:
                    response.raise_for_status()
                    async for line in response.aiter_lines():
@@ -423,9 +423,18 @@ class OpenAIClient(GenAIClient):
                for tc in tool_calls_by_index.values():
                    try:
                        # Parse accumulated arguments as JSON
-                        parsed_args = json.loads(tc["arguments"])
-                    except (json.JSONDecodeError, Exception):
-                        parsed_args = tc["arguments"]
+                        parsed_args = json.loads(tc["arguments"] or "{}")
+                    except (json.JSONDecodeError, ValueError):
+                        logger.warning(
+                            "Failed to parse streamed tool call arguments for %s",
+                            tc["name"],
+                        )
+                        parsed_args = {}
+
+                    # Downstream (ToolCall model) requires a dict; never leak a
+                    # partial/invalid arguments string.
+                    if not isinstance(parsed_args, dict):
+                        parsed_args = {}

                    tool_calls_list.append(
                        {
@@ -6,7 +6,7 @@ transport.
 """

 import datetime
-from typing import Any
+from typing import Any, Literal

 from playhouse.shortcuts import model_to_dict

@@ -249,6 +249,7 @@ def get_attribute_classifications(config: FrigateConfig) -> list[dict[str, Any]]
 def get_tool_definitions(
    semantic_search_enabled: bool = False,
    attribute_classifications: list[dict[str, Any]] | None = None,
+    embeddings_language: Literal["english", "multi"] = "multi",
 ) -> list[dict[str, Any]]:
    """
    Get OpenAI-compatible tool definitions for Frigate.
@@ -258,7 +259,9 @@ def get_tool_definitions(
    tool exposes an additional `semantic_query` parameter for descriptive
    queries (e.g. "person riding a lawn mower") and find_similar_objects is
    included. When attribute classification models are configured, an
-    `attribute` parameter is exposed for filtering by their labels.
+    `attribute` parameter is exposed for filtering by their labels. When the
+    embeddings model only understands English (JinaV1), the `semantic_query`
+    description instructs the model to write the query in English.
    """
    search_objects_properties: dict[str, Any] = {
        "camera": {
@@ -349,6 +352,14 @@ def get_tool_definitions(
                "When set, combine with label/time/camera/zone filters as "
                "usual (e.g. label='person', semantic_query='riding a lawn "
                "mower', after='2024-05-01T00:00:00Z')."
+                + (
+                    " The configured embeddings model only understands "
+                    "English, so always write semantic_query in English, "
+                    "translating the user's description if they phrased it "
+                    "in another language."
+                    if embeddings_language == "english"
+                    else ""
+                )
            ),
        }

@@ -682,14 +693,17 @@ def build_chat_system_prompt(
            if camera_config.friendly_name
            else camera_id.replace("_", " ").title()
        )
-        zone_names = list(camera_config.zones.keys())
+        zone_descriptors = [
+            f"{zone_config.get_formatted_name(zone_name)} (ID: {zone_name})"
+            for zone_name, zone_config in camera_config.zones.items()
+        ]
        if not has_speed_zone:
            has_speed_zone = any(
                zone.distances for zone in camera_config.zones.values()
            )
-        if zone_names:
+        if zone_descriptors:
            cameras_info.append(
-                f"  - {friendly_name} (ID: {camera_id}, zones: {', '.join(zone_names)})"
+                f"  - {friendly_name} (ID: {camera_id}, zones: {', '.join(zone_descriptors)})"
            )
        else:
            cameras_info.append(f"  - {friendly_name} (ID: {camera_id})")
@@ -699,7 +713,7 @@ def build_chat_system_prompt(
        cameras_section = (
            "\n\nAvailable cameras:\n"
            + "\n".join(cameras_info)
-            + "\n\nWhen users refer to cameras by their friendly name (e.g., 'Back Deck Camera'), use the corresponding camera ID (e.g., 'back_deck_cam') in tool calls."
+            + "\n\nWhen users refer to cameras or zones by their friendly name (e.g., 'Back Deck Camera', 'Front Walkway'), use the corresponding ID (e.g., 'back_deck_cam', 'front_walk') in tool calls. Tool results also identify zones by their ID, so when presenting cameras or zones back to the user, translate the ID to its friendly name."
        )

    speed_units_section = ""
@@ -335,6 +335,7 @@ 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:
@@ -372,6 +373,13 @@ 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
@@ -482,6 +490,7 @@ 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
@@ -500,21 +509,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,
-                    # 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,
-                    ),
-                )
+                active_cameras_to_add = sorted_active_cameras
                if len(active_cameras) == 1:
                    # show single camera as fullscreen
                    camera = active_cameras_to_add[0]
@@ -780,6 +789,7 @@ 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
@@ -20,6 +20,10 @@ 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,
@@ -194,7 +198,9 @@ class PtzAutoTrackerThread(threading.Thread):

    def run(self):
        while not self.stop_event.wait(1):
-            for camera, camera_config in self.config.cameras.items():
+            self.ptz_autotracker.check_for_updates()
+
+            for camera, camera_config in list(self.config.cameras.items()):
                if not camera_config.enabled:
                    continue

@@ -211,6 +217,7 @@ 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...")


@@ -244,6 +251,16 @@ 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:
@@ -260,6 +277,29 @@ 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")

@@ -1365,7 +1405,7 @@ class PtzAutoTracker:
        camera_config = self.config.cameras[camera]

        if camera_config.onvif.autotracking.enabled:
-            if not self.autotracker_init[camera]:
+            if not self.autotracker_init.get(camera):
                future = asyncio.run_coroutine_threadsafe(
                    self._autotracker_setup(camera_config, camera), self.onvif.loop
                )
@@ -1483,9 +1523,11 @@ class PtzAutoTracker:
                }

    async def camera_maintenance(self, camera):
-        # bail and don't check anything if we're calibrating or tracking an object
+        # 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
        if (
-            not self.autotracker_init[camera]
+            not self.autotracker_init.get(camera)
            or self.calibrating[camera]
            or self.tracked_object[camera] is not None
        ):
@@ -344,16 +344,17 @@ class OnvifController:
            autotracking_config.enabled_in_config and autotracking_config.enabled
        )

-        # 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
+        # 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

-            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 (
@@ -1,8 +1,10 @@
 """Test camera user and password cleanup."""

+import multiprocessing as mp
 import unittest

-from frigate.output.birdseye import get_canvas_shape
+from frigate.config import FrigateConfig
+from frigate.output.birdseye import BirdsEyeFrameManager, get_canvas_shape


 class TestBirdseye(unittest.TestCase):
@@ -45,3 +47,70 @@ class TestBirdseye(unittest.TestCase):
        canvas_width, canvas_height = get_canvas_shape(width, height)
        assert canvas_width == width  # width will be the same
        assert canvas_height != height
+
+
+class TestBirdseyeCameraOrder(unittest.TestCase):
+    """Test that birdseye reacts to camera order changes without a restart."""
+
+    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())
+
+        # 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
+
+    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_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
+
+        self.manager.update_frame()
+
+        assert self.layout_order() == ["side", "back", "front"]
+
+    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"]
+
+        # 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_changed = self.manager.update_frame()
+
+        assert layout_changed
+        assert self.layout_order() == ["side", "back", "front"]
+
+    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_changed = self.manager.update_frame()
+
+        assert not layout_changed
+        assert self.layout_order() == ["back", "front", "side"]
@@ -397,6 +397,43 @@ class TestConfig(unittest.TestCase):
        assert "dog" in frigate_config.cameras["back"].objects.filters
        assert frigate_config.cameras["back"].objects.filters["dog"].threshold == 0.7

+    def test_unsupported_tracked_object_pruned_from_track_and_filters(self):
+        # "unicorn" is not in the model labelmap, so it must be removed from the
+        # tracked objects AND from the object filters, otherwise a stale filter
+        # entry lingers in the parsed config.
+        config = {
+            "mqtt": {"host": "mqtt"},
+            "cameras": {
+                "back": {
+                    "ffmpeg": {
+                        "inputs": [
+                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
+                        ]
+                    },
+                    "detect": {
+                        "height": 1080,
+                        "width": 1920,
+                        "fps": 5,
+                    },
+                    "objects": {
+                        "track": ["person", "unicorn"],
+                        "filters": {
+                            "person": {"threshold": 0.7},
+                            "unicorn": {"threshold": 0.7},
+                        },
+                    },
+                }
+            },
+        }
+
+        frigate_config = FrigateConfig(**config)
+        objects = frigate_config.cameras["back"].objects
+        assert "unicorn" not in objects.track
+        assert "unicorn" not in objects.filters
+        # supported entries are left untouched
+        assert "person" in objects.track
+        assert "person" in objects.filters
+
    def test_global_object_mask(self):
        config = {
            "mqtt": {"host": "mqtt"},
@@ -0,0 +1,496 @@
+"""Smoke tests for GenAI chat providers.
+
+Each provider's ``chat_with_tools_stream`` is driven with a canned "test
+response" so the two conversion layers are exercised without any network:
+
+  1. Frigate (OpenAI-style) messages -> provider-native request format
+  2. provider-native response -> Frigate ``("kind", value)`` stream events
+
+These guard against regressions such as tool-call arguments arriving as raw
+strings instead of dicts (which crash the ``ToolCall`` model), and multimodal
+user content (a list of text/image parts, as injected by ``get_live_context``)
+crashing message conversion.
+"""
+
+import asyncio
+import base64
+import json
+import unittest
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from frigate.config import GenAIConfig, GenAIProviderEnum
+from frigate.genai import PROVIDERS, load_providers
+
+load_providers()
+
+# A minimal but valid JPEG data URI, mirroring what get_live_context injects.
+_TINY_JPEG = base64.b64encode(b"\xff\xd8\xff\xd9").decode("ascii")
+_IMAGE_DATA_URI = f"data:image/jpeg;base64,{_TINY_JPEG}"
+
+# Conversation ending in a multimodal user message (text + live image), the
+# exact shape the chat endpoint builds after a get_live_context tool result.
+MULTIMODAL_MESSAGES = [
+    {"role": "system", "content": "You are a test assistant."},
+    {"role": "user", "content": "what do you see on the front camera?"},
+    {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+            {
+                "id": "call_1",
+                "type": "function",
+                "function": {
+                    "name": "get_live_context",
+                    "arguments": json.dumps({"camera": "front"}),
+                },
+            }
+        ],
+    },
+    {
+        "role": "tool",
+        "tool_call_id": "call_1",
+        "name": "get_live_context",
+        "content": json.dumps({"camera": "front"}),
+    },
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "text",
+                "text": "Here is the current live image from camera 'front'.",
+            },
+            {"type": "image_url", "image_url": {"url": _IMAGE_DATA_URI}},
+        ],
+    },
+]
+
+SIMPLE_MESSAGES = [
+    {"role": "system", "content": "You are a test assistant."},
+    {"role": "user", "content": "hello"},
+]
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "search_objects",
+            "description": "Search tracked objects",
+            "parameters": {
+                "type": "object",
+                "properties": {"label": {"type": "string"}},
+            },
+        },
+    }
+]
+
+
+def _make_client(provider: str, **cfg_overrides):
+    """Build a provider client offline (no model validation, no network)."""
+    cfg = GenAIConfig(provider=provider, **cfg_overrides)
+    cls = PROVIDERS[GenAIProviderEnum(provider)]
+    return cls(cfg, timeout=5, validate_model=False)
+
+
+def _collect(client, messages, tools=TOOLS):
+    """Drain chat_with_tools_stream into a list of (kind, value) events."""
+
+    async def _run():
+        events = []
+        async for event in client.chat_with_tools_stream(
+            messages=messages, tools=tools, tool_choice="auto"
+        ):
+            events.append(event)
+        return events
+
+    return asyncio.run(_run())
+
+
+def _final_message(events) -> dict:
+    messages = [value for (kind, value) in events if kind == "message"]
+    assert messages, f"stream produced no final message: {events}"
+    return messages[-1]
+
+
+def _assert_tool_args_are_dicts(final: dict) -> None:
+    """Every returned tool call must expose arguments as a dict, never a string."""
+    for tool_call in final.get("tool_calls") or []:
+        assert isinstance(tool_call["arguments"], dict), (
+            f"tool call arguments must be a dict, got "
+            f"{type(tool_call['arguments']).__name__}: {tool_call['arguments']!r}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# OpenAI
+# ---------------------------------------------------------------------------
+def _openai_tc(index, id=None, name=None, arguments=None):
+    return SimpleNamespace(
+        index=index,
+        id=id,
+        function=SimpleNamespace(name=name, arguments=arguments),
+    )
+
+
+def _openai_chunk(content=None, tool_calls=None, finish_reason=None, usage=None):
+    delta = SimpleNamespace(
+        content=content,
+        tool_calls=tool_calls,
+        reasoning_content=None,
+        reasoning=None,
+    )
+    choice = SimpleNamespace(delta=delta, finish_reason=finish_reason)
+    return SimpleNamespace(choices=[choice], usage=usage)
+
+
+class TestOpenAIProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client(
+            "openai", model="gpt-4o", api_key="k", base_url="http://localhost:9999/v1"
+        )
+
+    def test_stream_tool_call_arguments_are_dict(self):
+        # Arguments arrive split across chunks, as the real API streams them.
+        chunks = [
+            _openai_chunk(
+                tool_calls=[
+                    _openai_tc(0, id="c1", name="search_objects", arguments='{"label":')
+                ]
+            ),
+            _openai_chunk(tool_calls=[_openai_tc(0, arguments=' "person"}')]),
+            _openai_chunk(finish_reason="tool_calls"),
+        ]
+        client = self._client()
+        client.provider.chat.completions.create = MagicMock(return_value=iter(chunks))
+
+        final = _final_message(_collect(client, SIMPLE_MESSAGES))
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        self.assertEqual(len(final["tool_calls"]), 1)
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+
+    def test_stream_content_response(self):
+        chunks = [
+            _openai_chunk(content="hel"),
+            _openai_chunk(content="lo"),
+            _openai_chunk(finish_reason="stop"),
+        ]
+        client = self._client()
+        client.provider.chat.completions.create = MagicMock(return_value=iter(chunks))
+
+        events = _collect(client, SIMPLE_MESSAGES)
+        deltas = [v for (k, v) in events if k == "content_delta"]
+        self.assertEqual("".join(deltas), "hello")
+        self.assertEqual(_final_message(events)["content"], "hello")
+
+    def test_multimodal_message_does_not_crash(self):
+        client = self._client()
+        client.provider.chat.completions.create = MagicMock(
+            return_value=iter([_openai_chunk(content="ok", finish_reason="stop")])
+        )
+        # Passing the OpenAI-native multimodal list through must not raise.
+        final = _final_message(_collect(client, MULTIMODAL_MESSAGES))
+        self.assertEqual(final["content"], "ok")
+
+
+# ---------------------------------------------------------------------------
+# Gemini
+# ---------------------------------------------------------------------------
+def _gemini_part(text=None, thought=False, function_call=None, thought_signature=None):
+    return SimpleNamespace(
+        text=text,
+        thought=thought,
+        function_call=function_call,
+        thought_signature=thought_signature,
+    )
+
+
+def _gemini_chunk(parts, finish_reason=None, usage_metadata=None):
+    candidate = SimpleNamespace(
+        content=SimpleNamespace(parts=parts), finish_reason=finish_reason
+    )
+    return SimpleNamespace(candidates=[candidate], usage_metadata=usage_metadata)
+
+
+def _gemini_stream(chunks):
+    async def _agen(*args, **kwargs):
+        for chunk in chunks:
+            yield chunk
+
+    return _agen
+
+
+class TestGeminiProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client("gemini", model="gemini-2.5-flash", api_key="k")
+
+    def _patch_stream(self, client, chunks):
+        client.provider = MagicMock()
+        client.provider.aio.models.generate_content_stream = AsyncMock(
+            side_effect=_gemini_stream(chunks)
+        )
+
+    def test_stream_parallel_tool_calls_stay_separate_dicts(self):
+        # Regression: Gemini streams complete function calls. Two calls to the
+        # same tool must NOT be merged into one concatenated arguments string.
+        from google.genai.types import FinishReason
+
+        chunks = [
+            _gemini_chunk(
+                parts=[
+                    _gemini_part(
+                        function_call=SimpleNamespace(
+                            name="search_objects", args={"label": "person"}
+                        )
+                    ),
+                    _gemini_part(
+                        function_call=SimpleNamespace(
+                            name="search_objects", args={"limit": 1}
+                        )
+                    ),
+                ],
+                finish_reason=FinishReason.STOP,
+            ),
+        ]
+        client = self._client()
+        self._patch_stream(client, chunks)
+
+        final = _final_message(_collect(client, SIMPLE_MESSAGES))
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        self.assertEqual(len(final["tool_calls"]), 2)
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+        self.assertEqual(final["tool_calls"][1]["arguments"], {"limit": 1})
+
+    def test_stream_content_response(self):
+        from google.genai.types import FinishReason
+
+        chunks = [
+            _gemini_chunk(parts=[_gemini_part(text="hel")]),
+            _gemini_chunk(
+                parts=[_gemini_part(text="lo")], finish_reason=FinishReason.STOP
+            ),
+        ]
+        client = self._client()
+        self._patch_stream(client, chunks)
+
+        events = _collect(client, SIMPLE_MESSAGES)
+        deltas = [v for (k, v) in events if k == "content_delta"]
+        self.assertEqual("".join(deltas), "hello")
+        self.assertEqual(_final_message(events)["content"], "hello")
+
+    def test_multimodal_message_converts_without_crash(self):
+        # Regression: a user message with list content (text + image_url) used
+        # to be handed to Part.from_text(text=<list>) and raise ValidationError.
+        from google.genai.types import FinishReason
+
+        client = self._client()
+        self._patch_stream(
+            client,
+            [
+                _gemini_chunk(
+                    parts=[_gemini_part(text="ok")], finish_reason=FinishReason.STOP
+                )
+            ],
+        )
+        final = _final_message(_collect(client, MULTIMODAL_MESSAGES))
+        self.assertEqual(final["content"], "ok")
+
+
+# ---------------------------------------------------------------------------
+# Ollama
+# ---------------------------------------------------------------------------
+class TestOllamaProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client("ollama", model="llama3", base_url="http://localhost:9999")
+
+    def _run_with_response(self, client, response, messages):
+        # Ollama uses a non-streaming call when tools are present, via an
+        # internally-constructed async client.
+        fake_async = MagicMock()
+        fake_async.chat = AsyncMock(return_value=response)
+        with patch(
+            "frigate.genai.plugins.ollama.OllamaAsyncClient",
+            return_value=fake_async,
+        ):
+            return _collect(client, messages)
+
+    def test_tool_call_arguments_are_dict(self):
+        response = {
+            "message": {
+                "content": "",
+                "tool_calls": [
+                    {
+                        "function": {
+                            "name": "search_objects",
+                            "arguments": {"label": "person"},
+                        }
+                    }
+                ],
+            },
+            "done": True,
+            "done_reason": "stop",
+            "eval_count": 5,
+            "prompt_eval_count": 3,
+            "eval_duration": 1_000_000,
+        }
+        client = self._client()
+        final = _final_message(
+            self._run_with_response(client, response, SIMPLE_MESSAGES)
+        )
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+
+    def test_multimodal_message_normalizes_image(self):
+        # Ollama needs content as a string with images pulled into a separate
+        # field; the normalizer must extract both without crashing.
+        response = {
+            "message": {"content": "ok"},
+            "done": True,
+            "done_reason": "stop",
+        }
+        client = self._client()
+        final = _final_message(
+            self._run_with_response(client, response, MULTIMODAL_MESSAGES)
+        )
+        self.assertEqual(final["content"], "ok")
+
+    def test_normalize_multimodal_content(self):
+        from frigate.genai.plugins.ollama import _normalize_multimodal_content
+
+        text, images = _normalize_multimodal_content(MULTIMODAL_MESSAGES[-1]["content"])
+        self.assertIn("live image", text)
+        self.assertEqual(len(images), 1)
+        self.assertEqual(images[0], b"\xff\xd8\xff\xd9")
+
+
+# ---------------------------------------------------------------------------
+# llama.cpp
+# ---------------------------------------------------------------------------
+class _FakeStreamResponse:
+    def __init__(self, lines):
+        self._lines = lines
+
+    def raise_for_status(self):
+        return None
+
+    async def aiter_lines(self):
+        for line in self._lines:
+            yield line
+
+
+class _FakeStreamCtx:
+    def __init__(self, lines):
+        self._resp = _FakeStreamResponse(lines)
+
+    async def __aenter__(self):
+        return self._resp
+
+    async def __aexit__(self, *exc):
+        return False
+
+
+class _FakeAsyncClient:
+    def __init__(self, lines):
+        self._lines = lines
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *exc):
+        return False
+
+    def stream(self, method, url, json=None, headers=None):
+        return _FakeStreamCtx(self._lines)
+
+
+class TestLlamaCppProvider(unittest.TestCase):
+    def _client(self):
+        return _make_client("llamacpp", model="m", base_url="http://localhost:9999")
+
+    def _run_with_lines(self, client, lines, messages):
+        with patch(
+            "frigate.genai.plugins.llama_cpp.httpx.AsyncClient",
+            return_value=_FakeAsyncClient(lines),
+        ):
+            return _collect(client, messages)
+
+    def test_stream_tool_call_arguments_are_dict(self):
+        lines = [
+            "data: "
+            + json.dumps(
+                {
+                    "choices": [
+                        {
+                            "delta": {
+                                "tool_calls": [
+                                    {
+                                        "index": 0,
+                                        "id": "c1",
+                                        "function": {
+                                            "name": "search_objects",
+                                            "arguments": '{"label":',
+                                        },
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ),
+            "data: "
+            + json.dumps(
+                {
+                    "choices": [
+                        {
+                            "delta": {
+                                "tool_calls": [
+                                    {
+                                        "index": 0,
+                                        "function": {"arguments": ' "person"}'},
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ),
+            "data: "
+            + json.dumps({"choices": [{"delta": {}, "finish_reason": "tool_calls"}]}),
+            "data: [DONE]",
+        ]
+        client = self._client()
+        final = _final_message(self._run_with_lines(client, lines, SIMPLE_MESSAGES))
+        self.assertEqual(final["finish_reason"], "tool_calls")
+        _assert_tool_args_are_dicts(final)
+        self.assertEqual(final["tool_calls"][0]["arguments"], {"label": "person"})
+
+    def test_stream_content_response(self):
+        lines = [
+            "data: " + json.dumps({"choices": [{"delta": {"content": "hel"}}]}),
+            "data: " + json.dumps({"choices": [{"delta": {"content": "lo"}}]}),
+            "data: "
+            + json.dumps({"choices": [{"delta": {}, "finish_reason": "stop"}]}),
+            "data: [DONE]",
+        ]
+        client = self._client()
+        events = self._run_with_lines(client, lines, SIMPLE_MESSAGES)
+        deltas = [v for (k, v) in events if k == "content_delta"]
+        self.assertEqual("".join(deltas), "hello")
+        self.assertEqual(_final_message(events)["content"], "hello")
+
+    def test_multimodal_message_does_not_crash(self):
+        lines = [
+            "data: " + json.dumps({"choices": [{"delta": {"content": "ok"}}]}),
+            "data: "
+            + json.dumps({"choices": [{"delta": {}, "finish_reason": "stop"}]}),
+            "data: [DONE]",
+        ]
+        client = self._client()
+        final = _final_message(self._run_with_lines(client, lines, MULTIMODAL_MESSAGES))
+        self.assertEqual(final["content"], "ok")
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -21,8 +21,12 @@ class TestGpuStats(unittest.TestCase):
    @patch("frigate.util.services.time.sleep")
    @patch("frigate.util.services.time.monotonic")
    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    def test_intel_gpu_stats_fdinfo(self, read_fdinfo, monotonic, sleep, get_names):
+    @patch("frigate.util.services._enumerate_drm_devices")
+    def test_intel_gpu_stats_fdinfo(
+        self, drm_devices, 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"}

@@ -40,18 +44,18 @@ class TestGpuStats(unittest.TestCase):
                "driver": "i915",
                "pid": "100",
                "engines": {
-                    "render": (1_000_000_000, 0),
-                    "video": (5_000_000_000, 0),
-                    "video-enhance": (200_000_000, 0),
-                    "compute": (0, 0),
+                    "render": (1_000_000_000, 0, 1),
+                    "video": (5_000_000_000, 0, 1),
+                    "video-enhance": (200_000_000, 0, 1),
+                    "compute": (0, 0, 1),
                },
            },
            ("0000:00:02.0", "2", "200"): {
                "driver": "i915",
                "pid": "200",
                "engines": {
-                    "render": (0, 0),
-                    "compute": (2_000_000_000, 0),
+                    "render": (0, 0, 1),
+                    "compute": (2_000_000_000, 0, 1),
                },
            },
        }
@@ -60,18 +64,18 @@ class TestGpuStats(unittest.TestCase):
                "driver": "i915",
                "pid": "100",
                "engines": {
-                    "render": (1_200_000_000, 0),
-                    "video": (5_500_000_000, 0),
-                    "video-enhance": (300_000_000, 0),
-                    "compute": (0, 0),
+                    "render": (1_200_000_000, 0, 1),
+                    "video": (5_500_000_000, 0, 1),
+                    "video-enhance": (300_000_000, 0, 1),
+                    "compute": (0, 0, 1),
                },
            },
            ("0000:00:02.0", "2", "200"): {
                "driver": "i915",
                "pid": "200",
                "engines": {
-                    "render": (0, 0),
-                    "compute": (2_100_000_000, 0),
+                    "render": (0, 0, 1),
+                    "compute": (2_100_000_000, 0, 1),
                },
            },
        }
@@ -92,7 +96,205 @@ 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.time.monotonic")
    @patch("frigate.util.services._read_intel_drm_fdinfo")
-    def test_intel_gpu_stats_no_clients(self, read_fdinfo):
+    @patch("frigate.util.services._enumerate_drm_devices")
+    def test_intel_gpu_stats_xe_capacity(
+        self, drm_devices, 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"}
+
+        # Deltas over the window (busy, total): render 200/1000 cap 1 = 20%,
+        # video 800/1000 cap 2 = 40%, video-enhance 400/1000 cap 2 = 20%,
+        # compute 100/1000 cap 1 = 10%. Without the capacity divisor video/
+        # video-enhance would read 80%/40% and dec would clamp at 100%.
+        snapshot_a = {
+            ("0000:03:00.0", "1", "300"): {
+                "driver": "xe",
+                "pid": "300",
+                "engines": {
+                    "render": (0, 0, 1),
+                    "video": (0, 0, 2),
+                    "video-enhance": (0, 0, 2),
+                    "compute": (0, 0, 1),
+                },
+            },
+        }
+        snapshot_b = {
+            ("0000:03:00.0", "1", "300"): {
+                "driver": "xe",
+                "pid": "300",
+                "engines": {
+                    "render": (200, 1000, 1),
+                    "video": (800, 1000, 2),
+                    "video-enhance": (400, 1000, 2),
+                    "compute": (100, 1000, 1),
+                },
+            },
+        }
+        read_fdinfo.side_effect = [snapshot_a, snapshot_b]
+
+        intel_stats = get_intel_gpu_stats(None)
+
+        assert intel_stats == {
+            "0000:03:00.0": {
+                "name": "Intel Arc",
+                "vendor": "intel",
+                "gpu": "90.0%",
+                "mem": "-%",
+                "compute": "30.0%",
+                "dec": "60.0%",
+                "clients": {"300": "90.0%"},
+            },
+        }
+
+    @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"}
        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%",
+            },
+        }
@@ -0,0 +1,130 @@
+"""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()
@@ -0,0 +1,147 @@
+"""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()
@@ -0,0 +1,54 @@
+"""Tests for the REGEXP function registered on the main Frigate database.
+
+Regression coverage for GHSA-q8jx-q884-jcq9: an attacker-controlled
+catastrophic (ReDoS) pattern reaching the REGEXP sink must not be able to
+stall the serialized database worker thread.
+"""
+
+import sqlite3
+import time
+import unittest
+
+from frigate.db.sqlitevecq import REGEXP_TIMEOUT_SECONDS, SqliteVecQueueDatabase
+
+
+class TestRegexpFunction(unittest.TestCase):
+    def setUp(self) -> None:
+        # autostart=False keeps the queue worker thread from spinning up; we
+        # only need the REGEXP registration, exercised on our own connection.
+        self.db = SqliteVecQueueDatabase(":memory:", autostart=False)
+        self.conn = sqlite3.connect(":memory:")
+        self.db._register_regexp(self.conn)
+
+    def tearDown(self) -> None:
+        self.conn.close()
+
+    def _regexp(self, value: str | None, pattern: str) -> int | None:
+        # SQLite maps "value REGEXP pattern" to regexp(pattern, value).
+        return self.conn.execute("SELECT ? REGEXP ?", (value, pattern)).fetchone()[0]
+
+    def test_normal_patterns_still_match(self) -> None:
+        self.assertTrue(self._regexp("ABC123", "^ABC"))
+        self.assertTrue(self._regexp("ABC123", "ABC.*"))
+        self.assertTrue(self._regexp("ABC123", "[0-9]+$"))
+        self.assertFalse(self._regexp("ABC123", "^XYZ"))
+
+    def test_null_value_does_not_match(self) -> None:
+        self.assertFalse(self._regexp(None, ".*"))
+
+    def test_invalid_pattern_does_not_raise(self) -> None:
+        self.assertFalse(self._regexp("ABC123", "(unclosed"))
+
+    def test_catastrophic_pattern_is_time_bounded(self) -> None:
+        # Without the timeout this evaluation backtracks for minutes to hours
+        # and wedges the whole database thread (GHSA-q8jx-q884-jcq9).
+        catastrophic = "(a{2,})+c"
+        subject = "a" * 4000
+
+        start = time.monotonic()
+        result = self._regexp(subject, catastrophic)
+        elapsed = time.monotonic() - start
+
+        # The pattern does not match; the guarantee is that it returns quickly.
+        self.assertFalse(result)
+        self.assertLess(elapsed, REGEXP_TIMEOUT_SECONDS + 2.0)
@@ -285,6 +285,10 @@ _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:
@@ -294,29 +298,70 @@ def _resolve_intel_gpu_pdev(device: str | None) -> str | None:
    if not device:
        return None

-    if re.match(r"^[0-9a-fA-F]{4}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-9a-fA-F]$", device):
+    if _PCI_ADDRESS_RE.match(device):
        return device

    name = os.path.basename(device.rstrip("/"))
    try:
-        return os.path.basename(os.path.realpath(f"/sys/class/drm/{name}/device"))
+        pdev = 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 _read_intel_drm_fdinfo(target_pdev: str | None) -> dict:
+
+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:
    """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.
+    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.
    """
    snapshot: dict = {}

    try:
        proc_entries = os.listdir("/proc")
    except OSError:
-        return snapshot
+        return None

    for entry in proc_entries:
        if not entry.isdigit():
@@ -360,7 +405,7 @@ def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict:
            if key in snapshot:
                continue

-            engines: dict[str, tuple[int, int]] = {}
+            engines: dict[str, tuple[int, int, int]] = {}

            if driver == "i915":
                for fkey, engine in _I915_ENGINE_KEYS.items():
@@ -368,58 +413,156 @@ def _read_intel_drm_fdinfo(target_pdev: str | None) -> dict:
                    if not raw:
                        continue
                    try:
-                        engines[engine] = (int(raw.split()[0]), 0)
+                        engines[engine] = (int(raw.split()[0]), 0, 1)
                    except (ValueError, IndexError):
                        continue
            else:
                for suffix, engine in _XE_ENGINE_KEYS.items():
                    busy_raw = fields.get(f"drm-cycles-{suffix}")
                    total_raw = fields.get(f"drm-total-cycles-{suffix}")
+
                    if not (busy_raw and total_raw):
                        continue
+
+                    # drm-cycles-* is summed across every instance of the engine
+                    # class while drm-total-cycles-* tracks a single instance, so
+                    # busy/total scales up to the capacity (e.g. Battlemage
+                    # reports 2 for vcs/vecs). Capture it to divide back out;
+                    # absent means a single engine, so default to 1.
+                    capacity_raw = fields.get(f"drm-engine-capacity-{suffix}")
+
+                    try:
+                        capacity = int(capacity_raw.split()[0]) if capacity_raw else 1
+                    except (ValueError, IndexError):
+                        capacity = 1
+
                    try:
                        engines[engine] = (
                            int(busy_raw.split()[0]),
                            int(total_raw.split()[0]),
+                            max(1, capacity),
                        )
                    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> (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%).
+    /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%).

    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: 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 "",
+            "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()})),
        )
        return None

@@ -428,12 +571,18 @@ def get_intel_gpu_stats(
    elapsed_ns = (time.monotonic() - start) * 1e9

    snapshot_b = _read_intel_drm_fdinfo(target_pdev)
-    if not snapshot_b or elapsed_ns <= 0:
-        logger.warning(
-            "Unable to collect Intel GPU stats: second DRM fdinfo sample was empty"
-        )
+    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"
+        )
+        return _idle_intel_gpu_stats(target_pdev, intel_pdevs)
+
    def _new_engine_pct() -> dict[str, float]:
        return {"render": 0.0, "video": 0.0, "video-enhance": 0.0, "compute": 0.0}

@@ -445,16 +594,23 @@ 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, {})

        client_total = 0.0
-        for engine, (busy_b, total_b) in data_b["engines"].items():
+        for engine, (busy_b, total_b, capacity) in data_b["engines"].items():
            if engine not in engine_pct:
                continue

-            busy_a, total_a = data_a["engines"].get(engine, (busy_b, total_b))
+            busy_a, total_a, _ = data_a["engines"].get(
+                engine, (busy_b, total_b, capacity)
+            )

            if data_b["driver"] == "i915":
                delta = max(0, busy_b - busy_a)
@@ -464,7 +620,9 @@ def get_intel_gpu_stats(
                delta_total = total_b - total_a
                if delta_total <= 0:
                    continue
-                pct = min(100.0, delta_busy / delta_total * 100.0)
+                # Normalize by capacity so a class with N engine instances
+                # (busy summed across all N) reports 0-100%, not 0-N*100%.
+                pct = min(100.0, delta_busy / (delta_total * capacity) * 100.0)

            engine_pct[engine] += pct
            client_total += pct
@@ -472,11 +630,12 @@ 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:
-        logger.warning(
-            "Unable to collect Intel GPU stats: no per-engine counters available "
-            "(i915 requires kernel >= 5.19)"
+        # 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"
        )
-        return None
+        return _idle_intel_gpu_stats(target_pdev, intel_pdevs)

    names = intel_gpu_name_resolver.get_names()
    results: dict[str, dict[str, Any]] = {}
@@ -61,7 +61,8 @@
      "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}}"
+        "failed": "No s'ha pogut inciar l'exportació: {{error}}",
+        "noValidTimeSelected": "No s'ha seleccionat cap interval de temps vàlid"
      },
      "view": "Vista",
      "queued": "Exporta a la cua. Mostra el progrés a la pàgina d'exportacions.",
@@ -493,6 +493,9 @@
            "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": {
@@ -380,6 +380,9 @@
            "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": {
@@ -192,7 +192,20 @@
    "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": "Nota: Canviar les classes d'estat requereix tornar a entrenar el model amb les classes actualitzades."
+    "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"
+    }
  },
  "tooltip": {
    "trainingInProgress": "El model s'està entrenant actualment",
@@ -202,5 +215,6 @@
  },
  "none": "Cap",
  "reclassifyImageAs": "Reclassifica la imatge com a:",
-  "reclassifyImage": "Reclassifica la imatge"
+  "reclassifyImage": "Reclassifica la imatge",
+  "disabled": "Desactivat"
 }
@@ -303,7 +303,7 @@
      },
      "offset": {
        "label": "Òfset d'Anotació",
-        "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.",
+        "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.",
        "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": {
@@ -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 nou compte d'usuari i especifica un rol per accedir a àrees de la interfície de Frigate."
+        "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."
      }
    },
    "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 la Fragata.",
+        "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.",
        "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 la fragata per aplicar tots els canvis.",
+        "successMultiWithRestart_other": "Configuració copiada a {{count}} càmeres. Reinicia Frigate 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,7 +1641,14 @@
      "keyLabel": "Clau",
      "valueLabel": "Valor",
      "keyPlaceholder": "Nou valor",
-      "remove": "Elimina"
+      "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)"
    },
    "timezone": {
      "defaultOption": "Utilitza la zona horària del navegador"
@@ -1,5 +1,6 @@
 {
  "documentTitle": "Classification Models - Frigate",
+  "disabled": "Disabled",
  "details": {
    "scoreInfo": "Score represents the average classification confidence across all detections of this object.",
    "none": "None",
@@ -64,7 +65,20 @@
    "title": "Edit Classification Model",
    "descriptionState": "Edit the classes for this state classification model. Changes will require retraining the model.",
    "descriptionObject": "Edit the object type and classification type for this object classification model.",
-    "stateClassesInfo": "Note: Changing state classes requires retraining the model with the updated classes."
+    "enabled": "Enabled",
+    "enabledDesc": "Run this model. When disabled, it stops running and no longer classifies.",
+    "saveAttempts": "Save Attempts",
+    "saveAttemptsDesc": "Number of classification attempt images to keep for the recent classifications UI.",
+    "motion": "Run on Motion",
+    "motionDesc": "Run classification when motion is detected within the configured crop.",
+    "interval": "Interval",
+    "intervalDesc": "Seconds between periodic classification runs. Leave empty to run only on motion.",
+    "intervalPlaceholder": "No interval",
+    "stateClassesInfo": "Model updated. Retrain the model for the class changes to take effect.",
+    "errors": {
+      "saveAttemptsInvalid": "Save attempts must be a whole number of 0 or greater",
+      "intervalInvalid": "Interval must be a whole number greater than 0"
+    }
  },
  "deleteDatasetImages": {
    "title": "Delete Dataset Images",
@@ -107,12 +107,7 @@
      },
      "npuUsage": "NPU Usage",
      "npuMemory": "NPU Memory",
-      "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."
-      }
+      "npuTemperature": "NPU Temperature"
    },
    "otherProcesses": {
      "title": "Other Processes",
@@ -273,5 +273,69 @@
  "sailboat": "Purjekas",
  "soundtrack_music": "Filmimuusika",
  "jingle": "Kõlisemine/tilisemine",
-  "theme_music": "Tunnusmuusika"
+  "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"
 }
@@ -37,6 +37,9 @@
          "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": {
@@ -70,18 +73,79 @@
      "success": "Eksportimise käivitamine õnnestus. Faili leiad eksportimise lehelt.",
      "view": "Vaata",
      "error": {
-        "failed": "Eksportimise käivitamine ei õnnestunud: {{error}}",
+        "failed": "Eksportimise järjekorda lisamine ei õnnestunud: {{error}}",
        "endTimeMustAfterStartTime": "Ajavahemiku lõpp peab olema peale algust",
-        "noVaildTimeSelected": "Ühtegi kehtivat ajavahemikku pole valitud"
-      }
+        "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}}"
    },
    "fromTimeline": {
      "saveExport": "Salvesta eksporditud sisu",
-      "previewExport": "Eksporditud sisu eelvaade"
+      "previewExport": "Eksporditud sisu eelvaade",
+      "queueingExport": "Ekspordi järjekorda lisamine...",
+      "useThisRange": "Kasuta seda vahemikku"
    },
    "case": {
      "label": "Juhtum",
-      "placeholder": "Vali 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}}"
+      }
    }
  },
  "streaming": {
@@ -114,6 +178,14 @@
        "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": {
@@ -12,11 +12,20 @@
        "description": "Kasutusel"
    },
    "audio": {
-        "label": "Helisündmused"
+        "label": "Heli tuvastus",
+        "min_volume": {
+            "label": "Minimaalne helitase"
+        },
+        "filters": {
+            "label": "Audio filtrid"
+        }
    },
    "birdseye": {
        "mode": {
            "label": "Jälgimisrežiim"
+        },
+        "order": {
+            "label": "Positsioon"
        }
    },
    "label": "Kaameraseadistus",
@@ -25,7 +34,8 @@
            "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",
@@ -34,6 +44,171 @@
    "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"
    }
 }
@@ -1,10 +1,31 @@
 {
    "audio": {
-        "label": "Helisündmused"
+        "label": "Heli tuvastus",
+        "min_volume": {
+            "label": "Minimaalne helitase"
+        },
+        "filters": {
+            "label": "Audio filtrid"
+        }
    },
    "birdseye": {
        "mode": {
            "label": "Jälgimisrežiim"
+        },
+        "order": {
+            "label": "Positsioon"
+        },
+        "height": {
+            "label": "Kõrgus"
+        },
+        "width": {
+            "label": "Laius"
+        },
+        "layout": {
+            "label": "Paigutus",
+            "scaling_factor": {
+                "label": "Skaleerimistegur"
+            }
        }
    },
    "version": {
@@ -22,6 +43,15 @@
            "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"
            }
        }
    },
@@ -30,11 +60,25 @@
            "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": {
@@ -42,15 +86,393 @@
        "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."
+        "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"
+        }
    },
    "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"
    }
 }
@@ -6,5 +6,67 @@
    "error": "Midagi läks valesti. Palun proovi uuesti.",
    "processing": "Töötlen…",
    "toolsUsed": "Kasutatud: {{tools}}",
-    "similarity_score": "Sarnasus"
+    "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"
+    }
 }
@@ -43,5 +43,8 @@
  },
  "tooltip": {
    "trainingInProgress": "Mudel on parasjagu õppimas"
+  },
+  "train": {
+    "titleShort": "Hiljutised"
  }
 }
@@ -5,7 +5,8 @@
  "noTrackedObjects": "Ühtegi jälgitavat objekti ei leidunud",
  "itemMenu": {
    "findSimilar": {
-      "aria": "Otsi sarnaseid jälgitavaid objekte"
+      "aria": "Otsi sarnaseid jälgitavaid objekte",
+      "label": "Leia sarnane"
    },
    "downloadSnapshot": {
      "label": "Laadi hetkvõte alla",
@@ -14,6 +15,14 @@
    "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": {
@@ -21,11 +30,22 @@
      "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}}"
+        "other": "{{label}} on tuvastatud kui {{attribute}}",
+        "faceOrLicense_plate": "{{attribute}} tuvastatud objektil {{label}}"
      },
      "stationary": "{{label}} jäi paigale",
      "active": "{{label}} muutus aktiivseks",
@@ -37,7 +57,8 @@
        "area": "Ala",
        "score": "Punktiskoor",
        "computedScore": "Arvutatud punktiskoor",
-        "topScore": "Suuremad punktiskoorid"
+        "topScore": "Suuremad punktiskoorid",
+        "toggleAdvancedScores": "Täpsemate tulemuste sisse-/väljalülitamine"
      },
      "external": "{{label}} on tuvastatud",
      "heard": "{{label}} on kuuldud",
@@ -50,7 +71,11 @@
      "previous": "Eelmine slaid",
      "next": "Järgmine slaid"
    },
-    "count": "{{first}} / {{second}}"
+    "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"
  },
  "documentTitle": "Avasta - Frigate",
  "generativeAI": "Generatiivne tehisaru",
@@ -64,7 +89,22 @@
      },
      "startingUp": "Käivitun…",
      "estimatedTime": "Hinnanguliselt jäänud aega:",
-      "finishingShortly": "Lõpetan õige pea"
+      "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."
    }
  },
  "type": {
@@ -107,8 +147,52 @@
    },
    "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."
+      "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"
    }
  },
-  "trackedObjectDetails": "Jälgitava objekti üksikasjad"
+  "trackedObjectDetails": "Jälgitava objekti üksikasjad",
+  "aiAnalysis": {
+    "title": "Tehisintellekti analüüs"
+  },
+  "concerns": {
+    "label": "Mured"
+  },
+  "objectLifecycle": {
+    "noImageFound": "Selle jälgitava objekti kohta ei leitud pilti."
+  }
 }
@@ -16,12 +16,15 @@
    "downloadVideo": "Laadi video alla",
    "editName": "Muuda nime",
    "deleteExport": "Kustuta eksporditud sisu",
-    "assignToCase": "Lisa juhtumile"
+    "assignToCase": "Lisa juhtumile",
+    "removeFromCase": "Eemalda juhtumist"
  },
  "toast": {
    "error": {
      "renameExportFailed": "Eksporditud sisu nime muutmine ei õnnestunud: {{errorMessage}}",
-      "assignCaseFailed": "Juhtumiga seose uuendamine ei õnnestunud: {{errorMessage}}"
+      "assignCaseFailed": "Juhtumiga seose uuendamine ei õnnestunud: {{errorMessage}}",
+      "caseSaveFailed": "Juhtumi salvestamine ei õnnestunud: {{errorMessage}}",
+      "caseDeleteFailed": "Juhtumi kustutamine ei õnnestunud: {{errorMessage}}"
    }
  },
  "headings": {
@@ -35,5 +38,44 @@
    "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"
  }
 }
@@ -1,6 +1,11 @@
 {
  "button": {
-    "uploadImage": "Laadi pilt üles"
+    "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"
  },
  "collections": "Kogumikud",
  "description": {
@@ -11,28 +16,41 @@
  },
  "documentTitle": "Näoteek - Frigate",
  "createFaceLibrary": {
-    "new": "Lisa uus nägu"
+    "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>"
  },
  "deleteFaceLibrary": {
-    "title": "Kustuta nimi"
+    "title": "Kustuta nimi",
+    "desc": "Kas oled kindel, et soovid isiku '{{name}}' kollektsiooni kustutada? See kustutab jäädavalt kõik seotud näod."
  },
  "toast": {
    "error": {
      "addFaceLibraryFailed": "Näo sidumine nimega ei õnnestunud: {{errorMessage}}",
-      "updateFaceScoreFailed": "Näo punktiskoori uuendamine 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}}"
    },
    "success": {
-      "addFaceLibrary": "Lisamine Näoteeki õnnestus: {{name}}!",
+      "addFaceLibrary": "Lisamine nägude kogusse õ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}})."
+      "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."
    }
  },
  "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."
+    "desc_other": "Kas oled kindel, et soovid kustutada {{count}} nägu? Seda tegevust ei saa tagasi pöörata.",
+    "title": "Kustuta näod"
  },
  "details": {
    "timestamp": "Ajatampel",
@@ -42,5 +60,40 @@
  "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"
 }
@@ -1,4 +1,78 @@
 {
    "documentTitle": "Liikumise tuvastus - Frigate",
-    "title": "Liikumise otsing"
+    "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}}"
 }
@@ -12,7 +12,48 @@
        "selectFromTimeline": "Vali",
        "starting": "Käivitan kordust…",
        "startLabel": "Algus",
-        "endLabel": "Lõpp"
+        "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"
+        }
    },
-    "title": "Kordus veaotsinguks"
+    "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."
+    }
 }
@@ -7,7 +7,28 @@
      "connectionSettings": "Ühenduse seadistused",
      "port": "Port",
      "username": "Kasutajanimi",
-      "usernamePlaceholder": "Valikuline"
+      "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"
    },
    "step3": {
      "streamUrlPlaceholder": "rtsp://kasutajanimi:salasõna@host:port/asukoht",
@@ -17,17 +38,37 @@
      "roles": "Rollid",
      "roleLabels": {
        "record": "Salvestamine",
-        "audio": "Heliriba"
+        "audio": "Heliriba",
+        "detect": "Objektituvastus"
      },
      "connected": "Ühendatud",
-      "featuresTitle": "Funktsionaalsused"
+      "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"
    },
    "steps": {
-      "probeOrSnapshot": "Võta proov või tee hetkvõte"
+      "probeOrSnapshot": "Võta proov või tee hetkvõte",
+      "nameAndConnection": "Nimi ja ühendus",
+      "streamConfiguration": "Voo seaded",
+      "validationAndTesting": "Valideerimine ja testimine"
    },
    "step2": {
      "testing": {
-        "fetchingSnapshot": "Laadin kaamera hetkvõtet alla..."
+        "fetchingSnapshot": "Laadin kaamera hetkvõtet alla...",
+        "probingMetadata": "Tuvastan kaamera metaandmeid..."
      },
      "retry": "Proovi uuesti",
      "manufacturer": "Tootja",
@@ -37,7 +78,30 @@
      "presets": "Eelseadistused",
      "useCandidate": "Kasuta",
      "uriCopy": "Kopeeri",
-      "connected": "Ühendatud"
+      "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}}"
    },
    "testResultLabels": {
      "resolution": "Resolutsioon",
@@ -56,7 +120,17 @@
      "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",
@@ -172,24 +246,32 @@
  },
  "documentTitle": {
    "default": "Seadistused - Frigate",
-    "authentication": "Autentimise seadistused - Frigate",
-    "cameraReview": "Kaamerate kordusvaatuste seadistused - Frigate",
-    "general": "Profiili seadistused - Frigate",
-    "frigatePlus": "Frigate+ seadistused - Frigate",
-    "notifications": "Teavituste seadistused - Frigate",
+    "authentication": "Autentimise seaded - Frigate",
+    "cameraReview": "Kaamerate kordusvaatuste seaded - Frigate",
+    "general": "Profiili seaded - Frigate",
+    "frigatePlus": "Frigate+ seaded - Frigate",
+    "notifications": "Teavituste seaded - Frigate",
    "cameraManagement": "Kaamerate haldus - Frigate",
    "masksAndZones": "Maskide ja tsoonide haldus - Frigate",
-    "object": "Silumine ja veaotsing - 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"
  },
  "general": {
-    "title": "Profiili seadistused",
+    "title": "Kasutajaliidese seadistused",
    "cameraGroupStreaming": {
      "clearAll": "Kustuta kõik voogedastuse seadistused"
    },
    "liveDashboard": {
      "title": "Töölaud reaalajas",
      "automaticLiveView": {
-        "label": "Automaatne otseülekande vaade"
+        "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."
      }
    },
    "calendar": {
@@ -335,7 +417,7 @@
  },
  "menu": {
    "ui": "Kasutajaliides",
-    "cameraManagement": "Haldus",
+    "cameraManagement": "Kaamera haldus",
    "masksAndZones": "Maskid ja tsoonid",
    "triggers": "Päästikud",
    "debug": "Silumine ja veaotsing",
@@ -373,7 +455,37 @@
    "systemMqtt": "MQTT",
    "systemGo2rtcStreams": "go2rtc voogedastus",
    "integrationSemanticSearch": "Semantiline otsing",
-    "integrationGenerativeAi": "Generatiivne tehisaru"
+    "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"
  },
  "dialog": {
    "unsavedChanges": {
@@ -389,7 +501,11 @@
    "semanticSearch": {
      "reindexNow": {
        "confirmButton": "Indekseeri uuesti",
-        "label": "Indekseeri uuesti kohe"
+        "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"
      },
      "modelSize": {
        "small": {
@@ -397,7 +513,9 @@
        },
        "large": {
          "title": "suur"
-        }
+        },
+        "label": "Mudeli suurus",
+        "desc": "Semantilise otsingu manustamiseks kasutatava mudeli suurus."
      },
      "title": "Semantiline otsing"
    },
@@ -408,14 +526,23 @@
        },
        "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": {
@@ -497,5 +624,31 @@
    "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"
+    }
  }
 }
@@ -2,7 +2,14 @@
  "documentTitle": {
    "general": "Üldine statistika - Frigate",
    "cameras": "Kaamerate statistika - Frigate",
-    "storage": "Andmeruumi 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"
  },
  "logs": {
    "download": {
@@ -16,11 +23,29 @@
    "websocket": {
      "filter": {
        "cameras_count_one": "{{count}} kaamera",
-        "cameras_count_other": "{{count}} kaamerat"
+        "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"
      },
      "empty": "Ühtegi sõnumit pole veel hõivatud",
      "count_one": "{{count}} sõnum",
-      "count_other": "{{count}} sõnumit"
+      "count_other": "{{count}} sõnumit",
+      "pause": "Peata",
+      "resume": "Jätka",
+      "label": "Sõnumid",
+      "clear": "Tühista",
+      "expanded": {
+        "payload": "Last"
+      }
    },
    "type": {
      "label": "Tüüp",
@@ -36,5 +61,170 @@
      }
    }
  },
-  "title": "Süsteem"
+  "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."
+    }
+  }
 }
@@ -67,7 +67,8 @@
      "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."
+        "noVaildTimeSelected": "La plage horaire sélectionnée n'est pas valide.",
+        "noValidTimeSelected": "Interval de temps invalide"
      },
      "success": "Exportation démarrée avec succès. Consultez le fichier sur la page des exportations.",
      "view": "Vue",
@@ -88,7 +89,9 @@
    "export": "Exporter",
    "fromTimeline": {
      "saveExport": "Enregistrer l'exportation",
-      "previewExport": "Aperçu de l'exportation"
+      "previewExport": "Aperçu de l'exportation",
+      "queueingExport": "Traitement de l'export...",
+      "useThisRange": "Utiliser cet interval"
    },
    "case": {
      "label": "Dossier",
@@ -195,6 +198,10 @@
      "markAsReviewed": "Marquer comme traité",
      "deleteNow": "Supprimer maintenant",
      "markAsUnreviewed": "Marquer comme non traité"
+    },
+    "shareTimestamp": {
+      "label": "Partager cette date",
+      "title": "Partager cette date"
    }
  },
  "imagePicker": {
@@ -24,6 +24,9 @@
        },
        "state": {
          "submitted": "Terkirim"
+        },
+        "toast": {
+          "error": "Gagal submit ke Frigate+. Harap periksa koneksi jaringan Anda dan coba lagi."
        }
      }
    },
@@ -57,7 +60,8 @@
      "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}}"
+      "batchFailed": "Gagal memulai ekspor sebanyak {{total}}. Kamera yang gagal: {{failedCameras}}",
+      "batchQueuedPartial": "Antrian ekspor berhasil sebanyak {{successful}} dari total {{total}} ekspor. Kamera yang gagal: {{failedCameras}}"
    },
    "case": {
      "newCaseOption": "Membuat Kasus Baru",
@@ -87,7 +91,9 @@
      "selectGroup": "Pilih grup",
      "noMatchingCameras": "Tidak ada kamera yang sesuai dengan pencarian Anda",
      "selectedCount": "{{terpilih}} / {{total}} terpilih",
-      "namePlaceholder": "Nama dasar opsional untuk ekspor ini"
+      "namePlaceholder": "Nama dasar opsional untuk ekspor ini",
+      "searchOrSelectGroup": "Cari, atau pilih grup kamera...",
+      "selectAll": "Pilih semua kamera"
    },
    "multi": {
      "title_other": "Ekspor {{count}} Ulasan",
@@ -68,8 +68,8 @@
  "choir": "Koris",
  "yodeling": "Jodelēšana",
  "mantra": "Mantra",
-  "rapping": "Repot",
-  "whistling": "Svilpot",
+  "rapping": "Repošana",
+  "whistling": "Svilpošana",
  "sniff": "Ošņāt",
  "hands": "Rokas",
  "animal": "Dzīvnieks",
@@ -122,5 +122,17 @@
  "fireworks": "Uguņošana",
  "glass": "Stikls",
  "white_noise": "Baltais troksnis",
-  "radio": "Radio"
+  "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"
 }
@@ -64,7 +64,8 @@
      "error": {
        "failed": "Kunne ikke legge eksport i kø: {{error}}",
        "noVaildTimeSelected": "Ingen gyldig tidsperiode valgt",
-        "endTimeMustAfterStartTime": "Sluttid må være etter starttid"
+        "endTimeMustAfterStartTime": "Sluttid må være etter starttid",
+        "noValidTimeSelected": "Ingen gyldig tidsperiode valgt"
      },
      "view": "Vis",
      "queued": "Eksport lagt i kø. Se fremdrift på eksportsiden.",
@@ -34,6 +34,9 @@
          "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."
        }
      }
    },
@@ -104,7 +107,14 @@
      "namePlaceholder": "Optionele basisnaam voor deze exporten",
      "queueingButton": "Exporten in wachtrij plaatsen...",
      "exportButton_one": "Export 1 Camera",
-      "exportButton_other": "{{count}} camera's exporteren"
+      "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"
    },
    "multi": {
      "title_one": "Review 1 exporteren",
@@ -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,7 +71,10 @@
      "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."
+      "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."
    },
    "fromTimeline": {
      "saveExport": "Salvar Exportação",
@@ -132,7 +135,10 @@
        "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}}"
+        "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."
      }
    }
  },
@@ -215,7 +215,8 @@
        "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"
+            "label": "Ativar Birdseye",
+            "description": "Habilita ou desabilita a função Birdseye."
        }
    },
    "live": {
@@ -401,7 +402,9 @@
        "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",
@@ -539,6 +542,18 @@
            "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."
            }
        }
    }
@@ -239,7 +239,8 @@
        "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"
+            "label": "Ativar Birdseye",
+            "description": "Habilita ou desabilita a função Birdseye."
        }
    },
    "live": {
@@ -420,7 +421,9 @@
        "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",
@@ -553,6 +556,18 @@
            "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."
            }
        }
    }
@@ -12,12 +12,12 @@
  },
  "toast": {
    "success": {
-      "deletedCategory_one": "Classe Apagada",
-      "deletedCategory_many": "Classes apagadas",
-      "deletedCategory_other": "",
-      "deletedImage_one": "Imagen Apagada",
-      "deletedImage_many": "Imagens Apagadas",
-      "deletedImage_other": "",
+      "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",
      "categorizedImage": "Imagem Classificada com Sucesso",
      "trainedModel": "Modelo treinado com sucesso.",
      "trainingModel": "Treinamento do modelo iniciado com sucesso.",
@@ -296,7 +296,7 @@
      }
    },
    "motionMaskLabel": "Máscara de Movimento {{number}}",
-    "objectMaskLabel": "Máscara de Objeto {{number}} ({{label}})",
+    "objectMaskLabel": "Máscara de Objeto {{number}}",
    "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 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+.",
+      "cleanCopyWarning": "Algumas câmeras estão com os snapshots desativados",
      "table": {
        "camera": "Câmera",
        "snapshots": "Capturas de Imagem",
@@ -3,7 +3,7 @@
  "machine_gun": "Mitraliera",
  "speech": "Vorbire",
  "babbling": "Murmur",
-  "yell": "Striga",
+  "yell": "Strigăt",
  "bellow": "Sub",
  "dog": "Câine",
  "horse": "Cal",
@@ -32,6 +32,9 @@
          "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": {
@@ -96,7 +99,8 @@
      "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"
+        "noVaildTimeSelected": "Nu a fost selectat un interval de timp valid",
+        "noValidTimeSelected": "Niciun interval de timp valid selectat"
      },
      "view": "Vizualizează",
      "queued": "Export pus la coadă. Vezi progresul pe pagina de exporturi.",
@@ -145,7 +149,14 @@
      "queueingButton": "Se adaugă exporturile la coadă...",
      "exportButton_one": "Exportă 1 cameră",
      "exportButton_few": "Exportă {{count}} camere",
-      "exportButton_other": "Exportă {{count}} de 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"
    },
    "multi": {
      "title_one": "Exportă o revizuire",
@@ -371,7 +371,7 @@
                "description": "Folosește snapshot-urile obiectelor în loc de miniaturi pentru GenAI."
            },
            "prompt": {
-                "label": "Prompt descriere",
+                "label": "Prompt de descriere",
                "description": "Șablonul de prompt implicit pentru descrierile GenAI."
            },
            "object_prompts": {
@@ -493,6 +493,9 @@
            "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": {
@@ -768,7 +771,7 @@
            "description": "Adresa de email folosită pentru notificări push sau cerută de anumiți furnizori de notificări."
        },
        "cooldown": {
-            "label": "Perioadă de răcire",
+            "label": "Perioadă de repaus",
            "description": "Timpul de așteptare (secunde) între notificări pentru a evita spamarea destinatarilor."
        },
        "enabled_in_config": {
@@ -217,7 +217,7 @@
    },
    "ffmpeg": {
        "label": "FFmpeg",
-        "description": "Setări FFmpeg: cale binar, argumente, accelerare hardware și ieșiri per rol.",
+        "description": "Setări FFmpeg: inclusiv calea către 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 descriere",
+                "label": "Prompt de descriere",
                "description": "Șablonul de prompt implicit pentru descrierile GenAI."
            },
            "object_prompts": {
@@ -637,6 +637,9 @@
            "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": {
@@ -952,7 +955,7 @@
            "description": "Adresa de email folosită pentru notificări push sau cerută de anumiți furnizori de notificări."
        },
        "cooldown": {
-            "label": "Perioadă de răcire",
+            "label": "Perioadă de repaus",
            "description": "Timpul de așteptare (secunde) între notificări pentru a evita spamarea destinatarilor."
        },
        "enabled_in_config": {
@@ -192,7 +192,20 @@
    "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": "Notă: Modificarea claselor de stare necesită reantrenarea modelului cu clasele actualizate."
+    "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"
+    }
  },
  "tooltip": {
    "trainingInProgress": "Modelul este în curs de antrenare",
@@ -202,5 +215,6 @@
  },
  "none": "Niciuna",
  "reclassifyImageAs": "Reclasifică imaginea ca:",
-  "reclassifyImage": "Reclasifică imaginea"
+  "reclassifyImage": "Reclasifică imaginea",
+  "disabled": "Dezactivat"
 }
@@ -120,7 +120,7 @@
    },
    "editSubLabel": {
      "title": "Editează subeticheta",
-      "desc": "Introdu o sub-etichetă nouă pentru acest {{label}}",
+      "desc": "Introdu o sub-etichetă nouă pentru acest/această {{label}}",
      "descNoLabel": "Introduceți o nouă subetichetă pentru acest obiect urmărit"
    },
    "editLPR": {
@@ -122,7 +122,7 @@
        "desc": "Arată întotdeauna numele camerelor într-un tag (chip) în dashboard-ul live multi-cameră."
      },
      "liveFallbackTimeout": {
-        "label": "Timeout Rezecție Player Live",
+        "label": "Timp de expirare pentru player-ul 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 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.",
+      "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.",
      "disabledSubheading": "Dezactivat în configurație",
      "status": {
        "on": "Pornit",
@@ -1643,7 +1643,14 @@
      "keyLabel": "Cheie",
      "valueLabel": "Valoare",
      "keyPlaceholder": "Cheie nouă",
-      "remove": "Elimină"
+      "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)"
    },
    "timezone": {
      "defaultOption": "Folosește fusul orar al browserului"
@@ -2098,6 +2105,10 @@
    },
    "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": {
@@ -1,9 +1,9 @@
 {
  "time": {
-    "untilForTime": "Do{{time}}",
+    "untilForTime": "Do {{time}}",
    "untilForRestart": "Do reštartu Frigate.",
    "untilRestart": "Do reštartu",
-    "ago": "{{timeAgo}} pred časom",
+    "ago": "pred {{timeAgo}}",
    "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}}rokov",
-    "year_other": "{{time}}rokov",
+    "year_one": "{{time}} rok",
+    "year_few": "{{time}} roky",
+    "year_other": "{{time}} rokov",
    "mo": "{{time}}mes",
-    "month_one": "{{time}}mesiac",
+    "month_one": "{{time}} mesiac",
    "month_few": "{{time}} mesiace",
-    "month_other": "{{time}} mesiaca",
+    "month_other": "{{time}} mesiacov",
    "d": "{{time}}d",
-    "day_one": "{{time}}deň",
-    "day_few": "{{time}}dni",
-    "day_other": "{{time}}dni",
+    "day_one": "{{time}} deň",
+    "day_few": "{{time}} dni",
+    "day_other": "{{time}} dní",
    "h": "{{time}}h",
-    "hour_one": "{{time}}hodina",
-    "hour_few": "{{time}}hodiny",
-    "hour_other": "{{time}}hodin",
+    "hour_one": "{{time}} hodina",
+    "hour_few": "{{time}} hodiny",
+    "hour_other": "{{time}} hodín",
    "m": "{{time}} min",
    "s": "{{time}}s",
-    "minute_one": "{{time}}minuta",
-    "minute_few": "{{time}}minuty",
-    "minute_other": "{{time}}minut",
-    "second_one": "{{time}}sekunda",
-    "second_few": "{{time}}sekundy",
-    "second_other": "{{time}}sekund",
+    "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",
    "formattedTimestamp": {
-      "12hour": "Deň MMM, h:mm:ss aaa",
-      "24hour": "Deň MMM, HH:mm:ss"
+      "12hour": "d MMM, h:mm:ss aaa",
+      "24hour": "d 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ť",
@@ -43,9 +43,9 @@
        "title": "Čas ukončenia",
        "label": "Vybrat čas ukončenia"
      },
-      "lastHour_one": "Minulu hodinu",
-      "lastHour_few": "Minule{{count}}hodiny",
-      "lastHour_other": "Minulych{{count}}hodin"
+      "lastHour_one": "Posledná hodina",
+      "lastHour_few": "Posledné {{count}} hodiny",
+      "lastHour_other": "Posledných {{count}} hodín"
    },
    "name": {
      "placeholder": "Pomenujte Export"
@@ -12,12 +12,12 @@
  },
  "toast": {
    "success": {
-      "deletedCategory_one": "Vymazaná Trieda",
-      "deletedCategory_few": "",
-      "deletedCategory_other": "",
-      "deletedImage_one": "Vymazané Obrázky",
-      "deletedImage_few": "",
-      "deletedImage_other": "",
+      "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",
      "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 štátov",
+      "title": "Žiadne modely klasifikácie stavov",
      "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": "Štátna oblasť",
+      "stateArea": "Oblasť stavu",
      "chooseExamples": "Vyberte Príklady"
    },
    "step1": {
@@ -98,7 +98,7 @@
      "name": "Meno",
      "namePlaceholder": "Zadajte názov modelu...",
      "type": "Typ",
-      "typeState": "štátu",
+      "typeState": "Stav",
      "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": "Modely štátov vyžadujú aspoň 2 triedy",
+        "stateRequiresTwoClasses": "Stavové modely vyžadujú aspoň 2 triedy",
        "objectLabelRequired": "Vyberte označenie objektu",
        "objectTypeRequired": "Vyberte typ klasifikácie",
        "noneNotAllowed": "Trieda 'none' nie je povolená"
      },
-      "states": "Štátov"
+      "states": "Stavy"
    },
    "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 hodiny kliknite na tlačidlo Pokračovať.",
+      "selectImagesDescription": "Kliknite na obrázky a vyberte ich. Po dokončení tejto triedy 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": "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ú.",
+      "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.",
      "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": "Štátov"
+    "states": "Stavy"
  },
  "details": {
    "scoreInfo": "Skóre predstavuje priemernú istotu klasifikácie naprieč všetkými detekciami tohoto objektu.",
@@ -40,8 +40,8 @@
  "detail": {
    "noDataFound": "Žiadne podrobné údaje na kontrolu",
    "aria": "Prepnúť zobrazenie detailov",
-    "trackedObject_one": "objekt",
-    "trackedObject_other": "objekty",
+    "trackedObject_one": "{{count}} objekt",
+    "trackedObject_other": "{{count}} objektov",
    "noObjectDetailData": "Nie sú k dispozícii žiadne podrobné údaje o objekte.",
    "label": "Detail",
    "settings": "Nastavenia podrobného zobrazenia",
@@ -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": "Zbierky",
+  "collections": "Kolekcie",
  "createFaceLibrary": {
    "title": "Vytvoriť Zbierku",
    "desc": "Vytvoriť novú zbierku",
    "new": "Vytvoriť novú tvár",
-    "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>"
+    "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>"
  },
  "steps": {
    "faceName": "Zadajte Meno tváre",
@@ -34,8 +34,8 @@
    }
  },
  "train": {
-    "title": "Nedávne uznania",
-    "aria": "Vyberte posledné rozpoznania",
+    "title": "Nedávno rozpoznané tváre",
+    "aria": "Vyberte nedávno rozpoznané tváre",
    "empty": "Neexistujú žiadne predchádzajúce pokusy o rozpoznávanie tváre"
  },
  "selectItem": "Vyberte {{item}}",
@@ -85,9 +85,10 @@
      "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": "Úspešne premenovaná tvár na {{name}}",
-      "trainedFace": "Úspešne natrénovaná tvár.",
-      "updatedFaceScore": "Úspešne aktualizované skóre tváre."
+      "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á."
    },
    "error": {
      "uploadingImageFailed": "Nepodarilo sa nahrať obrázok: {{errorMessage}}",
@@ -95,8 +96,9 @@
      "deleteFaceFailed": "Nepodarilo sa odstrániť: {{errorMessage}}",
      "deleteNameFailed": "Nepodarilo sa odstrániť meno: {{errorMessage}}",
      "renameFaceFailed": "Nepodarilo sa premenovať tvár: {{errorMessage}}",
-      "trainFailed": "Nepodarilo sa trénovať: {{errorMessage}}",
-      "updateFaceScoreFailed": "Nepodarilo sa aktualizovať skóre tváre: {{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}}"
    }
  }
 }
@@ -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}} {{label}}"
+    "objectMaskLabel": "Maska objektu {{number}}"
  },
  "motionDetectionTuner": {
    "title": "Ladenie detekcie pohybu",
@@ -3,7 +3,7 @@
    "cameras": "Štatistiky kamier - Frigate",
    "storage": "Štatistiky úložiska - Frigate",
    "general": "Všeobecné štatistiky - Frigate",
-    "enrichments": "Štatistiky obohatenia - Frigate",
+    "enrichments": "Štatistiky AI funkcií - Frigate",
    "logs": {
      "frigate": "Protokoly Frigate - Frigate",
      "go2rtc": "Protokoly Go2RTC - Frigate",
@@ -36,7 +36,7 @@
    }
  },
  "general": {
-    "title": "Hlavný",
+    "title": "Všeobecné",
    "detector": {
      "title": "Detektory",
      "inferenceSpeed": "Detekčná rýchlosť",
@@ -96,7 +96,7 @@
    }
  },
  "storage": {
-    "title": "Skladovanie",
+    "title": "Úložisko",
    "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 kamery",
+      "title": "Úložisko kamier",
      "camera": "Kamera",
-      "unusedStorageInformation": "Nepoužité informácie o úložisku",
-      "storageUsed": "Skladovanie",
-      "percentageOfTotalUsed": "Percento z celkového počtu",
+      "unusedStorageInformation": "Informácie o nevyužitom úložisku",
+      "storageUsed": "Úložisko",
+      "percentageOfTotalUsed": "Percento z celku",
      "bandwidth": "Šírka pásma",
      "unused": {
        "title": "Nepoužité",
@@ -125,7 +125,7 @@
    "overview": "Prehľad",
    "info": {
      "aspectRatio": "pomer strán",
-      "cameraProbeInfo": "{{camera}} Informácie o sonde kamery",
+      "cameraProbeInfo": "Údaje o kamere {{camera}}",
      "streamDataFromFFPROBE": "Údaje zo streamu sa získavajú pomocou príkazu <code>ffprobe</code>.",
      "fetching": "Načítavajú sa údaje z kamery",
      "stream": "Stream {{idx}}",
@@ -137,32 +137,33 @@
      "audio": "Zvuk:",
      "error": "Chyba: {{error}}",
      "tips": {
-        "title": "Informácie o kamerovej sonde"
+        "title": "Údaje o kamere"
      }
    },
-    "framesAndDetections": "Rámy / Detekcie",
+    "framesAndDetections": "Snímky / Detekcie",
    "label": {
      "camera": "kamera",
-      "detect": "odhaliť",
+      "detect": "detekcie",
      "skipped": "preskočené",
      "ffmpeg": "FFmpeg",
-      "capture": "zachytiť",
+      "capture": "zachytávanie",
      "cameraFfmpeg": "{{camName}} FFmpeg",
-      "cameraCapture": "zachytiť{{camName}}",
-      "cameraDetect": "Detekcia {{camName}}",
+      "cameraCapture": "{{camName}} zachytávanie",
+      "cameraDetect": "{{camName}} detekcie",
      "overallFramesPerSecond": "celkový počet snímok za sekundu",
      "overallDetectionsPerSecond": "celkový počet detekcií za sekundu",
-      "overallSkippedDetectionsPerSecond": "celkový počet vynechaných detekcií za sekundu",
+      "overallSkippedDetectionsPerSecond": "celkový počet preskočených detekcií za sekundu",
      "cameraFramesPerSecond": "{{camName}} snímky za sekundu",
-      "cameraDetectionsPerSecond": "{{camName}}detekcie za sekundu",
-      "cameraSkippedDetectionsPerSecond": "{{camName}} vynechaných detekcií za sekundu"
+      "cameraDetectionsPerSecond": "{{camName}} detekcie za sekundu",
+      "cameraSkippedDetectionsPerSecond": "{{camName}} preskočené detekcie za sekundu",
+      "cameraGpu": "{{camName}} GPU"
    },
    "toast": {
      "success": {
-        "copyToClipboard": "Dáta sondy boli skopírované do schránky."
+        "copyToClipboard": "Údaje o kamere boli skopírované do schránky."
      },
      "error": {
-        "unableToProbeCamera": "Nepodarilo sa overiť kameru: {{errorMessage}}"
+        "unableToProbeCamera": "Nepodarilo sa načítať údaje z kamery: {{errorMessage}}"
      }
    }
  },
@@ -178,7 +179,7 @@
    "shmTooLow": "Alokácia /dev/shm ({{total}} MB) by sa mala zvýšiť aspoň na {{min}} MB."
  },
  "enrichments": {
-    "title": "Obohatenia",
+    "title": "AI funkcie",
    "infPerSecond": "Inferencie za sekundu",
    "embeddings": {
      "image_embedding": "Vkladanie obrázkov",
@@ -75,5 +75,9 @@
      "24hour": "MM-dd-yy-HH-mm-ss"
    }
  },
-  "readTheDocumentation": "Прочитајте документацију"
+  "readTheDocumentation": "Прочитајте документацију",
+  "menu": {
+    "system": "Систем",
+    "profiles": "Профили"
+  }
 }
@@ -24,6 +24,9 @@
        },
        "state": {
          "submitted": "Inskickad"
+        },
+        "toast": {
+          "error": "Misslyckades att skicka till Frigate+. Kontrollera din nätverksanslutning och försök igen."
        }
      }
    },
@@ -106,7 +109,10 @@
      "selectAll": "Välj alla kameror",
      "selectWithActivity": "Kameror med spårade objekt",
      "selectGroup": "Välj grupp",
-      "noMatchingCameras": "Ingen kamera matchar din sökning"
+      "noMatchingCameras": "Ingen kamera matchar din sökning",
+      "searchOrSelectGroup": "Sök, eller välj en kameragrupp...",
+      "clearSelection": "Rensa val",
+      "selectedCount": "{{selected}} / {{total}} valda"
    },
    "multi": {
      "title_one": "Exportera 1 recension",
@@ -20,10 +20,35 @@
            "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."
+            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar.",
+            "label": "Avbryt paus"
        },
        "min_volume": {
-            "label": "Minsta ljudvolym"
+            "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."
        }
+    },
+    "audio_transcription": {
+        "label": "Ljudtranskribering"
    }
 }
@@ -8,10 +8,35 @@
            "label": "Aktivera ljuddetektering"
        },
        "max_not_heard": {
-            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar."
+            "description": "Antal sekunder utan den konfigurerade ljudtypen innan en ljudbaserad händelse slutar.",
+            "label": "Avbryt paus"
        },
        "min_volume": {
-            "label": "Minsta ljudvolym"
+            "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."
        }
+    },
+    "audio_transcription": {
+        "label": "Ljudtranskribering"
    }
 }
@@ -239,7 +239,7 @@
      "label": "主题",
      "blue": "蓝色",
      "green": "绿色",
-      "nord": "Nord",
+      "nord": "极地蓝",
      "red": "红色",
      "contrast": "高对比度",
      "default": "默认",
@@ -67,7 +67,8 @@
      "error": {
        "failed": "未能加入导出队列：{{error}}",
        "endTimeMustAfterStartTime": "结束时间必须在开始时间之后",
-        "noVaildTimeSelected": "未选择有效的时间范围"
+        "noVaildTimeSelected": "未选择有效的时间范围",
+        "noValidTimeSelected": "未选择有效的时间范围"
      },
      "view": "查看",
      "queued": "导出已加入队列。请在导出页面查看进度。",
@@ -314,12 +314,12 @@
            "description": "画面变动轮廓被计入所需的最小轮廓区域（像素）。"
        },
        "delta_alpha": {
-            "label": "Delta alpha",
-            "description": "用于画面变动计算的帧差异中使用的 alpha 混合因子。"
+            "label": "变化量权重",
+            "description": "该值用于调节帧间差异计算时的混合比例，影响运动检测的灵敏度。"
        },
        "frame_alpha": {
-            "label": "画面 alpha 通道",
-            "description": "画面变动预处理时混合画面所使用的 alpha 值。"
+            "label": "背景更新速度",
+            "description": "该值在运动检测前对画面进行预处理，控制帧混合程度，影响后续检测的输入质量。"
        },
        "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": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
+                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
                }
            }
        },
@@ -510,7 +510,7 @@
                },
                "mode": {
                    "label": "保留模式",
-                    "description": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
+                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
                }
            }
        },
@@ -1507,10 +1507,10 @@
    },
    "motion": {
        "label": "画面变动检测",
-        "description": "应用于摄像头的默认动作检测设置，除非按摄像头覆盖。",
+        "description": "默认情况下，画面变动检测配置统一应用于各摄像头，除非对特定摄像头单独进行自定义。",
        "enabled": {
            "label": "开启画面变动检测",
-            "description": "为所有摄像头启用或禁用动作检测；可按摄像头覆盖。"
+            "description": "为所有摄像头启用或禁用画面变动检测。可以给指定摄像头单独覆盖此设置。"
        },
        "threshold": {
            "label": "画面变动阈值",
@@ -1533,12 +1533,12 @@
            "description": "画面变动轮廓被计入所需的最小轮廓区域（像素）。"
        },
        "delta_alpha": {
-            "label": "Delta alpha",
-            "description": "用于画面变动计算的帧差异中使用的 alpha 混合因子。"
+            "label": "变化量权重",
+            "description": "该值用于调节帧间差异计算时的混合比例，影响运动检测的灵敏度。"
        },
        "frame_alpha": {
-            "label": "画面 alpha 通道",
-            "description": "画面变动预处理时混合画面所使用的 alpha 值。"
+            "label": "背景更新速度",
+            "description": "该值在运动检测前对画面进行预处理，控制帧混合程度，影响后续检测的输入质量。"
        },
        "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": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
+                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
                }
            }
        },
@@ -1764,7 +1764,7 @@
                },
                "mode": {
                    "label": "保留模式",
-                    "description": "保留模式：all（保存所有片段）、motion（保存有动作的片段）或 active_objects（保存有活动目标的片段）。"
+                    "description": "保留模式：全部（保存所有片段）、画面变动（保存有画面变动的片段）或 活动目标（保存有活动目标的片段）。"
                }
            }
        },
@@ -2030,8 +2030,8 @@
                    }
                },
                "motion": {
-                    "label": "动作时运行",
-                    "description": "启用后，当在指定裁剪区域内检测到动作时运行分类。"
+                    "label": "画面变动时运行",
+                    "description": "启用后，当在指定裁剪区域内检测到画面变动时进行分类。"
                },
                "interval": {
                    "label": "分类间隔",
@@ -178,7 +178,20 @@
    "title": "编辑分类模型",
    "descriptionState": "编辑此状态分类模型的类别；更改后需要重新训练模型。",
    "descriptionObject": "编辑此目标分类模型的目标类型和分类类型。",
-    "stateClassesInfo": "注意：更改状态类别后需使用更新后的类别重新训练模型。"
+    "stateClassesInfo": "模型已更新。请重新训练模型以使类别更改生效。",
+    "enabled": "开启",
+    "enabledDesc": "运行此模型。禁用后，它将停止运行且不再进行分类。",
+    "saveAttempts": "保存尝试",
+    "saveAttemptsDesc": "保存在近期分类记录界面中显示的分类快照数量。",
+    "motion": "画面变动时运行",
+    "motionDesc": "检测到配置的裁剪区域内发生移动时，运行分类。",
+    "interval": "间隔",
+    "intervalDesc": "定期分类运行之间的间隔秒数。留空则仅在检测到移动时运行。",
+    "intervalPlaceholder": "无间隔",
+    "errors": {
+      "saveAttemptsInvalid": "保存在近期分类记录数量必须是大于或等于 0 的整数",
+      "intervalInvalid": "间隔必须是大于 0 的整数"
+    }
  },
  "tooltip": {
    "trainingInProgress": "模型正在训练中",
@@ -188,5 +201,6 @@
  },
  "none": "无标签",
  "reclassifyImageAs": "重新分类图片为：",
-  "reclassifyImage": "重新分类图片"
+  "reclassifyImage": "重新分类图片",
+  "disabled": "关闭"
 }
@@ -1655,7 +1655,14 @@
      "keyLabel": "键",
      "valueLabel": "值",
      "keyPlaceholder": "新键名",
-      "remove": "移除"
+      "remove": "移除",
+      "providerNameLabel": "提供商名称",
+      "providerNamePlaceholder": "例如：openai、deepseek",
+      "variableNameLabel": "变量名",
+      "variableNamePlaceholder": "例如：MY_VARIABLE",
+      "loggerNameLabel": "日志模块名称",
+      "loggerNamePlaceholder": "例如：frigate.record",
+      "keyPatternError": "只能使用字母、数字、连字符和下划线（不包含空格）"
    },
    "roleMap": {
      "empty": "未配置权限组映射",
@@ -59,7 +59,8 @@
      "error": {
        "failed": "匯出失敗：{{error}}",
        "endTimeMustAfterStartTime": "結束時間必須要在開始時間之後",
-        "noVaildTimeSelected": "沒有選取有效的時間範圍"
+        "noVaildTimeSelected": "沒有選取有效的時間範圍",
+        "noValidTimeSelected": "未選擇有效的時間範圍"
      },
      "view": "查看",
      "queued": "匯出已加入佇列。請在匯出頁面檢視進度。",
@@ -497,6 +497,9 @@
            "max_concurrent": {
                "label": "最大併發匯出數",
                "description": "同時可處理的最大匯出任務數量。"
+            },
+            "chapters": {
+                "label": "匯出錄影時要嵌入的章節資訊"
            }
        },
        "preview": {
@@ -1043,6 +1043,9 @@
            "max_concurrent": {
                "label": "最大併發匯出數",
                "description": "同時可處理的最大匯出任務數量。"
+            },
+            "chapters": {
+                "label": "匯出錄影時要嵌入的章節資訊"
            }
        },
        "preview": {
--- a/Show More
+++ b/Show More